noahbackus/godot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Update Bullet to the latest commit 126b676

Browse Source
This commit is contained in:
Oussama
2019-01-03 14:26:51 +01:00
committed by Rémi Verschelde
parent a6722cf362
commit 22b7c9dfa8
612 changed files with 114715 additions and 103413 deletions
Download Patch File Download Diff File Expand all files Collapse all files
thirdparty/bullet/Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h
Vendored
+84 -90
View File
@@ -7,16 +7,16 @@
template <typename T>
class b3OpenCLArray
{
size_t m_size;
size_t m_capacity;
cl_mem m_clBuffer;
size_t m_size;
size_t m_capacity;
cl_mem m_clBuffer;
cl_context m_clContext;
cl_context m_clContext;
cl_command_queue m_commandQueue;
bool m_ownsMemory;
bool m_ownsMemory;
bool m_allowGrowingCapacity;
bool m_allowGrowingCapacity;
void deallocate()
{
@@ -25,22 +25,19 @@ class b3OpenCLArray
clReleaseMemObject(m_clBuffer);
}
m_clBuffer = 0;
m_capacity=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);
}
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)
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)
{
@@ -60,34 +57,32 @@ public:
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;
// }
// 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
cl_mem getBufferCL() const
{
return m_clBuffer;
}
virtual ~b3OpenCLArray()
{
deallocate();
m_size=0;
m_capacity=0;
m_size = 0;
m_capacity = 0;
}
B3_FORCE_INLINE bool push_back(const T& _Val,bool waitForCompletion=true)
B3_FORCE_INLINE bool push_back(const T& _Val, bool waitForCompletion = true)
{
bool result = true;
size_t sz = size();
if( sz == capacity() )
if (sz == capacity())
{
result = reserve( allocSize(size()) );
result = reserve(allocSize(size()));
}
copyFromHostPointer(&_Val, 1, sz, waitForCompletion);
m_size++;
@@ -96,23 +91,23 @@ public:
B3_FORCE_INLINE T forcedAt(size_t n) const
{
b3Assert(n>=0);
b3Assert(n<capacity());
b3Assert(n >= 0);
b3Assert(n < capacity());
T elem;
copyToHostPointer(&elem,1,n,true);
copyToHostPointer(&elem, 1, n, true);
return elem;
}
B3_FORCE_INLINE T at(size_t n) const
{
b3Assert(n>=0);
b3Assert(n<size());
b3Assert(n >= 0);
b3Assert(n < size());
T elem;
copyToHostPointer(&elem,1,n,true);
copyToHostPointer(&elem, 1, n, true);
return elem;
}
B3_FORCE_INLINE bool resize(size_t newsize, bool copyOldContents=true)
B3_FORCE_INLINE bool resize(size_t newsize, bool copyOldContents = true)
{
bool result = true;
size_t curSize = size();
@@ -120,11 +115,12 @@ public:
if (newsize < curSize)
{
//leave the OpenCL memory for now
} else
}
else
{
if (newsize > size())
{
result = reserve(newsize,copyOldContents);
result = reserve(newsize, copyOldContents);
}
//leave new data uninitialized (init in debug mode?)
@@ -134,7 +130,8 @@ public:
if (result)
{
m_size = newsize;
} else
}
else
{
m_size = 0;
}
@@ -146,25 +143,25 @@ public:
return m_size;
}
B3_FORCE_INLINE size_t capacity() const
B3_FORCE_INLINE size_t capacity() const
{
return m_capacity;
}
B3_FORCE_INLINE bool reserve(size_t _Count, bool copyOldContents=true)
B3_FORCE_INLINE bool reserve(size_t _Count, bool copyOldContents = true)
{
bool result=true;
bool result = true;
// determine new minimum length of allocated storage
if (capacity() < _Count)
{ // not enough room, reallocate
{ // not enough room, reallocate
if (m_allowGrowingCapacity)
{
cl_int ciErrNum;
//create a new OpenCL buffer
size_t memSizeInBytes = sizeof(T)*_Count;
size_t memSizeInBytes = sizeof(T) * _Count;
cl_mem buf = clCreateBuffer(m_clContext, CL_MEM_READ_WRITE, memSizeInBytes, NULL, &ciErrNum);
if (ciErrNum!=CL_SUCCESS)
if (ciErrNum != CL_SUCCESS)
{
b3Error("OpenCL out-of-memory\n");
_Count = 0;
@@ -173,13 +170,13 @@ public:
//#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++)
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);
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
#endif //B3_ALWAYS_INITIALIZE_OPENCL_BUFFERS
if (result)
{
@@ -193,21 +190,21 @@ public:
m_clBuffer = buf;
m_capacity = _Count;
} else
}
else
{
//fail: assert and
b3Assert(0);
deallocate();
result=false;
result = false;
}
}
return result;
}
void copyToCL(cl_mem destination, size_t numElements, size_t firstElem=0, size_t dstOffsetInElems=0) const
void copyToCL(cl_mem destination, size_t numElements, size_t firstElem = 0, size_t dstOffsetInElems = 0) const
{
if (numElements<=0)
if (numElements <= 0)
return;
b3Assert(m_clBuffer);
@@ -216,75 +213,74 @@ public:
//likely some error, destination is same as source
b3Assert(m_clBuffer != destination);
b3Assert((firstElem+numElements)<=m_size);
b3Assert((firstElem + numElements) <= m_size);
cl_int status = 0;
b3Assert(numElements > 0);
b3Assert(numElements <= m_size);
b3Assert(numElements>0);
b3Assert(numElements<=m_size);
size_t srcOffsetBytes = sizeof(T) * firstElem;
size_t dstOffsetInBytes = sizeof(T) * dstOffsetInElems;
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);
status = clEnqueueCopyBuffer( m_commandQueue, m_clBuffer, destination,
srcOffsetBytes, dstOffsetInBytes, sizeof(T)*numElements, 0, 0, 0 );
b3Assert( status == CL_SUCCESS );
b3Assert(status == CL_SUCCESS);
}
void copyFromHost(const b3AlignedObjectArray<T>& srcArray, bool waitForCompletion=true)
void copyFromHost(const b3AlignedObjectArray<T>& srcArray, bool waitForCompletion = true)
{
size_t newSize = srcArray.size();
bool copyOldContents = false;
resize (newSize,copyOldContents);
resize(newSize, copyOldContents);
if (newSize)
copyFromHostPointer(&srcArray[0],newSize,0,waitForCompletion);
copyFromHostPointer(&srcArray[0], newSize, 0, waitForCompletion);
}
void copyFromHostPointer(const T* src, size_t numElems, size_t destFirstElem= 0, bool waitForCompletion=true)
void copyFromHostPointer(const T* src, size_t numElems, size_t destFirstElem = 0, bool waitForCompletion = true)
{
b3Assert(numElems+destFirstElem <= capacity());
b3Assert(numElems + destFirstElem <= capacity());
if (numElems+destFirstElem)
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 );
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
}
else
{
b3Error("copyFromHostPointer invalid range\n");
}
}
void copyToHost(b3AlignedObjectArray<T>& destArray, bool waitForCompletion=true) const
void copyToHost(b3AlignedObjectArray<T>& destArray, bool waitForCompletion = true) const
{
destArray.resize(this->size());
if (size())
copyToHostPointer(&destArray[0], size(),0,waitForCompletion);
copyToHostPointer(&destArray[0], size(), 0, waitForCompletion);
}
void copyToHostPointer(T* destPtr, size_t numElem, size_t srcFirstElem=0, bool waitForCompletion=true) const
void copyToHostPointer(T* destPtr, size_t numElem, size_t srcFirstElem = 0, bool waitForCompletion = true) const
{
b3Assert(numElem+srcFirstElem <= capacity());
b3Assert(numElem + srcFirstElem <= capacity());
if(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 );
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
}
else
{
b3Error("copyToHostPointer invalid range\n");
}
@@ -296,11 +292,9 @@ public:
resize(newSize);
if (size())
{
src.copyToCL(m_clBuffer,size());
src.copyToCL(m_clBuffer, size());
}
}
};
#endif //B3_OPENCL_ARRAY_H
#endif //B3_OPENCL_ARRAY_H