Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added libspe2 parallel Cell SPE support contribution by IBM Germany 'Extreme Blue' project:

Browse Source 
Thanks to Benjamin Hoeferlin, Minh Cuong Tran,Martina Huellmann,Frederick Roth.
This commit is contained in:
ejcoumans
2007-09-26 23:37:25 +00:00
parent dae8b658da
commit 5ebab3e59b
4 changed files with 498 additions and 467 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
Extras/BulletMultiThreaded/PlatformDefinitions.h
View File

@@ -1,44 +1,72 @@
#ifndef TYPE_DEFINITIONS_H #ifndef TYPE_DEFINITIONS_H
#define TYPE_DEFINITIONS_H #define TYPE_DEFINITIONS_H
///This file provides some platform/compiler checks for common definitions ///This file provides some platform/compiler checks for common definitions
#ifdef WIN32 #ifdef WIN32
#if defined(__MINGW32__) || defined(__CYGWIN__) || (defined (_MSC_VER) && _MSC_VER < 1300)
#else typedef union
#endif //__MINGW32__ {
unsigned int u;
typedef unsigned char uint8_t; void *p;
typedef unsigned long int uint64_t; } addr64;
typedef unsigned int uint32_t;
typedef unsigned short uint16_t; #if defined(__MINGW32__) || defined(__CYGWIN__) || (defined (_MSC_VER) && _MSC_VER < 1300)
#else
#include <malloc.h> #endif //__MINGW32__
#define memalign(alignment, size) malloc(size);
typedef unsigned char uint8_t;
#include <string.h> //memcpy typedef unsigned long int uint64_t;
typedef unsigned int uint32_t;
#define USE_WIN32_THREADING 1 typedef unsigned short uint16_t;
#else #include <malloc.h>
#if defined (__CELLOS_LV2__) #define memalign(alignment, size) malloc(size);
///Playstation 3 Cell SDK
#include <spu_printf.h> #include <string.h> //memcpy
#else
//non-windows systems #define USE_WIN32_THREADING 1
#define USE_PTHREADS 1
#include <stdio.h>
#define spu_printf printf
#endif //__CELLOS_LV2__
#else
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> //for memcpy #include <string.h> //for memcpy
#endif #if defined (__CELLOS_LV2__)
// Playstation 3 Cell SDK
#include <spu_printf.h>
#endif //TYPE_DEFINITIONS_H
#else
// posix system
#define USE_PTHREADS
#ifdef USE_LIBSPE2
#include <stdio.h>
#define spu_printf printf
#define DWORD unsigned int
typedef union
{
unsigned long long ull;
unsigned int ui[2];
void *p;
} addr64;
#endif // USE_LIBSPE2
#endif //__CELLOS_LV2__
#endif
#endif //TYPE_DEFINITIONS_H

561
Extras/BulletMultiThreaded/SpuCollisionTaskProcess.cpp
View File

