Switching to CFFI.

fynv · May 9, 2020 · 1b8cb1d · 1b8cb1d
1 parent 23cc74d
commit 1b8cb1d
Show file tree

Hide file tree

Showing 108 changed files with 2,594 additions and 2,686 deletions.
diff --git a/DVTuple.cpp b/DVTuple.cpp
@@ -18,11 +18,6 @@ DVTuple::DVTuple(const std::vector<CapturedDeviceViewable>& elem_map)
 	TRTC_Query_Struct(m_name_view_cls.c_str(), name_elems, m_offsets.data());
 }
 
-std::string DVTuple::name_view_cls() const
-{
-	return m_name_view_cls;
-}
-
 ViewBuf DVTuple::view() const
 {
 	ViewBuf ret(m_offsets[m_offsets.size() - 1]);

diff --git a/DVTuple.h b/DVTuple.h
@@ -9,12 +9,9 @@ class THRUST_RTC_API DVTuple : public DeviceViewable
 {
 public:
 	DVTuple(const std::vector<CapturedDeviceViewable>& elem_map);
-
-	virtual std::string name_view_cls() const;
 	virtual ViewBuf view() const;
 
 private:
-	std::string m_name_view_cls;
 	std::vector<ViewBuf> m_view_elems;
 	std::vector<size_t> m_offsets;
 

diff --git a/DVVector.cpp b/DVVector.cpp
@@ -20,6 +20,8 @@ DVVector::DVVector(const char* elem_cls, size_t size, void* hdata)
 		cuMemcpyHtoD(dptr, hdata, m_elem_size*m_size);
 	else
 		cuMemsetD8(dptr, 0, m_elem_size*m_size);
+
+	m_name_view_cls = std::string("VectorView<") + m_elem_cls + ">";
 }
 
 DVVector::~DVVector()
@@ -34,11 +36,6 @@ void DVVector::to_host(void* hdata, size_t begin, size_t end) const
 	cuMemcpyDtoH(hdata, (CUdeviceptr)((char*)m_data + begin* m_elem_size), m_elem_size*n);
 }
 
-std::string DVVector::name_view_cls() const
-{
-	return std::string("VectorView<") + m_elem_cls + ">";
-}
-
 ViewBuf DVVector::view() const
 {
 	ViewBuf buf(sizeof(VectorView<char>));
@@ -49,26 +46,26 @@ ViewBuf DVVector::view() const
 }
 
 DVVectorAdaptor::DVVectorAdaptor(const char* elem_cls, size_t size, void* ddata)
-	: DVVectorLike(elem_cls, (std::string(elem_cls) + "&").c_str(), size), m_data(ddata){}
+	: DVVectorLike(elem_cls, (std::string(elem_cls) + "&").c_str(), size), m_data(ddata)
+{
+	m_name_view_cls = std::string("VectorView<") + m_elem_cls + ">";
+}
 
 DVVectorAdaptor::DVVectorAdaptor(const DVVector& vec, size_t begin, size_t end)
 	: DVVectorLike(vec.name_elem_cls().c_str(), vec.name_ref_type().c_str(), (end == (size_t)(-1)? vec.size() : end) - begin)
 {
 	m_data = (char*)vec.data() + begin * vec.elem_size();
+	m_name_view_cls = std::string("VectorView<") + m_elem_cls + ">";
 }
 
 DVVectorAdaptor::DVVectorAdaptor(const DVVectorAdaptor& vec, size_t begin, size_t end)
 	: DVVectorLike(vec.name_elem_cls().c_str(), vec.name_ref_type().c_str(), (end == (size_t)(-1) ? vec.size() : end) - begin)
 {
 	m_data = (char*)vec.data() + begin * vec.elem_size();
+	m_name_view_cls = std::string("VectorView<") + m_elem_cls + ">";
 }
 
 
