virtualx-engine/thirdparty/bullet/Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h

#ifndef B3_OPENCL_ARRAY_H
#define B3_OPENCL_ARRAY_H

#include "Bullet3Common/b3AlignedObjectArray.h"
#include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h"

template <typename T>
class b3OpenCLArray
{
	size_t m_size;
	size_t m_capacity;
	cl_mem m_clBuffer;

	cl_context m_clContext;
	cl_command_queue m_commandQueue;

	bool m_ownsMemory;

	bool m_allowGrowingCapacity;

	void deallocate()
	{
		if (m_clBuffer && m_ownsMemory)
		{
			clReleaseMemObject(m_clBuffer);
		}
		m_clBuffer = 0;
		m_capacity = 0;
	}

	b3OpenCLArray<T>& operator=(const b3OpenCLArray<T>& src);

	B3_FORCE_INLINE size_t allocSize(size_t size)
	{
		return (size ? size * 2 : 1);
	}

public:
	b3OpenCLArray(cl_context ctx, cl_command_queue queue, size_t initialCapacity = 0, bool allowGrowingCapacity = true)
		: m_size(0), m_capacity(0), m_clBuffer(0), m_clContext(ctx), m_commandQueue(queue), m_ownsMemory(true), m_allowGrowingCapacity(true)
	{
		if (initialCapacity)
		{
			reserve(initialCapacity);
		}
		m_allowGrowingCapacity = allowGrowingCapacity;
	}

	///this is an error-prone method with no error checking, be careful!
	void setFromOpenCLBuffer(cl_mem buffer, size_t sizeInElements)
	{
		deallocate();
		m_ownsMemory = false;
		m_allowGrowingCapacity = false;
		m_clBuffer = buffer;
		m_size = sizeInElements;
		m_capacity = sizeInElements;
	}

	// we could enable this assignment, but need to make sure to avoid accidental deep copies
	//	b3OpenCLArray<T>& operator=(const b3AlignedObjectArray<T>& src)
	//	{
	//		copyFromArray(src);
	//		return *this;
	//	}

	cl_mem getBufferCL() const
	{
		return m_clBuffer;
	}

	virtual ~b3OpenCLArray()
	{
		deallocate();
		m_size = 0;
		m_capacity = 0;
	}

	B3_FORCE_INLINE bool push_back(const T& _Val, bool waitForCompletion = true)
	{
		bool result = true;
		size_t sz = size();
		if (sz == capacity())
		{
			result = reserve(allocSize(size()));
		}
		copyFromHostPointer(&_Val, 1, sz, waitForCompletion);
		m_size++;
		return result;
	}

	B3_FORCE_INLINE T forcedAt(size_t n) const
	{
		b3Assert(n >= 0);
		b3Assert(n < capacity());
		T elem;
		copyToHostPointer(&elem, 1, n, true);
		return elem;
	}

	B3_FORCE_INLINE T at(size_t n) const
	{
		b3Assert(n >= 0);
		b3Assert(n < size());
		T elem;
		copyToHostPointer(&elem, 1, n, true);
		return elem;
	}

	B3_FORCE_INLINE bool resize(size_t newsize, bool copyOldContents = true)
	{
		bool result = true;
		size_t curSize = size();

		if (newsize < curSize)
		{
			//leave the OpenCL memory for now
		}
		else
		{
			if (newsize > size())
			{
				result = reserve(newsize, copyOldContents);
			}

			//leave new data uninitialized (init in debug mode?)
			//for (size_t i=curSize;i<newsize;i++) ...
		}

		if (result)
		{
			m_size = newsize;
		}
		else
		{
			m_size = 0;
		}
		return result;
	}

	B3_FORCE_INLINE size_t size() const
	{
		return m_size;
	}

	B3_FORCE_INLINE size_t capacity() const
	{
		return m_capacity;
	}