@@ -1,288 +1,273 @@
/* /*
Bullet Continuous Collision Detection and Physics Library Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2007 Erwin Coumans http://bulletphysics.com Copyright (c) 2003-2007 Erwin Coumans http://bulletphysics.com
This software is provided 'as-is', without any express or implied warranty. This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software. In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely, including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions: subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution. 3. This notice may not be removed or altered from any source distribution.
*/ */
//#define DEBUG_SPU_TASK_SCHEDULING 1 //#define DEBUG_SPU_TASK_SCHEDULING 1
#include "btThreadSupportInterface.h"
//class OptimizedBvhNode;
//#include "SPUAssert.h"
#include <string.h> #include "SpuCollisionTaskProcess.h"
//class OptimizedBvhNode;
#include "SpuCollisionTaskProcess.h"
#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
#include "BulletCollision/CollisionShapes/btCollisionShape.h"
#include "BulletCollision/CollisionShapes/btConvexShape.h" SpuCollisionTaskProcess::SpuCollisionTaskProcess(class btThreadSupportInterface* threadInterface, unsigned int maxNumOutstandingTasks)
#include "SpuLibspe2Support.h" :m_threadInterface(threadInterface),
#include "SpuNarrowPhaseCollisionTask/SpuGatheringCollisionTask.h" // for definitions processCollisionTask and createCollisionLocalStoreMemory m_maxNumOutstandingTasks(maxNumOutstandingTasks)
{
m_workUnitTaskBuffers = (unsigned char *)0;
#include <stdio.h> m_taskBusy.resize(m_maxNumOutstandingTasks);
m_spuGatherTaskDesc.resize(m_maxNumOutstandingTasks);
for (int i = 0; i < m_maxNumOutstandingTasks; i++)
{
m_taskBusy[i] = false;
}
m_numBusyTasks = 0;
SpuCollisionTaskProcess::SpuCollisionTaskProcess(class btThreadSupportInterface* threadInterface, unsigned int maxNumOutstandingTasks) m_currentTask = 0;
:m_threadInterface(threadInterface), m_currentPage = 0;
m_maxNumOutstandingTasks(maxNumOutstandingTasks) m_currentPageEntry = 0;
{
m_workUnitTaskBuffers = (unsigned char *)0; #ifdef DEBUG_SpuCollisionTaskProcess
m_initialized = false;
m_taskBusy.resize(m_maxNumOutstandingTasks); #endif
m_spuGatherTaskDesc.resize(m_maxNumOutstandingTasks);
m_threadInterface->startSPU();
for (int i = 0; i < m_maxNumOutstandingTasks; i++)
{ //printf("sizeof vec_float4: %d\n", sizeof(vec_float4));
m_taskBusy[i] = false; printf("sizeof SpuGatherAndProcessWorkUnitInput: %d\n", sizeof(SpuGatherAndProcessWorkUnitInput));
}
m_numBusyTasks = 0; }
m_currentTask = 0;
m_currentPage = 0; SpuCollisionTaskProcess::~SpuCollisionTaskProcess()
m_currentPageEntry = 0; {
#ifdef DEBUG_SpuCollisionTaskProcess if (m_workUnitTaskBuffers != 0)
m_initialized = false; {
#endif btAlignedFree(m_workUnitTaskBuffers);
m_workUnitTaskBuffers = 0;
m_threadInterface->startSPU(); }
//printf("sizeof vec_float4: %d\n", sizeof(vec_float4));
printf("sizeof SpuGatherAndProcessWorkUnitInput: %d\n", sizeof(SpuGatherAndProcessWorkUnitInput));
m_threadInterface->stopSPU();
}
}
SpuCollisionTaskProcess::~SpuCollisionTaskProcess()
{
if (m_workUnitTaskBuffers != 0)
{ void SpuCollisionTaskProcess::initialize2()
free(m_workUnitTaskBuffers); {
m_workUnitTaskBuffers = 0;
} #ifdef DEBUG_SPU_TASK_SCHEDULING
printf("SpuCollisionTaskProcess::initialize()\n");
#endif //DEBUG_SPU_TASK_SCHEDULING
if (!m_workUnitTaskBuffers)
m_threadInterface->stopSPU(); {
m_workUnitTaskBuffers = (unsigned char *)btAlignedAlloc(MIDPHASE_WORKUNIT_TASK_SIZE*m_maxNumOutstandingTasks, 128);
} }
for (int i = 0; i < m_maxNumOutstandingTasks; i++)
{
void m_taskBusy[i] = false;
SpuCollisionTaskProcess::initialize2() }
{ m_numBusyTasks = 0;
#ifdef DEBUG_SPU_TASK_SCHEDULING m_currentTask = 0;
printf("SpuCollisionTaskProcess::initialize()\n"); m_currentPage = 0;
#endif //DEBUG_SPU_TASK_SCHEDULING m_currentPageEntry = 0;
if (!m_workUnitTaskBuffers)
{ #ifdef DEBUG_SpuCollisionTaskProcess
m_workUnitTaskBuffers = (unsigned char *)memalign(128, MIDPHASE_WORKUNIT_TASK_SIZE*m_maxNumOutstandingTasks); m_initialized = true;
} assert(MIDPHASE_NUM_WORKUNITS_PER_TASK*sizeof(SpuGatherAndProcessWorkUnitInput) <= MIDPHASE_WORKUNIT_TASK_SIZE);
#endif
for (int i = 0; i < m_maxNumOutstandingTasks; i++) }
{
m_taskBusy[i] = false;
} void SpuCollisionTaskProcess::issueTask2()
m_numBusyTasks = 0; {
m_currentTask = 0;
m_currentPage = 0; #ifdef DEBUG_SPU_TASK_SCHEDULING
m_currentPageEntry = 0; printf("SpuCollisionTaskProcess::issueTask (m_currentTask= %d\n)", m_currentTask);
#endif //DEBUG_SPU_TASK_SCHEDULING
#ifdef DEBUG_SpuCollisionTaskProcess
m_initialized = true; m_taskBusy[m_currentTask] = true;
assert(MIDPHASE_NUM_WORKUNITS_PER_TASK*sizeof(SpuGatherAndProcessWorkUnitInput) <= MIDPHASE_WORKUNIT_TASK_SIZE); m_numBusyTasks++;
#endif
}
SpuGatherAndProcessPairsTaskDesc& taskDesc = m_spuGatherTaskDesc[m_currentTask];
{
void SpuCollisionTaskProcess::issueTask2() // send task description in event message
{ // no error checking here...
// but, currently, event queue can be no larger than NUM_WORKUNIT_TASKS.
taskDesc.inPtr = reinterpret_cast<uint64_t>(MIDPHASE_TASK_PTR(m_currentTask));
#ifdef DEBUG_SPU_TASK_SCHEDULING
printf("SpuCollisionTaskProcess::issueTask (m_currentTask= %d\)n", m_currentTask); taskDesc.taskId = m_currentTask;
#endif //DEBUG_SPU_TASK_SCHEDULING taskDesc.numPages = m_currentPage+1;
taskDesc.numOnLastPage = m_currentPageEntry;
m_taskBusy[m_currentTask] = true; }
m_numBusyTasks++;
SpuGatherAndProcessPairsTaskDesc& taskDesc = m_spuGatherTaskDesc[m_currentTask]; m_threadInterface->sendRequest(CMD_GATHER_AND_PROCESS_PAIRLIST, (uint32_t) &taskDesc,m_currentTask);
{
// send task description in event message // if all tasks busy, wait for spu event to clear the task.
// no error checking here...
// but, currently, event queue can be no larger than NUM_WORKUNIT_TASKS.
if (m_numBusyTasks >= m_maxNumOutstandingTasks)
taskDesc.inPtr = reinterpret_cast<uint64_t>(MIDPHASE_TASK_PTR(m_currentTask)); {
unsigned int taskId;
taskDesc.taskId = m_currentTask; unsigned int outputSize;
taskDesc.numPages = m_currentPage+1;
taskDesc.numOnLastPage = m_currentPageEntry; m_threadInterface->waitForResponse(&taskId, &outputSize);
}
//printf("PPU: after issue, received event: %u %d\n", taskId, outputSize);
//postProcess(taskId, outputSize);
m_threadInterface->sendRequest(CMD_GATHER_AND_PROCESS_PAIRLIST, (uint32_t) &taskDesc,m_currentTask);
m_taskBusy[taskId] = false;
// if all tasks busy, wait for spu event to clear the task.
m_numBusyTasks--;
}
if (m_numBusyTasks >= m_maxNumOutstandingTasks)
{ }
unsigned int taskId;
unsigned int outputSize; void SpuCollisionTaskProcess::addWorkToTask(void* pairArrayPtr,int startIndex,int endIndex)
{
m_threadInterface->waitForResponse(&taskId, &outputSize); #ifdef DEBUG_SPU_TASK_SCHEDULING
printf("#");
//printf("PPU: after issue, received event: %u %d\n", taskId, outputSize); #endif //DEBUG_SPU_TASK_SCHEDULING
//postProcess(taskId, outputSize); #ifdef DEBUG_SpuCollisionTaskProcess
assert(m_initialized);
m_taskBusy[taskId] = false; assert(m_workUnitTaskBuffers);
m_numBusyTasks--; #endif
}
bool batch = true;
}
if (batch)
void SpuCollisionTaskProcess::addWorkToTask(void* pairArrayPtr,int startIndex,int endIndex) {
{ if (m_currentPageEntry == MIDPHASE_NUM_WORKUNITS_PER_PAGE)
#ifdef DEBUG_SPU_TASK_SCHEDULING {
printf("#"); if (m_currentPage == MIDPHASE_NUM_WORKUNIT_PAGES-1)
#endif //DEBUG_SPU_TASK_SCHEDULING {
// task buffer is full, issue current task.
#ifdef DEBUG_SpuCollisionTaskProcess // if all task buffers busy, this waits until SPU is done.
assert(m_initialized); issueTask2();
assert(m_workUnitTaskBuffers);
// find new task buffer
#endif for (unsigned int i = 0; i < m_maxNumOutstandingTasks; i++)
{
bool batch = true; if (!m_taskBusy[i])
{
if (batch) m_currentTask = i;
{ //init the task data
if (m_currentPageEntry == MIDPHASE_NUM_WORKUNITS_PER_PAGE)
{ break;
if (m_currentPage == MIDPHASE_NUM_WORKUNIT_PAGES-1) }
{ }
// task buffer is full, issue current task.
// if all task buffers busy, this waits until SPU is done. m_currentPage = 0;
issueTask2(); }
else
// find new task buffer {
for (unsigned int i = 0; i < m_maxNumOutstandingTasks; i++) m_currentPage++;
{ }
if (!m_taskBusy[i])
{ m_currentPageEntry = 0;
m_currentTask = i; }
//init the task data }
break; {
}
}
m_currentPage = 0; SpuGatherAndProcessWorkUnitInput &wuInput =
} *(reinterpret_cast<SpuGatherAndProcessWorkUnitInput*>
else (MIDPHASE_ENTRY_PTR(m_currentTask, m_currentPage, m_currentPageEntry)));
{
m_currentPage++; wuInput.m_pairArrayPtr = reinterpret_cast<uint64_t>(pairArrayPtr);
} wuInput.m_startIndex = startIndex;
wuInput.m_endIndex = endIndex;
m_currentPageEntry = 0;
}
}
m_currentPageEntry++;
{
if (!batch)
{
issueTask2();
SpuGatherAndProcessWorkUnitInput &wuInput =
*(reinterpret_cast<SpuGatherAndProcessWorkUnitInput*> // find new task buffer
(MIDPHASE_ENTRY_PTR(m_currentTask, m_currentPage, m_currentPageEntry))); for (unsigned int i = 0; i < m_maxNumOutstandingTasks; i++)
{
wuInput.m_pairArrayPtr = reinterpret_cast<uint64_t>(pairArrayPtr); if (!m_taskBusy[i])
wuInput.m_startIndex = startIndex; {
wuInput.m_endIndex = endIndex; m_currentTask = i;
//init the task data
break;
m_currentPageEntry++; }
}
if (!batch)
{ m_currentPage = 0;
issueTask2(); m_currentPageEntry =0;
}
// find new task buffer }
for (unsigned int i = 0; i < m_maxNumOutstandingTasks; i++) }
{
if (!m_taskBusy[i])
{ void
m_currentTask = i; SpuCollisionTaskProcess::flush2()
//init the task data {
#ifdef DEBUG_SPU_TASK_SCHEDULING
break; printf("\nSpuCollisionTaskProcess::flush()\n");
} #endif //DEBUG_SPU_TASK_SCHEDULING
}
// if there's a partially filled task buffer, submit that task
m_currentPage = 0; if (m_currentPage > 0 || m_currentPageEntry > 0)
m_currentPageEntry =0; {
} issueTask2();
} }
}
// all tasks are issued, wait for all tasks to be complete
void while(m_numBusyTasks > 0)
SpuCollisionTaskProcess::flush2() {
{ // Consolidating SPU code
#ifdef DEBUG_SPU_TASK_SCHEDULING unsigned int taskId;
printf("\nSpuCollisionTaskProcess::flush()\n"); unsigned int outputSize;
#endif //DEBUG_SPU_TASK_SCHEDULING
{
// if there's a partially filled task buffer, submit that task
if (m_currentPage > 0 || m_currentPageEntry > 0) // SPURS support.
{ m_threadInterface->waitForResponse(&taskId, &outputSize);
issueTask2(); }
}
//printf("PPU: flushing, received event: %u %d\n", taskId, outputSize);
// all tasks are issued, wait for all tasks to be complete //postProcess(taskId, outputSize);
while(m_numBusyTasks > 0)
{ m_taskBusy[taskId] = false;
// Consolidating SPU code
unsigned int taskId; m_numBusyTasks--;
unsigned int outputSize; }
{
}
// SPURS support.
m_threadInterface->waitForResponse(&taskId, &outputSize);
}
//printf("PPU: flushing, received event: %u %d\n", taskId, outputSize);
//postProcess(taskId, outputSize);
m_taskBusy[taskId] = false;
m_numBusyTasks--;
}
}

