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

Code-style consistency improvement:

Browse Source 
Apply clang-format-all.sh using the _clang-format file through all the cpp/.h files.
make sure not to apply it to certain serialization structures, since some parser expects the * as part of the name, instead of type.
This commit contains no other changes aside from adding and applying clang-format-all.sh
This commit is contained in:
erwincoumans
2018-09-23 14:17:31 -07:00
parent b73b05e9fb
commit ab8f16961e
1773 changed files with 1081087 additions and 474249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

272
examples/MultiThreading/b3PosixThreadSupport.cpp
View File

@@ -19,16 +19,15 @@ subject to the following restrictions:
#include <errno.h>
#include <unistd.h>
#define checkPThreadFunction(returnValue) \
if(0 != returnValue) { \
printf("PThread problem at line %i in file %s: %i %d\n", __LINE__, __FILE__, returnValue, errno); \
}
#define checkPThreadFunction(returnValue) \
if (0 != returnValue) \
{ \
printf("PThread problem at line %i in file %s: %i %d\n", __LINE__, __FILE__, returnValue, errno); \
}
// 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.
b3PosixThreadSupport::b3PosixThreadSupport(ThreadConstructionInfo& threadConstructionInfo)
{
startThreads(threadConstructionInfo);
@@ -40,30 +39,29 @@ b3PosixThreadSupport::~b3PosixThreadSupport()
stopThreads();
}
#if (defined (__APPLE__))
#if (defined(__APPLE__))
#define NAMED_SEMAPHORES
#endif
static sem_t* createSem(const char* baseName)
{
static int semCount = 0;
#ifdef NAMED_SEMAPHORES
/// Named semaphore begin
char name[32];
snprintf(name, 32, "/%8.s-%4.d-%4.4d", baseName, getpid(), semCount++);
sem_t* tempSem = sem_open(name, O_CREAT, 0600, 0);
/// Named semaphore begin
char name[32];
snprintf(name, 32, "/%8.s-%4.d-%4.4d", baseName, getpid(), semCount++);
sem_t* tempSem = sem_open(name, O_CREAT, 0600, 0);
if (tempSem != reinterpret_cast<sem_t *>(SEM_FAILED))
{
// printf("Created \"%s\" Semaphore %p\n", name, tempSem);
}
else
if (tempSem != reinterpret_cast<sem_t*>(SEM_FAILED))
{
// printf("Created \"%s\" Semaphore %p\n", name, tempSem);
}
else
{
//printf("Error creating Semaphore %d\n", errno);
exit(-1);
}
/// Named semaphore end
/// Named semaphore end
#else
sem_t* tempSem = new sem_t;
checkPThreadFunction(sem_init(tempSem, 0, 0));
@@ -81,38 +79,36 @@ static void destroySem(sem_t* semaphore)
#endif
}
static void *threadFunction(void *argument)
static void* threadFunction(void* argument)
{
b3PosixThreadSupport::b3ThreadStatus* status = (b3PosixThreadSupport::b3ThreadStatus*)argument;
while (1)
{
checkPThreadFunction(sem_wait(status->startSemaphore));
checkPThreadFunction(sem_wait(status->startSemaphore));
void* userPtr = status->m_userPtr;
if (userPtr)
{
b3Assert(status->m_status);
status->m_userThreadFunc(userPtr,status->m_lsMemory);
status->m_userThreadFunc(userPtr, status->m_lsMemory);
status->m_status = 2;
checkPThreadFunction(sem_post(status->m_mainSemaphore));
status->threadUsed++;
} else {
status->threadUsed++;
}
else
{
//exit Thread
status->m_status = 3;
checkPThreadFunction(sem_post(status->m_mainSemaphore));
printf("Thread with taskId %i exiting\n",status->m_taskId);
printf("Thread with taskId %i exiting\n", status->m_taskId);
break;
}
}
printf("Thread TERMINATED\n");
return 0;
}
///send messages to SPUs
@@ -122,13 +118,11 @@ void b3PosixThreadSupport::runTask(int uiCommand, void* uiArgument0, int taskId)
///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 B3_THREAD_SCHEDULE_TASK:
case B3_THREAD_SCHEDULE_TASK:
{
b3ThreadStatus& spuStatus = m_activeThreadStatus[taskId];
b3ThreadStatus& spuStatus = m_activeThreadStatus[taskId];
b3Assert(taskId >= 0);
b3Assert(taskId < m_activeThreadStatus.size());
@@ -140,76 +134,74 @@ void b3PosixThreadSupport::runTask(int uiCommand, void* uiArgument0, int taskId)
checkPThreadFunction(sem_post(spuStatus.startSemaphore));
break;
}
default:
default:
{
///not implemented
b3Assert(0);
}
};
}
///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)
bool b3PosixThreadSupport::isTaskCompleted(int* puiArgument0, int* puiArgument1, int timeOutInMilliseconds)
{
b3Assert(m_activeThreadStatus.size());
// wait for any of the threads to finish
// wait for any of the threads to finish
int result = sem_trywait(m_mainSemaphore);
if (result==0)
{
// get at least one thread which has finished
int last = -1;
int status = -1;
for(int t=0; t < int (m_activeThreadStatus.size()); ++t) {
status = m_activeThreadStatus[t].m_status;
if(2 == m_activeThreadStatus[t].m_status) {
last = t;
break;
}
}
if (result == 0)
{
// get at least one thread which has finished
int last = -1;
int status = -1;
for (int t = 0; t < int(m_activeThreadStatus.size()); ++t)
{
status = m_activeThreadStatus[t].m_status;
if (2 == m_activeThreadStatus[t].m_status)
{
last = t;
break;
}
}
b3ThreadStatus& spuStatus = m_activeThreadStatus[last];
b3ThreadStatus& spuStatus = m_activeThreadStatus[last];
b3Assert(spuStatus.m_status > 1);
spuStatus.m_status = 0;
b3Assert(spuStatus.m_status > 1);
spuStatus.m_status = 0;
// need to find an active spu
b3Assert(last >= 0);
// need to find an active spu
b3Assert(last >= 0);
*puiArgument0 = spuStatus.m_taskId;
*puiArgument1 = spuStatus.m_status;
return true;
}
return false;
*puiArgument0 = spuStatus.m_taskId;
*puiArgument1 = spuStatus.m_status;
return true;
}
return false;
}
///check for messages from SPUs
void b3PosixThreadSupport::waitForResponse( int *puiArgument0, int *puiArgument1)
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
// wait for any of the threads to finish
checkPThreadFunction(sem_wait(m_mainSemaphore));
// get at least one thread which has finished
size_t last = -1;
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;
}
}
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];
@@ -223,27 +215,25 @@ void b3PosixThreadSupport::waitForResponse( int *puiArgument0, int *puiArgument
*puiArgument1 = spuStatus.m_status;
}
void b3PosixThreadSupport::startThreads(ThreadConstructionInfo& threadConstructionInfo)
{
printf("%s creating %i threads.\n", __FUNCTION__, threadConstructionInfo.m_numThreads);
printf("%s creating %i threads.\n", __FUNCTION__, threadConstructionInfo.m_numThreads);
m_activeThreadStatus.resize(threadConstructionInfo.m_numThreads);
m_mainSemaphore = createSem("main");
//checkPThreadFunction(sem_wait(mainSemaphore));
for (int i=0;i < threadConstructionInfo.m_numThreads;i++)
for (int i = 0; i < threadConstructionInfo.m_numThreads; i++)
{
printf("starting thread %d\n",i);
printf("starting thread %d\n", i);
b3ThreadStatus& spuStatus = m_activeThreadStatus[i];
b3ThreadStatus& spuStatus = m_activeThreadStatus[i];
spuStatus.startSemaphore = createSem("threadLocal");
checkPThreadFunction(pthread_create(&spuStatus.thread, NULL, &threadFunction, (void*)&spuStatus));
checkPThreadFunction(pthread_create(&spuStatus.thread, NULL, &threadFunction, (void*)&spuStatus));
spuStatus.m_userPtr=0;
spuStatus.m_userPtr = 0;
spuStatus.m_taskId = i;
spuStatus.m_commandId = 0;
@@ -254,40 +244,35 @@ void b3PosixThreadSupport::startThreads(ThreadConstructionInfo& threadConstructi
spuStatus.m_lsMemoryReleaseFunc = threadConstructionInfo.m_lsMemoryReleaseFunc;
spuStatus.threadUsed = 0;
printf("started thread %d \n",i);
printf("started thread %d \n", i);
}
}
///tell the task scheduler we are done with the SPU tasks
void b3PosixThreadSupport::stopThreads()
{
for(size_t t=0; t < size_t(m_activeThreadStatus.size()); ++t)
for (size_t t = 0; t < size_t(m_activeThreadStatus.size()); ++t)
{
b3ThreadStatus& spuStatus = m_activeThreadStatus[t];
// printf("%s: Thread %i used: %ld\n", __FUNCTION__, int(t), spuStatus.threadUsed);
b3ThreadStatus& spuStatus = m_activeThreadStatus[t];
spuStatus.m_userPtr = 0;
checkPThreadFunction(sem_post(spuStatus.startSemaphore));
checkPThreadFunction(sem_wait(m_mainSemaphore));
// printf("%s: Thread %i used: %ld\n", __FUNCTION__, int(t), spuStatus.threadUsed);
printf("destroy semaphore\n");
destroySem(spuStatus.startSemaphore);
printf("semaphore destroyed\n");
checkPThreadFunction(pthread_join(spuStatus.thread,0));
if (spuStatus.m_lsMemoryReleaseFunc)
{
spuStatus.m_lsMemoryReleaseFunc( spuStatus.m_lsMemory);
}
}
spuStatus.m_userPtr = 0;
checkPThreadFunction(sem_post(spuStatus.startSemaphore));
checkPThreadFunction(sem_wait(m_mainSemaphore));
printf("destroy semaphore\n");
destroySem(spuStatus.startSemaphore);
printf("semaphore destroyed\n");
checkPThreadFunction(pthread_join(spuStatus.thread, 0));
if (spuStatus.m_lsMemoryReleaseFunc)
{
spuStatus.m_lsMemoryReleaseFunc(spuStatus.m_lsMemory);
}
}
printf("destroy main semaphore\n");
destroySem(m_mainSemaphore);
destroySem(m_mainSemaphore);
printf("main semaphore destroyed\n");
m_activeThreadStatus.clear();
}
@@ -310,24 +295,26 @@ public:
virtual unsigned int getSharedParam(int i)
{
if (i<32)
{
return mCommonBuff[i];
} else
{
b3Assert(0);
}
return 0;
if (i < 32)
{
return mCommonBuff[i];
}
else
{
b3Assert(0);
}
return 0;
}
virtual void setSharedParam(int i,unsigned int p)
virtual void setSharedParam(int i, unsigned int p)
{
if (i<32)
{
mCommonBuff[i] = p;
} else
{
b3Assert(0);
}
if (i < 32)
{
mCommonBuff[i] = p;
}
else
{
b3Assert(0);
}
}
virtual void lock()
@@ -340,24 +327,25 @@ public:
}
};
#if defined(_POSIX_BARRIERS) && (_POSIX_BARRIERS - 20012L) >= 0
/* OK to use barriers on this platform */
class b3PosixBarrier : public b3Barrier
{
pthread_barrier_t m_barr;
int m_numThreads;
public:
b3PosixBarrier()
:m_numThreads(0) { }
virtual ~b3PosixBarrier() {
: m_numThreads(0) {}
virtual ~b3PosixBarrier()
{
pthread_barrier_destroy(&m_barr);
}
virtual void sync()
{
int rc = pthread_barrier_wait(&m_barr);
if(rc != 0 && rc != PTHREAD_BARRIER_SERIAL_THREAD)
if (rc != 0 && rc != PTHREAD_BARRIER_SERIAL_THREAD)
{
printf("Could not wait on barrier\n");
exit(-1);
@@ -367,9 +355,9 @@ public:
{
int result = pthread_barrier_init(&m_barr, NULL, numThreads);
m_numThreads = numThreads;
b3Assert(result==0);
b3Assert(result == 0);
}
virtual int getMaxCount()
virtual int getMaxCount()
{
return m_numThreads;
}
@@ -382,16 +370,16 @@ class b3PosixBarrier : public b3Barrier
pthread_cond_t m_cond;
int m_numThreads;
int m_called;
int m_called;
public:
b3PosixBarrier()
:m_numThreads(0)
: m_numThreads(0)
{
}
virtual ~b3PosixBarrier()
{
if (m_numThreads>0)
if (m_numThreads > 0)
{
pthread_mutex_destroy(&m_mutex);
pthread_cond_destroy(&m_cond);
@@ -402,36 +390,36 @@ public:
{
pthread_mutex_lock(&m_mutex);
m_called++;
if (m_called == m_numThreads) {
if (m_called == m_numThreads)
{
m_called = 0;
pthread_cond_broadcast(&m_cond);
} else {
pthread_cond_wait(&m_cond,&m_mutex);
}
else
{
pthread_cond_wait(&m_cond, &m_mutex);
}
pthread_mutex_unlock(&m_mutex);
}
virtual void setMaxCount(int numThreads)
{
if (m_numThreads>0)
if (m_numThreads > 0)
{
pthread_mutex_destroy(&m_mutex);
pthread_cond_destroy(&m_cond);
}
m_called = 0;
pthread_mutex_init(&m_mutex,NULL);
pthread_cond_init(&m_cond,NULL);
pthread_mutex_init(&m_mutex, NULL);
pthread_cond_init(&m_cond, NULL);
m_numThreads = numThreads;
}
virtual int getMaxCount()
virtual int getMaxCount()
{
return m_numThreads;
}
};
#endif//_POSIX_BARRIERS
#endif //_POSIX_BARRIERS
b3Barrier* b3PosixThreadSupport::createBarrier()
{
@@ -445,7 +433,7 @@ b3CriticalSection* b3PosixThreadSupport::createCriticalSection()
return new b3PosixCriticalSection();
}
void b3PosixThreadSupport::deleteBarrier(b3Barrier* barrier)
void b3PosixThreadSupport::deleteBarrier(b3Barrier* barrier)
{
delete barrier;
}
@@ -454,4 +442,4 @@ void b3PosixThreadSupport::deleteCriticalSection(b3CriticalSection* cs)
{
delete cs;
}
#endif //_WIN32
#endif //_WIN32