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

enable poxix MultiThreading sample under Linux

Browse Source
This commit is contained in:
erwincoumans
2013-07-18 21:18:09 -07:00
parent 12a4480d08
commit 2f0fd80c9c
8 changed files with 193 additions and 440 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
btgui/MultiThreading/b3PosixThreadSupport.cpp
View File

@@ -4,8 +4,8 @@ Copyright (c) 2003-2007 Erwin Coumans http://bulletphysics.com
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.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
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.
@@ -14,13 +14,10 @@ subject to the following restrictions:
*/
#include <stdio.h>
#include "PosixThreadSupport.h"
#ifdef USE_PTHREADS
#include "b3PosixThreadSupport.h"
#include <errno.h>
#include <unistd.h>
#include "SpuCollisionTaskProcess.h"
#include "SpuNarrowPhaseCollisionTask/SpuGatheringCollisionTask.h"
#define checkPThreadFunction(returnValue) \
if(0 != returnValue) { \
@@ -30,17 +27,16 @@ subject to the following restrictions:
// The number of threads should be equal to the number of available cores
// Todo: each worker should be linked to a single core, using SetThreadIdealProcessor.
// PosixThreadSupport helps to initialize/shutdown libspe2, start/stop SPU tasks and communication
// Setup and initialize SPU/CELL/Libspe2
PosixThreadSupport::PosixThreadSupport(ThreadConstructionInfo& threadConstructionInfo)
b3PosixThreadSupport::b3PosixThreadSupport(ThreadConstructionInfo& threadConstructionInfo)
{
startThreads(threadConstructionInfo);
}
// cleanup/shutdown Libspe2
PosixThreadSupport::~PosixThreadSupport()
b3PosixThreadSupport::~b3PosixThreadSupport()
{
stopSPU();
stopThreads();
}
#if (defined (__APPLE__))
@@ -56,7 +52,7 @@ static sem_t* createSem(const char* baseName)
#ifdef NAMED_SEMAPHORES
/// Named semaphore begin
char name[32];
snprintf(name, 32, "/%s-%d-%4.4d", baseName, getpid(), semCount++);
snprintf(name, 32, "/%s-%d-%4.4d", baseName, getpid(), semCount++);
sem_t* tempSem = sem_open(name, O_CREAT, 0600, 0);
if (tempSem != reinterpret_cast<sem_t *>(SEM_FAILED))
@@ -83,24 +79,24 @@ static void destroySem(sem_t* semaphore)
#else
checkPThreadFunction(sem_destroy(semaphore));
delete semaphore;
#endif
#endif
}
static void *threadFunction(void *argument)
static void *threadFunction(void *argument)
{
PosixThreadSupport::btSpuStatus* status = (PosixThreadSupport::btSpuStatus*)argument;
b3PosixThreadSupport::b3ThreadStatus* status = (b3PosixThreadSupport::b3ThreadStatus*)argument;
while (1)
{
checkPThreadFunction(sem_wait(status->startSemaphore));
void* userPtr = status->m_userPtr;
if (userPtr)
{
btAssert(status->m_status);
b3Assert(status->m_status);
status->m_userThreadFunc(userPtr,status->m_lsMemory);
status->m_status = 2;
checkPThreadFunction(sem_post(mainSemaphore));
@@ -112,7 +108,7 @@ static void *threadFunction(void *argument)
printf("Thread with taskId %i exiting\n",status->m_taskId);
break;
}
}
printf("Thread TERMINATED\n");
@@ -121,21 +117,21 @@ static void *threadFunction(void *argument)
}
///send messages to SPUs
void PosixThreadSupport::sendRequest(uint32_t uiCommand, ppu_address_t uiArgument0, uint32_t taskId)
void b3PosixThreadSupport::sendRequest(int uiCommand, void* uiArgument0, int taskId)
{
/// gMidphaseSPU.sendRequest(CMD_GATHER_AND_PROCESS_PAIRLIST, (uint32_t) &taskDesc);
/// gMidphaseSPU.sendRequest(CMD_GATHER_AND_PROCESS_PAIRLIST, (int) &taskDesc);
///we should spawn an SPU task here, and in 'waitForResponse' it should wait for response of the (one of) the first tasks that finished
switch (uiCommand)
{
case CMD_GATHER_AND_PROCESS_PAIRLIST:
case B3_THREAD_SCHEDULE_TASK:
{
btSpuStatus& spuStatus = m_activeSpuStatus[taskId];
btAssert(taskId >= 0);
btAssert(taskId < m_activeSpuStatus.size());
b3ThreadStatus& spuStatus = m_activeThreadStatus[taskId];
b3Assert(taskId >= 0);
b3Assert(taskId < m_activeThreadStatus.size());
spuStatus.m_commandId = uiCommand;
spuStatus.m_status = 1;
@@ -148,7 +144,7 @@ void PosixThreadSupport::sendRequest(uint32_t uiCommand, ppu_address_t uiArgumen
default:
{
///not implemented
btAssert(0);
b3Assert(0);
}
};
@@ -156,37 +152,72 @@ void PosixThreadSupport::sendRequest(uint32_t uiCommand, ppu_address_t uiArgumen
}
///check for messages from SPUs
void PosixThreadSupport::waitForResponse(unsigned int *puiArgument0, unsigned int *puiArgument1)
///non-blocking test if a task is completed. First implement all versions, and then enable this API
bool b3PosixThreadSupport::isTaskCompleted(int *puiArgument0, int *puiArgument1, int timeOutInMilliseconds)
{
///We should wait for (one of) the first tasks to finish (or other SPU messages), and report its response
///A possible response can be 'yes, SPU handled it', or 'no, please do a PPU fallback'
btAssert(m_activeSpuStatus.size());
b3Assert(m_activeThreadStatus.size());
// wait for any of the threads to finish
checkPThreadFunction(sem_wait(mainSemaphore));
// get at least one thread which has finished
int result = sem_trywait(mainSemaphore);
if (result==0)
{
// get at least one thread which has finished
size_t last = -1;
for(size_t t=0; t < size_t(m_activeSpuStatus.size()); ++t) {
if(2 == m_activeSpuStatus[t].m_status) {
for(size_t t=0; t < size_t(m_activeThreadStatus.size()); ++t) {
if(2 == m_activeThreadStatus[t].m_status) {
last = t;
break;
}
}
btSpuStatus& spuStatus = m_activeSpuStatus[last];
b3ThreadStatus& spuStatus = m_activeThreadStatus[last];
btAssert(spuStatus.m_status > 1);
b3Assert(spuStatus.m_status > 1);
spuStatus.m_status = 0;
// need to find an active spu
b3Assert(last >= 0);
*puiArgument0 = spuStatus.m_taskId;
*puiArgument1 = spuStatus.m_status;
return true;
}
return false;
}
///check for messages from SPUs
void b3PosixThreadSupport::waitForResponse( int *puiArgument0, int *puiArgument1)
{
///We should wait for (one of) the first tasks to finish (or other SPU messages), and report its response
///A possible response can be 'yes, SPU handled it', or 'no, please do a PPU fallback'
b3Assert(m_activeThreadStatus.size());
// wait for any of the threads to finish
checkPThreadFunction(sem_wait(mainSemaphore));
// get at least one thread which has finished
size_t last = -1;
for(size_t t=0; t < size_t(m_activeThreadStatus.size()); ++t) {
if(2 == m_activeThreadStatus[t].m_status) {
last = t;
break;
}
}
b3ThreadStatus& spuStatus = m_activeThreadStatus[last];
b3Assert(spuStatus.m_status > 1);
spuStatus.m_status = 0;
// need to find an active spu
btAssert(last >= 0);
b3Assert(last >= 0);
*puiArgument0 = spuStatus.m_taskId;
*puiArgument1 = spuStatus.m_status;
@@ -194,22 +225,22 @@ void PosixThreadSupport::waitForResponse(unsigned int *puiArgument0, unsigned in
void PosixThreadSupport::startThreads(ThreadConstructionInfo& threadConstructionInfo)
void b3PosixThreadSupport::startThreads(ThreadConstructionInfo& threadConstructionInfo)
{
printf("%s creating %i threads.\n", __FUNCTION__, threadConstructionInfo.m_numThreads);
m_activeSpuStatus.resize(threadConstructionInfo.m_numThreads);
mainSemaphore = createSem("main");
m_activeThreadStatus.resize(threadConstructionInfo.m_numThreads);
mainSemaphore = createSem("main");
//checkPThreadFunction(sem_wait(mainSemaphore));
for (int i=0;i < threadConstructionInfo.m_numThreads;i++)
{
printf("starting thread %d\n",i);
btSpuStatus& spuStatus = m_activeSpuStatus[i];
b3ThreadStatus& spuStatus = m_activeThreadStatus[i];
spuStatus.startSemaphore = createSem("threadLocal");
spuStatus.startSemaphore = createSem("threadLocal");
checkPThreadFunction(pthread_create(&spuStatus.thread, NULL, &threadFunction, (void*)&spuStatus));
spuStatus.m_userPtr=0;
@@ -222,29 +253,26 @@ void PosixThreadSupport::startThreads(ThreadConstructionInfo& threadConstruction
spuStatus.threadUsed = 0;
printf("started thread %d \n",i);
}
}
void PosixThreadSupport::startSPU()
{
}
///tell the task scheduler we are done with the SPU tasks
void PosixThreadSupport::stopSPU()
void b3PosixThreadSupport::stopThreads()
{
for(size_t t=0; t < size_t(m_activeSpuStatus.size()); ++t)
for(size_t t=0; t < size_t(m_activeThreadStatus.size()); ++t)
{
btSpuStatus& spuStatus = m_activeSpuStatus[t];
b3ThreadStatus& spuStatus = m_activeThreadStatus[t];
printf("%s: Thread %i used: %ld\n", __FUNCTION__, int(t), spuStatus.threadUsed);
spuStatus.m_userPtr = 0;
spuStatus.m_userPtr = 0;
checkPThreadFunction(sem_post(spuStatus.startSemaphore));
checkPThreadFunction(sem_wait(mainSemaphore));
printf("destroy semaphore\n");
printf("destroy semaphore\n");
destroySem(spuStatus.startSemaphore);
printf("semaphore destroyed\n");
checkPThreadFunction(pthread_join(spuStatus.thread,0));
@@ -253,25 +281,25 @@ void PosixThreadSupport::stopSPU()
printf("destroy main semaphore\n");
destroySem(mainSemaphore);
printf("main semaphore destroyed\n");
m_activeSpuStatus.clear();
m_activeThreadStatus.clear();
}
class PosixCriticalSection : public btCriticalSection
class b3PosixCriticalSection : public b3CriticalSection
{
pthread_mutex_t m_mutex;
public:
PosixCriticalSection()
b3PosixCriticalSection()
{
pthread_mutex_init(&m_mutex, NULL);
}
virtual ~PosixCriticalSection()
virtual ~b3PosixCriticalSection()
{
pthread_mutex_destroy(&m_mutex);
}
ATTRIBUTE_ALIGNED16(unsigned int mCommonBuff[32]);
B3_ATTRIBUTE_ALIGNED16(unsigned int mCommonBuff[32]);
virtual unsigned int getSharedParam(int i)
{
return mCommonBuff[i];
@@ -280,7 +308,7 @@ public:
{
mCommonBuff[i] = p;
}
virtual void lock()
{
pthread_mutex_lock(&m_mutex);
@@ -294,7 +322,7 @@ public:
#if defined(_POSIX_BARRIERS) && (_POSIX_BARRIERS - 20012L) >= 0
/* OK to use barriers on this platform */
class PosixBarrier : public btBarrier
class PosixBarrier : public b3Barrier
{
pthread_barrier_t m_barr;
int m_numThreads;
@@ -304,7 +332,7 @@ public:
virtual ~PosixBarrier() {
pthread_barrier_destroy(&m_barr);
}
virtual void sync()
{
int rc = pthread_barrier_wait(&m_barr);
@@ -318,7 +346,7 @@ public:
{
int result = pthread_barrier_init(&m_barr, NULL, numThreads);
m_numThreads = numThreads;
btAssert(result==0);
b3Assert(result==0);
}
virtual int getMaxCount()
{
@@ -327,20 +355,20 @@ public:
};
#else
/* Not OK to use barriers on this platform - insert alternate code here */
class PosixBarrier : public btBarrier
class PosixBarrier : public btBarrier
{
pthread_mutex_t m_mutex;
pthread_cond_t m_cond;
int m_numThreads;
int m_called;
public:
PosixBarrier()
:m_numThreads(0)
{
}
virtual ~PosixBarrier()
virtual ~PosixBarrier()
{
if (m_numThreads>0)
{
@@ -348,9 +376,9 @@ public:
pthread_cond_destroy(&m_cond);
}
}
virtual void sync()
{
{
pthread_mutex_lock(&m_mutex);
m_called++;
if (m_called == m_numThreads) {
@@ -360,7 +388,7 @@ public:
pthread_cond_wait(&m_cond,&m_mutex);
}
pthread_mutex_unlock(&m_mutex);
}
virtual void setMaxCount(int numThreads)
{
@@ -384,26 +412,25 @@ public:
btBarrier* PosixThreadSupport::createBarrier()
b3Barrier* b3PosixThreadSupport::createBarrier()
{
PosixBarrier* barrier = new PosixBarrier();
barrier->setMaxCount(getNumTasks());
return barrier;
}
btCriticalSection* PosixThreadSupport::createCriticalSection()
b3CriticalSection* b3PosixThreadSupport::createCriticalSection()
{
return new PosixCriticalSection();
return new b3PosixCriticalSection();
}
void PosixThreadSupport::deleteBarrier(btBarrier* barrier)
void b3PosixThreadSupport::deleteBarrier(b3Barrier* barrier)
{
delete barrier;
}
void PosixThreadSupport::deleteCriticalSection(btCriticalSection* cs)
void b3PosixThreadSupport::deleteCriticalSection(b3CriticalSection* cs)
{
delete cs;
}
#endif // USE_PTHREADS