enable poxix MultiThreading sample under Linux

btgui/MultiThreading/b3PosixThreadSupport.cpp

@@ -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, 
+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:
 
 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"
+#include "b3PosixThreadSupport.h"
-#ifdef USE_PTHREADS
 #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
+b3PosixThreadSupport::b3PosixThreadSupport(ThreadConstructionInfo& threadConstructionInfo)
-PosixThreadSupport::PosixThreadSupport(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];
+			b3ThreadStatus&	spuStatus = m_activeThreadStatus[taskId];
-			btAssert(taskId >= 0);
+			b3Assert(taskId >= 0);
-			btAssert(taskId < m_activeSpuStatus.size());
+			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
 
 }
 
-
+///non-blocking test if a task is completed. First implement all versions, and then enable this API
-///check for messages from SPUs
+bool b3PosixThreadSupport::isTaskCompleted(int *puiArgument0, int *puiArgument1, int timeOutInMilliseconds)
-void PosixThreadSupport::waitForResponse(unsigned int *puiArgument0, unsigned 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());
-	btAssert(m_activeSpuStatus.size());
 
         // wait for any of the threads to finish
-	checkPThreadFunction(sem_wait(mainSemaphore));
+	int result = sem_trywait(mainSemaphore);
-        
+	if (result==0)
-	// get at least one thread which has finished
+    {
+        // get at least one thread which has finished
         size_t last = -1;
-        
+
-        for(size_t t=0; t < size_t(m_activeSpuStatus.size()); ++t) {
+        for(size_t t=0; t < size_t(m_activeThreadStatus.size()); ++t) {
-            if(2 == m_activeSpuStatus[t].m_status) {
+            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);
+	m_activeThreadStatus.resize(threadConstructionInfo.m_numThreads);
-        
+
-	mainSemaphore = createSem("main");                
+	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
 

btgui/MultiThreading/b3PosixThreadSupport.h

@@ -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, 
+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:
 
 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.
@@ -13,14 +13,12 @@ subject to the following restrictions:
 3. This notice may not be removed or altered from any source distribution.
 */
 
-#ifndef BT_POSIX_THREAD_SUPPORT_H
+#ifndef B3_POSIX_THREAD_SUPPORT_H
-#define BT_POSIX_THREAD_SUPPORT_H
+#define B3_POSIX_THREAD_SUPPORT_H
 
 
-#include "LinearMath/btScalar.h"
+#include "Bullet3Common/b3Scalar.h"
-#include "PlatformDefinitions.h"
 
-#ifdef USE_PTHREADS //platform specifc defines are defined in PlatformDefinitions.h
 
 #ifndef _XOPEN_SOURCE
 #define _XOPEN_SOURCE 600 //for definition of pthread_barrier_t, see http://pages.cs.wisc.edu/~travitch/pthreads_primer.html
@@ -30,16 +28,16 @@ subject to the following restrictions:
 
 
 
-#include "LinearMath/btAlignedObjectArray.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
 
-#include "btThreadSupportInterface.h"
+#include "b3ThreadSupportInterface.h"
 
 
-typedef void (*PosixThreadFunc)(void* userPtr,void* lsMemory);
+typedef void (*b3PosixThreadFunc)(void* userPtr,void* lsMemory);
-typedef void* (*PosixlsMemorySetupFunc)();
+typedef void* (*b3PosixlsMemorySetupFunc)();
 
-// PosixThreadSupport helps to initialize/shutdown libspe2, start/stop SPU tasks and communication
+// b3PosixThreadSupport helps to initialize/shutdown libspe2, start/stop SPU tasks and communication
-class PosixThreadSupport : public btThreadSupportInterface 
+class b3PosixThreadSupport : public b3ThreadSupportInterface
 {
 public:
     typedef enum sStatus {
@@ -49,13 +47,13 @@ public:
     } Status;
 
 	// placeholder, until libspe2 support is there
-	struct	btSpuStatus
+	struct	b3ThreadStatus
 	{
-		uint32_t	m_taskId;
+		int	m_taskId;
-		uint32_t	m_commandId;
+		int	m_commandId;
-		uint32_t	m_status;
+		int	m_status;
 
-		PosixThreadFunc	m_userThreadFunc;
+		b3PosixThreadFunc	m_userThreadFunc;
 		void*	m_userPtr; //for taskDesc etc
 		void*	m_lsMemory; //initialized using PosixLocalStoreMemorySetupFunc
 
@@ -66,17 +64,17 @@ public:
 	};
 private:
 
-	btAlignedObjectArray<btSpuStatus>	m_activeSpuStatus;
+	b3AlignedObjectArray<b3ThreadStatus>	m_activeThreadStatus;
 public:
 	///Setup and initialize SPU/CELL/Libspe2
 
-	
+
 
 	struct	ThreadConstructionInfo
 	{
 		ThreadConstructionInfo(const char* uniqueName,
-									PosixThreadFunc userThreadFunc,
+									b3PosixThreadFunc userThreadFunc,
-									PosixlsMemorySetupFunc	lsMemoryFunc,
+									b3PosixlsMemorySetupFunc	lsMemoryFunc,
 									int numThreads=1,
 									int threadStackSize=65535
 									)
@@ -90,58 +88,57 @@ public:
 		}
 
 		const char*					m_uniqueName;
-		PosixThreadFunc			m_userThreadFunc;
+		b3PosixThreadFunc			m_userThreadFunc;
-		PosixlsMemorySetupFunc	m_lsMemoryFunc;
+		b3PosixlsMemorySetupFunc	m_lsMemoryFunc;
 		int						m_numThreads;
 		int						m_threadStackSize;
 
 	};
 
-	PosixThreadSupport(ThreadConstructionInfo& threadConstructionInfo);
+	b3PosixThreadSupport(ThreadConstructionInfo& threadConstructionInfo);
 
 ///cleanup/shutdown Libspe2
-	virtual	~PosixThreadSupport();
+	virtual	~b3PosixThreadSupport();
 
 	void	startThreads(ThreadConstructionInfo&	threadInfo);
 
 
-///send messages to SPUs
+	virtual	void sendRequest(int uiCommand, void* uiArgument0, int uiArgument1);
-	virtual	void sendRequest(uint32_t uiCommand, ppu_address_t uiArgument0, uint32_t uiArgument1);
 
-///check for messages from SPUs
+	virtual	void waitForResponse(int *puiArgument0, int *puiArgument1);
-	virtual	void waitForResponse(unsigned int *puiArgument0, unsigned int *puiArgument1);
 
-///start the spus (can be called at the beginning of each frame, to make sure that the right SPU program is loaded)
-	virtual	void startSPU();
 
 ///tell the task scheduler we are done with the SPU tasks
-	virtual	void stopSPU();
+	virtual	void stopThreads();
 
 	virtual void setNumTasks(int numTasks) {}
 
 	virtual int getNumTasks() const
 	{
-		return m_activeSpuStatus.size();
+		return m_activeThreadStatus.size();
 	}
 
-	virtual btBarrier* createBarrier();
+	///non-blocking test if a task is completed. First implement all versions, and then enable this API
+	virtual bool isTaskCompleted(int *puiArgument0, int *puiArgument1, int timeOutInMilliseconds);
 
-	virtual btCriticalSection* createCriticalSection();
 
-	virtual void deleteBarrier(btBarrier* barrier);
+	virtual b3Barrier* createBarrier();
+
+	virtual b3CriticalSection* createCriticalSection();
+
+	virtual void deleteBarrier(b3Barrier* barrier);
+
+	virtual void deleteCriticalSection(b3CriticalSection* criticalSection);
+
 
-	virtual void deleteCriticalSection(btCriticalSection* criticalSection);
-	
-	
 	virtual void*	getThreadLocalMemory(int taskId)
 	{
-		return m_activeSpuStatus[taskId].m_lsMemory;
+		return m_activeThreadStatus[taskId].m_lsMemory;
 	}
 
 };
 
-#endif // USE_PTHREADS
 
-#endif // BT_POSIX_THREAD_SUPPORT_H
+#endif // B3_POSIX_THREAD_SUPPORT_H
 
 

btgui/MultiThreading/b3SequentialThreadSupport.cpp

@@ -1,179 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-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, 
-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.
-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.
-*/
-
-#include "b3SequentialThreadSupport.h"
-
-
-
-b3SequentialThreadSupport::b3SequentialThreadSupport(SequentialThreadConstructionInfo& threadConstructionInfo)
-{
-	startThreads(threadConstructionInfo);
-}
-
-///cleanup/shutdown Libspe2
-b3SequentialThreadSupport::~b3SequentialThreadSupport()
-{
-	stopThreads();
-}
-
-#include <stdio.h>
-
-///send messages to SPUs
-void b3SequentialThreadSupport::sendRequest(int uiCommand, void* uiArgument0, int taskId)
-{
-	switch (uiCommand)
-	{
-	case 	B3_THREAD_SCHEDULE_TASK:
-		{
-			btSpuStatus&	spuStatus = m_activeSpuStatus[0];
-			spuStatus.m_userPtr=(void*)uiArgument0;
-			spuStatus.m_userThreadFunc(spuStatus.m_userPtr,spuStatus.m_lsMemory);
-		}
-	break;
-	default:
-		{
-			///not implemented
-			b3Assert(0 && "Not implemented");
-		}
-
-	};
-
-
-}
-
-///check for messages from SPUs
-void b3SequentialThreadSupport::waitForResponse(unsigned int *puiArgument0, unsigned int *puiArgument1)
-{
-	b3Assert(m_activeSpuStatus.size());
-	btSpuStatus& spuStatus = m_activeSpuStatus[0];
-	*puiArgument0 = spuStatus.m_taskId;
-	*puiArgument1 = spuStatus.m_status;
-}
-
-void b3SequentialThreadSupport::startThreads(SequentialThreadConstructionInfo& threadConstructionInfo)
-{
-	m_activeSpuStatus.resize(1);
-	printf("STS: Not starting any threads\n");
-	btSpuStatus& spuStatus = m_activeSpuStatus[0];
-	spuStatus.m_userPtr = 0;
-	spuStatus.m_taskId = 0;
-	spuStatus.m_commandId = 0;
-	spuStatus.m_status = 0;
-	spuStatus.m_lsMemory = threadConstructionInfo.m_lsMemoryFunc();
-	spuStatus.m_userThreadFunc = threadConstructionInfo.m_userThreadFunc;
-	printf("STS: Created local store at %p for task %s\n", spuStatus.m_lsMemory, threadConstructionInfo.m_uniqueName);
-}
-
-void b3SequentialThreadSupport::startThreads()
-{
-}
-
-void b3SequentialThreadSupport::stopThreads()
-{
-	m_activeSpuStatus.clear();
-}
-
-void b3SequentialThreadSupport::setNumTasks(int numTasks)
-{
-	printf("b3SequentialThreadSupport::setNumTasks(%d) is not implemented and has no effect\n",numTasks);
-}
-
-
-
-
-class btDummyBarrier : public b3Barrier
-{
-private:
-		
-public:
-	btDummyBarrier()
-	{
-	}
-	
-	virtual ~btDummyBarrier()
-	{
-	}
-	
-	void sync()
-	{
-	}
-	
-	virtual void setMaxCount(int n) {}
-	virtual int  getMaxCount() {return 1;}
-};
-
-class btDummyCriticalSection : public b3CriticalSection
-{
-	
-public:
-	btDummyCriticalSection()
-	{
-	}
-	
-	virtual ~btDummyCriticalSection()
-	{
-	}
-	
-	unsigned int getSharedParam(int i)
-	{
-		b3Assert(i>=0&&i<31);
-		return mCommonBuff[i+1];
-	}
-	
-	void setSharedParam(int i,unsigned int p)
-	{
-		b3Assert(i>=0&&i<31);
-		mCommonBuff[i+1] = p;
-	}
-	
-	void lock()
-	{
-		mCommonBuff[0] = 1;
-	}
-	
-	void unlock()
-	{
-		mCommonBuff[0] = 0;
-	}
-};
-
-
-
-
-b3Barrier*	b3SequentialThreadSupport::createBarrier()
-{
-	return new btDummyBarrier();
-}
-
-b3CriticalSection* b3SequentialThreadSupport::createCriticalSection()
-{
-	return new btDummyCriticalSection();
-	
-}
-
-void b3SequentialThreadSupport::deleteBarrier(b3Barrier* barrier)
-{
-    delete barrier;
-}
-
-void b3SequentialThreadSupport::deleteCriticalSection(b3CriticalSection* criticalSection)
-{
-    delete criticalSection;
-}
-
-
-
-
-

btgui/MultiThreading/b3SequentialThreadSupport.h

@@ -1,100 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-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, 
-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.
-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.
-*/
-
-#include "Bullet3Common/b3Scalar.h"
-
-
-
-#ifndef B3_SEQUENTIAL_THREAD_SUPPORT_H
-#define B3_SEQUENTIAL_THREAD_SUPPORT_H
-
-#include "Bullet3Common/b3AlignedObjectArray.h"
-
-#include "b3ThreadSupportInterface.h"
-
-typedef void (*SequentialThreadFunc)(void* userPtr,void* lsMemory);
-typedef void* (*SequentiallsMemorySetupFunc)();
-
-
-
-///The b3SequentialThreadSupport is a portable non-parallel implementation of the btThreadSupportInterface
-///This is useful for debugging and porting SPU Tasks to other platforms.
-class b3SequentialThreadSupport : public b3ThreadSupportInterface 
-{
-public:
-	struct	btSpuStatus
-	{
-		int	m_taskId;
-		int	m_commandId;
-		int	m_status;
-
-		SequentialThreadFunc	m_userThreadFunc;
-
-		void*	m_userPtr; //for taskDesc etc
-		void*	m_lsMemory; //initialized using SequentiallsMemorySetupFunc
-	};
-private:
-	b3AlignedObjectArray<btSpuStatus>	m_activeSpuStatus;
-	b3AlignedObjectArray<void*>			m_completeHandles;	
-public:
-	struct	SequentialThreadConstructionInfo
-	{
-		SequentialThreadConstructionInfo (const char* uniqueName,
-									SequentialThreadFunc userThreadFunc,
-									SequentiallsMemorySetupFunc	lsMemoryFunc
-									)
-									:m_uniqueName(uniqueName),
-									m_userThreadFunc(userThreadFunc),
-									m_lsMemoryFunc(lsMemoryFunc)
-		{
-
-		}
-
-		const char*						m_uniqueName;
-		SequentialThreadFunc		m_userThreadFunc;
-		SequentiallsMemorySetupFunc	m_lsMemoryFunc;
-	};
-
-	b3SequentialThreadSupport(SequentialThreadConstructionInfo& threadConstructionInfo);
-	virtual	~b3SequentialThreadSupport();
-	void	startThreads(SequentialThreadConstructionInfo&	threadInfo);
-///send messages to SPUs
-	virtual	void sendRequest(int uiCommand, void* uiArgument0, int uiArgument1);
-///check for messages from SPUs
-	virtual	void waitForResponse(unsigned int *puiArgument0, unsigned int *puiArgument1);
-///start the spus (can be called at the beginning of each frame, to make sure that the right SPU program is loaded)
-	virtual	void startThreads();
-///tell the task scheduler we are done with the SPU tasks
-	virtual	void stopThreads();
-
-	virtual void setNumTasks(int numTasks);
-
-	virtual int getNumTasks() const
-	{
-		return 1;
-	}
-	virtual b3Barrier*	createBarrier();
-
-	virtual b3CriticalSection* createCriticalSection();
-	
-    virtual void deleteBarrier(b3Barrier* barrier);
-    
-    virtual void deleteCriticalSection(b3CriticalSection* criticalSection);
-
-
-};
-
-#endif //B3_SEQUENTIAL_THREAD_SUPPORT_H
-

btgui/MultiThreading/b3ThreadSupportInterface.h

@@ -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, 
+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:
 
 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.
@@ -66,7 +66,6 @@ public:
 	///non-blocking test if a task is completed. First implement all versions, and then enable this API
 	virtual bool isTaskCompleted(int *puiArgument0, int *puiArgument1, int timeOutInMilliseconds)=0;
 
-	virtual	void startThreads() =0;
 
 	virtual	void stopThreads()=0;
 
@@ -82,7 +81,7 @@ public:
 	virtual void deleteBarrier(b3Barrier* barrier)=0;
 
     virtual void deleteCriticalSection(b3CriticalSection* criticalSection)=0;
-	
+
 	virtual void*	getThreadLocalMemory(int taskId) { return 0; }
 
 };

btgui/MultiThreading/main.cpp

@@ -4,8 +4,8 @@ Copyright (c) 2010 Erwin Coumans  http://bulletphysics.org
 
 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, 
+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:
 
 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.
@@ -17,7 +17,7 @@ subject to the following restrictions:
 /// You can start threads and perform a blocking wait for completion
 /// Under Windows it uses Win32 Threads. On Mac and Linux it uses pthreads. On PlayStation 3 Cell SPU it uses SPURS.
 
-/// June 2010 
+/// June 2010
 /// New: critical section/barriers and non-blocking pollingn for completion, currently Windows only
 
 void	SampleThreadFunc(void* userPtr,void* lsMemory);
@@ -26,20 +26,19 @@ void*	SamplelsMemoryFunc();
 #include <stdio.h>
 //#include "BulletMultiThreaded/PlatformDefinitions.h"
 
-#ifdef USE_PTHREADS
+#ifndef _WIN32
-//#ifdef __APPLE__
+#include "b3PosixThreadSupport.h"
-#include "BulletMultiThreaded/PosixThreadSupport.h"
 
 b3ThreadSupportInterface* createThreadSupport(int numThreads)
 {
-	PosixThreadSupport::ThreadConstructionInfo constructionInfo("testThreads",
+	b3PosixThreadSupport::ThreadConstructionInfo constructionInfo("testThreads",
                                                                 SampleThreadFunc,
                                                                 SamplelsMemoryFunc,
                                                                 numThreads);
-    b3ThreadSupportInterface* threadSupport = new PosixThreadSupport(constructionInfo);
+    b3ThreadSupportInterface* threadSupport = new b3PosixThreadSupport(constructionInfo);
-	
+
 	return threadSupport;
-	
+
 }
 
 
@@ -51,12 +50,12 @@ b3ThreadSupportInterface* createThreadSupport(int numThreads)
 	b3Win32ThreadSupport::Win32ThreadConstructionInfo threadConstructionInfo("testThreads",SampleThreadFunc,SamplelsMemoryFunc,numThreads);
 	b3Win32ThreadSupport* threadSupport = new b3Win32ThreadSupport(threadConstructionInfo);
 	return threadSupport;
-	
-}
 
+}
 #endif
 
 