-std::string DVVectorAdaptor::name_view_cls() const
-{
-	return std::string("VectorView<") + m_elem_cls + ">";
-}
-
 ViewBuf DVVectorAdaptor::view() const
 {
 	ViewBuf buf(sizeof(VectorView<char>));

diff --git a/DVVector.h b/DVVector.h
@@ -8,8 +8,8 @@
 class THRUST_RTC_API DVVectorLike : public DeviceViewable
 {
 public:
-	std::string name_elem_cls() const { return m_elem_cls; }
-	std::string name_ref_type() const { return m_ref_type; }
+	const std::string& name_elem_cls() const { return m_elem_cls; }
+	const std::string& name_ref_type() const { return m_ref_type; }
 	size_t elem_size() const { return m_elem_size; }
 	size_t size() const { return m_size; }
 
@@ -35,7 +35,6 @@ class THRUST_RTC_API DVVector : public DVVectorLike
 	virtual bool is_writable() const { return true; }
 
 	void to_host(void* hdata, size_t begin=0, size_t end = (size_t)(-1)) const;
-	virtual std::string name_view_cls() const;
 	virtual ViewBuf view() const;
 
 private:
@@ -53,8 +52,6 @@ class THRUST_RTC_API DVVectorAdaptor : public DVVectorLike
 	DVVectorAdaptor(const DVVectorAdaptor& vec, size_t begin = 0, size_t end = (size_t)(-1));
 
 	virtual bool is_writable() const { return true; }
-
-	virtual std::string name_view_cls() const;
 	virtual ViewBuf view() const;
 
 private:

diff --git a/DeviceViewable.h b/DeviceViewable.h
@@ -14,8 +14,11 @@ class DeviceViewable
 public:
 	DeviceViewable(){}
 	virtual ~DeviceViewable(){}
-	virtual std::string name_view_cls() const = 0;
 	virtual ViewBuf view() const = 0;
+	const std::string& name_view_cls() const { return m_name_view_cls; }
+
+protected:
+	std::string m_name_view_cls;
 };
 
 
@@ -36,18 +39,12 @@ class BuiltIn : public DeviceViewable
 		memcpy(m_view_buf.data(), data_view, size_view);
 	}
 
-	virtual std::string name_view_cls() const
-	{
-		return m_name_view_cls;
-	}
-
 	virtual ViewBuf view() const
 	{
 		return m_view_buf;
 	}
 
 private:
-	std::string m_name_view_cls;
 	ViewBuf m_view_buf;
 };
 
@@ -84,4 +81,51 @@ DECLAR_DV_BASIC(DVUInt64, uint64_t)
 
 DECLAR_DV_BASIC(DVSizeT, size_t)
 
+
+class SomeDeviceViewable : public DeviceViewable
+{
+public:
+	SomeDeviceViewable(const ViewBuf& buf, const char* type)
+	{
+		m_buf = buf;
+		m_name_view_cls = type;
+
+	}
+	virtual ViewBuf view() const
+	{
+		return m_buf;
+	}
+private:
+	ViewBuf m_buf;
+};
+
+inline DeviceViewable* dv_from_viewbuf(const ViewBuf& buf, const char* type)
+{
+	std::string s_type = type;
+	if (s_type == "int8_t")
+		return new DVInt8(*(int8_t*)buf.data());
+	else if (s_type == "uint8_t")
+		return new DVUInt8(*(uint8_t*)buf.data());
+	else if (s_type == "int16_t")
+		return new DVInt16(*(int16_t*)buf.data());
+	else if (s_type == "uint16_t")
+		return new DVUInt16(*(uint16_t*)buf.data());
+	else if (s_type == "int32_t")
+		return new DVInt32(*(int32_t*)buf.data());
+	else if (s_type == "uint32_t")
+		return new DVUInt32(*(uint32_t*)buf.data());
+	else if (s_type == "int64_t")
+		return new DVInt64(*(int64_t*)buf.data());
+	else if (s_type == "uint64_t")
+		return new DVUInt64(*(uint64_t*)buf.data());
+	else if (s_type == "float")
+		return new DVFloat(*(float*)buf.data());
+	else if (s_type == "double")
+		return new DVDouble(*(double*)buf.data());
+	else if (s_type == "bool")
+		return new DVBool(*(bool*)buf.data());
+	else
+		return new SomeDeviceViewable(buf, type);
+}
+
 #endif
diff --git a/docs/QuickStartGuide.md b/docs/QuickStartGuide.md
@@ -29,7 +29,6 @@ At build time, you will only need:
 
 * UnQLite source code, as submodule: thirdparty/unqlite
 * CMake 3.x
-* C libraries of Python 3 is required to build the Python binding part of the code.
 
 After cloning the repo from github and resolving the submodules, you can build it with CMake.
 Libraries for different lauguages are now built separately. The C++ library is used as a 
@@ -57,7 +56,7 @@ You will get the library headers, binaries and examples in the "install" directo
 
 #### Install ThrustRTC for Python from Pypi
 