	B3_FORCE_INLINE bool reserve(size_t _Count, bool copyOldContents = true)
	{
		bool result = true;
		// determine new minimum length of allocated storage
		if (capacity() < _Count)
		{  // not enough room, reallocate

			if (m_allowGrowingCapacity)
			{
				cl_int ciErrNum;
				//create a new OpenCL buffer
				size_t memSizeInBytes = sizeof(T) * _Count;
				cl_mem buf = clCreateBuffer(m_clContext, CL_MEM_READ_WRITE, memSizeInBytes, NULL, &ciErrNum);
				if (ciErrNum != CL_SUCCESS)
				{
					b3Error("OpenCL out-of-memory\n");
					_Count = 0;
					result = false;
				}
//#define B3_ALWAYS_INITIALIZE_OPENCL_BUFFERS
#ifdef B3_ALWAYS_INITIALIZE_OPENCL_BUFFERS
				unsigned char* src = (unsigned char*)malloc(memSizeInBytes);
				for (size_t i = 0; i < memSizeInBytes; i++)
					src[i] = 0xbb;
				ciErrNum = clEnqueueWriteBuffer(m_commandQueue, buf, CL_TRUE, 0, memSizeInBytes, src, 0, 0, 0);
				b3Assert(ciErrNum == CL_SUCCESS);
				clFinish(m_commandQueue);
				free(src);
#endif  //B3_ALWAYS_INITIALIZE_OPENCL_BUFFERS

				if (result)
				{
					if (copyOldContents)
						copyToCL(buf, size());
				}

				//deallocate the old buffer
				deallocate();

				m_clBuffer = buf;

				m_capacity = _Count;
			}
			else
			{
				//fail: assert and
				b3Assert(0);
				deallocate();
				result = false;
			}
		}
		return result;
	}

	void copyToCL(cl_mem destination, size_t numElements, size_t firstElem = 0, size_t dstOffsetInElems = 0) const
	{
		if (numElements <= 0)
			return;

		b3Assert(m_clBuffer);
		b3Assert(destination);

		//likely some error, destination is same as source
		b3Assert(m_clBuffer != destination);

		b3Assert((firstElem + numElements) <= m_size);

		cl_int status = 0;

		b3Assert(numElements > 0);
		b3Assert(numElements <= m_size);

		size_t srcOffsetBytes = sizeof(T) * firstElem;
		size_t dstOffsetInBytes = sizeof(T) * dstOffsetInElems;

		status = clEnqueueCopyBuffer(m_commandQueue, m_clBuffer, destination,
									 srcOffsetBytes, dstOffsetInBytes, sizeof(T) * numElements, 0, 0, 0);

		b3Assert(status == CL_SUCCESS);
	}

	void copyFromHost(const b3AlignedObjectArray<T>& srcArray, bool waitForCompletion = true)
	{
		size_t newSize = srcArray.size();

		bool copyOldContents = false;
		resize(newSize, copyOldContents);
		if (newSize)
			copyFromHostPointer(&srcArray[0], newSize, 0, waitForCompletion);
	}

	void copyFromHostPointer(const T* src, size_t numElems, size_t destFirstElem = 0, bool waitForCompletion = true)
	{
		b3Assert(numElems + destFirstElem <= capacity());

		if (numElems + destFirstElem)
		{
			cl_int status = 0;
			size_t sizeInBytes = sizeof(T) * numElems;
			status = clEnqueueWriteBuffer(m_commandQueue, m_clBuffer, 0, sizeof(T) * destFirstElem, sizeInBytes,
										  src, 0, 0, 0);
			b3Assert(status == CL_SUCCESS);
			if (waitForCompletion)
				clFinish(m_commandQueue);
		}
		else
		{
			b3Error("copyFromHostPointer invalid range\n");
		}
	}

	void copyToHost(b3AlignedObjectArray<T>& destArray, bool waitForCompletion = true) const
	{
		destArray.resize(this->size());
		if (size())
			copyToHostPointer(&destArray[0], size(), 0, waitForCompletion);
	}

	void copyToHostPointer(T* destPtr, size_t numElem, size_t srcFirstElem = 0, bool waitForCompletion = true) const
	{
		b3Assert(numElem + srcFirstElem <= capacity());

		if (numElem + srcFirstElem <= capacity())
		{
			cl_int status = 0;
			status = clEnqueueReadBuffer(m_commandQueue, m_clBuffer, 0, sizeof(T) * srcFirstElem, sizeof(T) * numElem,
										 destPtr, 0, 0, 0);
			b3Assert(status == CL_SUCCESS);

			if (waitForCompletion)
				clFinish(m_commandQueue);
		}
		else
		{
			b3Error("copyToHostPointer invalid range\n");
		}
	}

	void copyFromOpenCLArray(const b3OpenCLArray& src)
	{
		size_t newSize = src.size();
		resize(newSize);
		if (size())
		{
			src.copyToCL(m_clBuffer, size());
		}
	}
};

#endif  //B3_OPENCL_ARRAY_H