+
 struct	SampleArgs
 {
 	SampleArgs()
@@ -122,8 +121,7 @@ int main(int argc,char** argv)
 
 	b3ThreadSupportInterface* threadSupport = createThreadSupport(numThreads);
 
-	
+
-	threadSupport->startThreads();
 
 	for (int i=0;i<threadSupport->getNumTasks();i++)
 	{
@@ -131,13 +129,13 @@ int main(int argc,char** argv)
 		b3Assert(storage);
 		storage->threadId = i;
 	}
-	
+
 
 	SampleArgs	args;
 	args.m_cs = threadSupport->createCriticalSection();
 	args.m_cs->setSharedParam(0,100);
 
-	
+
 	int arg0,arg1;
 	int i;
 	for (i=0;i<numThreads;i++)
@@ -145,7 +143,7 @@ int main(int argc,char** argv)
 		threadSupport->sendRequest(B3_THREAD_SCHEDULE_TASK, (void*) &args, i);
 	}
 
-	bool blockingWait =true;
+	bool blockingWait =false;
 	if (blockingWait)
 	{
 		for (i=0;i<numThreads;i++)
@@ -155,25 +153,19 @@ int main(int argc,char** argv)
 		}
 	} else
 	{
-#if _WIN32
 		int numActiveThreads = numThreads;
 		while (numActiveThreads)
 		{
-			if (((b3Win32ThreadSupport*)threadSupport)->isTaskCompleted(&arg0,&arg1,0))
+			if (threadSupport->isTaskCompleted(&arg0,&arg1,0))
 			{
 				numActiveThreads--;
 				printf("numActiveThreads = %d\n",numActiveThreads);
 
 			} else
 			{
-				printf("polling\n");
+//				printf("polling..");
 			}
 		};
-#else
-	btAssert(0);
-	printf("non-blocking wait is not supported on this platform\n");
-	exit(0);
-#endif
 	}
 
 printf("stopping threads\n");