-Builds for Win64/Linux64 + Python 3.7 are available from [Pypi](https://pypi.org/project/ThrustRTC/)
+Builds for Win64/Linux64 + Python 3.x are available from [Pypi](https://pypi.org/project/ThrustRTC/)
 If your environment matches, you can try:
 
 ```
@@ -90,6 +89,7 @@ Zip packages are available at:
 
 For Python
 * Python 3
+* cffi
 * numpy
 * numba (optional)
 

diff --git a/fake_vectors/DVConstant.cpp b/fake_vectors/DVConstant.cpp
@@ -4,15 +4,9 @@
 DVConstant::DVConstant(const DeviceViewable& dvobj, size_t size) :
 	DVVectorLike(dvobj.name_view_cls().c_str(), (std::string("const ") + dvobj.name_view_cls() + "&").c_str(), size)
 {
-	m_value = dvobj.view();
-
-	std::string name_struct = name_view_cls();
-	TRTC_Query_Struct(name_struct.c_str(), { "_size", "_value" }, m_offsets);
-}
-
-std::string DVConstant::name_view_cls() const
-{
-	return std::string("ConstantView<") + m_elem_cls + ">";
+	m_value = dvobj.view();	
+	m_name_view_cls = std::string("ConstantView<") + m_elem_cls + ">";
+	TRTC_Query_Struct(m_name_view_cls.c_str(), { "_size", "_value" }, m_offsets);
 }
 
 ViewBuf DVConstant::view() const

diff --git a/fake_vectors/DVConstant.h b/fake_vectors/DVConstant.h
@@ -8,7 +8,6 @@ class THRUST_RTC_API DVConstant : public DVVectorLike
 public:
 	ViewBuf value() const { return m_value; }
 	DVConstant(const DeviceViewable& dvobj, size_t size = (size_t)(-1));
-	virtual std::string name_view_cls() const;
 	virtual ViewBuf view() const;
 
 private:

diff --git a/fake_vectors/DVCounter.cpp b/fake_vectors/DVCounter.cpp
@@ -5,14 +5,8 @@ DVCounter::DVCounter(const DeviceViewable& dvobj_init, size_t size) :
 	DVVectorLike(dvobj_init.name_view_cls().c_str(), dvobj_init.name_view_cls().c_str(), size)
 {
 	m_value_init = dvobj_init.view();
-
-	std::string name_struct = name_view_cls();
-	TRTC_Query_Struct(name_struct.c_str(), { "_size", "_value_init" }, m_offsets);
-}
-
-std::string DVCounter::name_view_cls() const
-{
-	return std::string("CounterView<") + m_elem_cls + ">";
+	m_name_view_cls = std::string("CounterView<") + m_elem_cls + ">";
+	TRTC_Query_Struct(m_name_view_cls.c_str(), { "_size", "_value_init" }, m_offsets);
 }
 
 ViewBuf DVCounter::view() const

diff --git a/fake_vectors/DVCounter.h b/fake_vectors/DVCounter.h
@@ -8,7 +8,6 @@ class THRUST_RTC_API DVCounter : public DVVectorLike
 public:
 	ViewBuf value_init() const { return m_value_init; }
 	DVCounter(const DeviceViewable& dvobj_init, size_t size = (size_t)(-1));
-	virtual std::string name_view_cls() const;
 	virtual ViewBuf view() const;
 
 private:

diff --git a/fake_vectors/DVCustomVector.cpp b/fake_vectors/DVCustomVector.cpp
@@ -38,12 +38,6 @@ DVCustomVector::DVCustomVector(const std::vector<CapturedDeviceViewable>& arg_ma
 	TRTC_Query_Struct(m_name_view_cls.c_str(), { "_size", "_op" }, m_offsets);
 }
 
-
-std::string DVCustomVector::name_view_cls() const
-{
-	return m_name_view_cls;
-}
-
 ViewBuf DVCustomVector::view() const
 {
 	ViewBuf view_op(m_arg_offsets[m_arg_offsets.size() - 1]);

diff --git a/fake_vectors/DVCustomVector.h b/fake_vectors/DVCustomVector.h
@@ -11,13 +11,11 @@ class THRUST_RTC_API DVCustomVector : public DVVectorLike
 	DVCustomVector(const std::vector<CapturedDeviceViewable>& arg_map, const char* name_idx, const char* code_body,
 		const char* elem_cls, size_t size = (size_t)(-1), bool read_only = true);
 
-	virtual std::string name_view_cls() const;
 	virtual ViewBuf view() const;
 
 	virtual bool is_writable() const { return !m_read_only; }
 
 private:
-	std::string m_name_view_cls;
 	size_t m_size;
 	bool m_read_only;
 	std::vector<ViewBuf> m_view_args;

diff --git a/fake_vectors/DVDiscard.cpp b/fake_vectors/DVDiscard.cpp
@@ -1,11 +1,9 @@
 #include "DVDiscard.h"
 
 DVDiscard::DVDiscard(const char* elem_cls, size_t size)
-	:DVVectorLike(elem_cls, (std::string("_Sink<")+ elem_cls +">&").c_str(), size){}
-
-std::string DVDiscard::name_view_cls() const
+	:DVVectorLike(elem_cls, (std::string("_Sink<")+ elem_cls +">&").c_str(), size)
 {
-	return std::string("DiscardView<") + m_elem_cls + ">";
+	m_name_view_cls = std::string("DiscardView<") + m_elem_cls + ">";
 }
 
 ViewBuf DVDiscard::view() const

diff --git a/fake_vectors/DVDiscard.h b/fake_vectors/DVDiscard.h
@@ -7,7 +7,6 @@ class THRUST_RTC_API DVDiscard : public DVVectorLike
 {
 public:
 	DVDiscard(const char* elem_cls, size_t size = (size_t)(-1));
-	virtual std::string name_view_cls() const;
 	virtual ViewBuf view() const;
 	virtual bool is_readable() const { return false; }
 	virtual bool is_writable() const { return true; }

diff --git a/fake_vectors/DVPermutation.cpp b/fake_vectors/DVPermutation.cpp
@@ -11,13 +11,9 @@ DVPermutation::DVPermutation(const DVVectorLike& vec_value, const DVVectorLike&
 	m_cls_index = vec_index.name_view_cls();
 	m_view_index = vec_index.view();
 
-	std::string name_struct = name_view_cls();
-	TRTC_Query_Struct(name_struct.c_str(), { "_view_vec_value", "_view_vec_index" }, m_offsets);
-}
+	m_name_view_cls = std::string("PermutationView<") + m_cls_value + ", " + m_cls_index + ">";
+	TRTC_Query_Struct(m_name_view_cls.c_str(), { "_view_vec_value", "_view_vec_index" }, m_offsets);
 
-std::string DVPermutation::name_view_cls() const
-{
-	return std::string("PermutationView<") + m_cls_value + ", "+ m_cls_index+">";
 }
 
 ViewBuf DVPermutation::view() const

diff --git a/fake_vectors/DVPermutation.h b/fake_vectors/DVPermutation.h
@@ -12,7 +12,6 @@ class THRUST_RTC_API DVPermutation : public DVVectorLike
 	ViewBuf view_index() const { return m_view_index;  }
 
 	DVPermutation(const DVVectorLike& vec_value, const DVVectorLike& vec_index );
-	virtual std::string name_view_cls() const;
 	virtual ViewBuf view() const;
 	virtual bool is_readable() const { return m_readable; }
 	virtual bool is_writable() const { return m_writable; }

diff --git a/fake_vectors/DVRange.cpp b/fake_vectors/DVRange.cpp
@@ -12,14 +12,10 @@ DVRange::DVRange(const DVVectorLike& vec_value, size_t begin, size_t end)
 	m_begin = begin;
 	m_end = end;
 
-	std::string name_struct = name_view_cls();
-	TRTC_Query_Struct(name_struct.c_str(), { "_view_vec_value", "_begin", "_end" }, m_offsets);
+	m_name_view_cls = std::string("RangeView<") + m_cls_value + ">";
+	TRTC_Query_Struct(m_name_view_cls.c_str(), { "_view_vec_value", "_begin", "_end" }, m_offsets);
 }
 
-std::string DVRange::name_view_cls() const
-{
-	return std::string("RangeView<") + m_cls_value + ">";
-}
 
 ViewBuf DVRange::view() const
 {

diff --git a/fake_vectors/DVRange.h b/fake_vectors/DVRange.h
@@ -10,7 +10,6 @@ class THRUST_RTC_API DVRange : public DVVectorLike
 	ViewBuf view_value() const { return m_view_value; }
 
 	DVRange(const DVVectorLike& vec_value, size_t begin = 0, size_t end = (size_t)(-1));
-	virtual std::string name_view_cls() const;
 	virtual ViewBuf view() const;
 	virtual bool is_readable() const { return m_readable; }
 	virtual bool is_writable() const { return m_writable; }

diff --git a/fake_vectors/DVReverse.cpp b/fake_vectors/DVReverse.cpp
@@ -8,15 +8,10 @@ DVReverse::DVReverse(const DVVectorLike& vec_value)
 	m_writable = vec_value.is_writable();
 	m_cls_value = vec_value.name_view_cls();
 	m_view_value = vec_value.view();
-}
-
 
-std::string DVReverse::name_view_cls() const
-{
-	return std::string("ReverseView<") + m_cls_value + ">";
+	m_name_view_cls = std::string("ReverseView<") + m_cls_value + ">";
 }
 
-
 ViewBuf DVReverse::view() const
 {
 	ViewBuf buf(m_view_value.size());

diff --git a/fake_vectors/DVReverse.h b/fake_vectors/DVReverse.h
@@ -10,7 +10,6 @@ class THRUST_RTC_API DVReverse : public DVVectorLike
 	ViewBuf view_value() const { return m_view_value; }
 
 	DVReverse(const DVVectorLike& vec_value);
-	virtual std::string name_view_cls() const;
 	virtual ViewBuf view() const;
 	virtual bool is_readable() const { return m_readable; }
 	virtual bool is_writable() const { return m_writable; }