286
Extras/BulletMultiThreaded/SpuCollisionTaskProcess.h
View File

@@ -1,134 +1,152 @@
/* /*
Bullet Continuous Collision Detection and Physics Library Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2007 Erwin Coumans http://bulletphysics.com Copyright (c) 2003-2007 Erwin Coumans http://bulletphysics.com
This software is provided 'as-is', without any express or implied warranty. This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software. In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely, including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions: subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution. 3. This notice may not be removed or altered from any source distribution.
*/ */
#ifndef SPU_COLLISION_TASK_PROCESS_H #ifndef SPU_COLLISION_TASK_PROCESS_H
#define SPU_COLLISION_TASK_PROCESS_H #define SPU_COLLISION_TASK_PROCESS_H
#include <assert.h> #include <assert.h>
#include <LinearMath/btScalar.h> #include <LinearMath/btScalar.h>
#include "PlatformDefinitions.h" #include "PlatformDefinitions.h"
#include "LinearMath/btAlignedObjectArray.h" #include "LinearMath/btAlignedObjectArray.h"
#include "SpuNarrowPhaseCollisionTask/SpuGatheringCollisionTask.h" // for definitions processCollisionTask and createCollisionLocalStoreMemory
//#define DEBUG_SpuCollisionTaskProcess 1
#include "btThreadSupportInterface.h"
#define CMD_GATHER_AND_PROCESS_PAIRLIST 1
//#include "SPUAssert.h"
class btCollisionObject; #include <string.h>
class btPersistentManifold;
class btDispatcher;
#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
#include "BulletCollision/CollisionShapes/btCollisionShape.h"
///Task Description for SPU collision detection #include "BulletCollision/CollisionShapes/btConvexShape.h"
struct SpuGatherAndProcessPairsTaskDesc
{ #include <LinearMath/btAlignedAllocator.h>
uint64_t inPtr;//m_pairArrayPtr;
//mutex variable #include <stdio.h>
uint32_t m_someMutexVariableInMainMemory;
uint64_t m_dispatcher; #define DEBUG_SpuCollisionTaskProcess 1
uint32_t numOnLastPage;
#define CMD_GATHER_AND_PROCESS_PAIRLIST 1
uint16_t numPages;
uint16_t taskId; class btCollisionObject;
class btPersistentManifold;
// struct CollisionTask_LocalStoreMemory* m_lsMemory; class btDispatcher;
}
#ifdef __CELLOS_LV2__
__attribute__ ((aligned (16))) /////Task Description for SPU collision detection
#endif //struct SpuGatherAndProcessPairsTaskDesc
; //{
// uint64_t inPtr;//m_pairArrayPtr;
// //mutex variable
///MidphaseWorkUnitInput stores individual primitive versus mesh collision detection input, to be processed by the SPU. // uint32_t m_someMutexVariableInMainMemory;
struct SpuGatherAndProcessWorkUnitInput //
{ // uint64_t m_dispatcher;
uint64_t m_pairArrayPtr; //
int m_startIndex; // uint32_t numOnLastPage;
int m_endIndex; //
}; // uint16_t numPages;
// uint16_t taskId;
//
// struct CollisionTask_LocalStoreMemory* m_lsMemory;
//}
/// SpuCollisionTaskProcess handles SPU processing of collision pairs. //
/// Maintains a set of task buffers. //#if defined(__CELLOS_LV2__) || defined(USE_LIBSPE2)
/// When the task is full, the task is issued for SPUs to process. Contact output goes into btPersistentManifold //__attribute__ ((aligned (16)))
/// associated with each task. //#endif
/// When PPU issues a task, it will look for completed task buffers //;
/// PPU will do postprocessing, dependent on workunit output (not likely)
class SpuCollisionTaskProcess
{ ///MidphaseWorkUnitInput stores individual primitive versus mesh collision detection input, to be processed by the SPU.
struct SpuGatherAndProcessWorkUnitInput
unsigned char *m_workUnitTaskBuffers; {
uint64_t m_pairArrayPtr;
int m_startIndex;
// track task buffers that are being used, and total busy tasks int m_endIndex;
btAlignedObjectArray<bool> m_taskBusy; };
btAlignedObjectArray<SpuGatherAndProcessPairsTaskDesc> m_spuGatherTaskDesc;
class btThreadSupportInterface* m_threadInterface;
unsigned int m_maxNumOutstandingTasks; /// SpuCollisionTaskProcess handles SPU processing of collision pairs.
/// Maintains a set of task buffers.
unsigned int m_numBusyTasks; /// When the task is full, the task is issued for SPUs to process. Contact output goes into btPersistentManifold
/// associated with each task.
// the current task and the current entry to insert a new work unit /// When PPU issues a task, it will look for completed task buffers
unsigned int m_currentTask; /// PPU will do postprocessing, dependent on workunit output (not likely)
unsigned int m_currentPage; class SpuCollisionTaskProcess
unsigned int m_currentPageEntry; {
#ifdef DEBUG_SpuCollisionTaskProcess unsigned char *m_workUnitTaskBuffers;
bool m_initialized;
#endif
void issueTask2(); // track task buffers that are being used, and total busy tasks
//void postProcess(unsigned int taskId, int outputSize); btAlignedObjectArray<bool> m_taskBusy;
btAlignedObjectArray<SpuGatherAndProcessPairsTaskDesc> m_spuGatherTaskDesc;
public:
SpuCollisionTaskProcess(btThreadSupportInterface* threadInterface, unsigned int maxNumOutstandingTasks); class btThreadSupportInterface* m_threadInterface;
~SpuCollisionTaskProcess(); unsigned int m_maxNumOutstandingTasks;
///call initialize in the beginning of the frame, before addCollisionPairToTask unsigned int m_numBusyTasks;
void initialize2();
// the current task and the current entry to insert a new work unit
///batch up additional work to a current task for SPU processing. When batch is full, it issues the task. unsigned int m_currentTask;
void addWorkToTask(void* pairArrayPtr,int startIndex,int endIndex); unsigned int m_currentPage;
unsigned int m_currentPageEntry;
///call flush to submit potential outstanding work to SPUs and wait for all involved SPUs to be finished
void flush2(); #ifdef DEBUG_SpuCollisionTaskProcess
}; bool m_initialized;
#endif
void issueTask2();
//void postProcess(unsigned int taskId, int outputSize);
#define MIDPHASE_TASK_PTR(task) (&m_workUnitTaskBuffers[0] + MIDPHASE_WORKUNIT_TASK_SIZE*task)
#define MIDPHASE_ENTRY_PTR(task,page,entry) (MIDPHASE_TASK_PTR(task) + MIDPHASE_WORKUNIT_PAGE_SIZE*page + sizeof(SpuGatherAndProcessWorkUnitInput)*entry) public:
#define MIDPHASE_OUTPUT_PTR(task) (&m_contactOutputBuffers[0] + MIDPHASE_MAX_CONTACT_BUFFER_SIZE*task) SpuCollisionTaskProcess(btThreadSupportInterface* threadInterface, unsigned int maxNumOutstandingTasks);
#define MIDPHASE_TREENODES_PTR(task) (&m_complexShapeBuffers[0] + MIDPHASE_COMPLEX_SHAPE_BUFFER_SIZE*task)
~SpuCollisionTaskProcess();
#define MIDPHASE_WORKUNIT_PAGE_SIZE (16) ///call initialize in the beginning of the frame, before addCollisionPairToTask
void initialize2();
#define MIDPHASE_NUM_WORKUNIT_PAGES 1
#define MIDPHASE_WORKUNIT_TASK_SIZE (MIDPHASE_WORKUNIT_PAGE_SIZE*MIDPHASE_NUM_WORKUNIT_PAGES) ///batch up additional work to a current task for SPU processing. When batch is full, it issues the task.
#define MIDPHASE_NUM_WORKUNITS_PER_PAGE (MIDPHASE_WORKUNIT_PAGE_SIZE / sizeof(SpuGatherAndProcessWorkUnitInput)) void addWorkToTask(void* pairArrayPtr,int startIndex,int endIndex);
#define MIDPHASE_NUM_WORKUNITS_PER_TASK (MIDPHASE_NUM_WORKUNITS_PER_PAGE*MIDPHASE_NUM_WORKUNIT_PAGES)
///call flush to submit potential outstanding work to SPUs and wait for all involved SPUs to be finished
void flush2();
#endif // SPU_COLLISION_TASK_PROCESS_H };
#define MIDPHASE_TASK_PTR(task) (&m_workUnitTaskBuffers[0] + MIDPHASE_WORKUNIT_TASK_SIZE*task)
#define MIDPHASE_ENTRY_PTR(task,page,entry) (MIDPHASE_TASK_PTR(task) + MIDPHASE_WORKUNIT_PAGE_SIZE*page + sizeof(SpuGatherAndProcessWorkUnitInput)*entry)
#define MIDPHASE_OUTPUT_PTR(task) (&m_contactOutputBuffers[0] + MIDPHASE_MAX_CONTACT_BUFFER_SIZE*task)
#define MIDPHASE_TREENODES_PTR(task) (&m_complexShapeBuffers[0] + MIDPHASE_COMPLEX_SHAPE_BUFFER_SIZE*task)
#define MIDPHASE_WORKUNIT_PAGE_SIZE (16)
#define MIDPHASE_NUM_WORKUNIT_PAGES 1
#define MIDPHASE_WORKUNIT_TASK_SIZE (MIDPHASE_WORKUNIT_PAGE_SIZE*MIDPHASE_NUM_WORKUNIT_PAGES)
#define MIDPHASE_NUM_WORKUNITS_PER_PAGE (MIDPHASE_WORKUNIT_PAGE_SIZE / sizeof(SpuGatherAndProcessWorkUnitInput))
#define MIDPHASE_NUM_WORKUNITS_PER_TASK (MIDPHASE_NUM_WORKUNITS_PER_PAGE*MIDPHASE_NUM_WORKUNIT_PAGES)
#endif // SPU_COLLISION_TASK_PROCESS_H

2
Extras/BulletMultiThreaded/SpuContactManifoldCollisionAlgorithm.cpp
View File

@@ -55,4 +55,4 @@ SpuContactManifoldCollisionAlgorithm::~SpuContactManifoldCollisionAlgorithm()
{ {
if (m_manifoldPtr) if (m_manifoldPtr)
m_dispatcher->releaseManifold(m_manifoldPtr); m_dispatcher->releaseManifold(m_manifoldPtr);
} }