btgui/MultiThreading/premake4.lua

@@ -17,19 +17,35 @@
 	
 	
 	files {
-		"**.cpp",
+		"b3ThreadSupportInterface.cpp",
-		"**.h"
+		"main.cpp",
+		"b3ThreadSupportInterface.h"
 	}
 	if os.is("Windows") then
+
+		files {
+                "b3Win32ThreadSupport.cpp",  
+                "b3Win32ThreadSupport.h" 
+		}
 		--links {"winmm"}
 		--defines {"__WINDOWS_MM__", "WIN32"}
 	end
 
 	if os.is("Linux") then 
+		files {
+                "b3PosixThreadSupport.cpp",  
+                "b3PosixThreadSupport.h"    
+        	}
+
 		links {"pthread"}
 	end
 
 	if os.is("MacOSX") then
+		files {
+                "b3PosixThreadSupport.cpp",
+                "b3PosixThreadSupport.h"    
+                }
+
 		links {"pthread"}
 		--links{"CoreAudio.framework", "coreMIDI.framework", "Cocoa.framework"}
 		--defines {"__MACOSX_CORE__"}

build3/premake4.lua

@@ -100,6 +100,7 @@
 	language "C++"
 	
 	include "../Demos3/Wavefront"
+	include "../btgui/MultiThreading"
 
 	if not _OPTIONS["ios"] then
 --		include "../demo/gpudemo"