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

Thanks to Benjamin Hoeferlin, Minh Cuong Tran,Martina Huellmann,Frederick Roth.

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuContactResult.cpp

@@ -19,9 +19,6 @@ subject to the following restrictions:
 //#define DEBUG_SPU_COLLISION_DETECTION 1
 
 
-#include "SpuContactResult.h"
-
-
 SpuContactResult::SpuContactResult()
 {
 	m_manifoldAddress = 0;

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuGatheringCollisionTask.h

@@ -16,10 +16,113 @@ subject to the following restrictions:
 #ifndef SPU_GATHERING_COLLISION_TASK_H
 #define SPU_GATHERING_COLLISION_TASK_H
 
-struct SpuGatherAndProcessPairsTaskDesc;
+#include "../PlatformDefinitions.h"
+//#define DEBUG_SPU_COLLISION_DETECTION 1
+
+
+///Task Description for SPU collision detection
+struct SpuGatherAndProcessPairsTaskDesc 
+{
+	uint64_t	inPtr;//m_pairArrayPtr;
+	//mutex variable
+	uint32_t	m_someMutexVariableInMainMemory;
+
+	uint64_t	m_dispatcher;
+
+	uint32_t	numOnLastPage;
+
+	uint16_t numPages;
+	uint16_t taskId;
+
+	struct	CollisionTask_LocalStoreMemory*	m_lsMemory; 
+}
+
+#if  defined(__CELLOS_LV2__) || defined(USE_LIBSPE2)
+__attribute__ ((aligned (128)))
+#endif
+;
+
 
 void	processCollisionTask(void* userPtr, void* lsMemory);
 
 void*	createCollisionLocalStoreMemory();
 
+
+#if defined(USE_LIBSPE2) && defined(__SPU__)
+#include "../SpuLibspe2Support.h"
+#include <spu_intrinsics.h>
+#include <spu_mfcio.h>
+#include <SpuFakeDma.h>
+
+
+
+int main(unsigned long long speid, addr64 argp, addr64 envp)
+{
+	printf("SPU: hello \n");
+	
+	ATTRIBUTE_ALIGNED128(btSpuStatus status);
+	ATTRIBUTE_ALIGNED16( SpuGatherAndProcessPairsTaskDesc taskDesc ) ;
+	unsigned int received_message = Spu_Mailbox_Event_Nothing;
+    bool shutdown = false;
+
+	cellDmaGet(&status, argp.ull, sizeof(btSpuStatus), DMA_TAG(3), 0, 0);
+	cellDmaWaitTagStatusAll(DMA_MASK(3));
+
+	status.m_status = Spu_Status_Free;
+	status.m_lsMemory.p = createCollisionLocalStoreMemory();
+
+	cellDmaLargePut(&status, argp.ull, sizeof(btSpuStatus), DMA_TAG(3), 0, 0);
+	cellDmaWaitTagStatusAll(DMA_MASK(3));
+	
+	
+	while ( btLikely( !shutdown ) )
+	{
+		
+		received_message = spu_read_in_mbox();
+		
+		if( btLikely( received_message == Spu_Mailbox_Event_Task ))
+		{
+			printf("SPU: received Spu_Mailbox_Event_Task\n");
+		
+			// refresh the status
+			cellDmaGet(&status, argp.ull, sizeof(btSpuStatus), DMA_TAG(3), 0, 0);
+			cellDmaWaitTagStatusAll(DMA_MASK(3));
+		
+			btAssert(status.m_status==Spu_Status_Occupied);
+			
+			cellDmaGet(&taskDesc, status.m_taskDesc.p, sizeof(SpuGatherAndProcessPairsTaskDesc), DMA_TAG(3), 0, 0);
+			cellDmaWaitTagStatusAll(DMA_MASK(3));
+		
+			printf("SPU:processCollisionTask\n");	
+			processCollisionTask((void*)&taskDesc, taskDesc.m_lsMemory);
+			printf("SPU:finished processCollisionTask\n");
+		}
+		else
+		{
+			printf("SPU: received ShutDown\n");
+			if( btLikely( received_message == Spu_Mailbox_Event_Shutdown ) )
+			{
+				shutdown = true;
+			}
+			else
+			{
+				//printf("SPU - Sth. recieved\n");
+			}
+		}
+
+		// set to status free and wait for next task
+		status.m_status = Spu_Status_Free;
+		cellDmaLargePut(&status, argp.ull, sizeof(btSpuStatus), DMA_TAG(3), 0, 0);
+		cellDmaWaitTagStatusAll(DMA_MASK(3));		
+				
+		
+  	}
+	printf("SPU: shutdown\n");
+  	return 0;
+}
+#endif // USE_LIBSPE2
+
+
 #endif //SPU_GATHERING_COLLISION_TASK_H
+
+

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuGjkPairDetector.cpp

@@ -292,7 +292,7 @@ void SpuGjkPairDetector::getClosestPoints(const SpuClosestPointInput& input,SpuC
 	{
 #ifdef __SPU__
 		//spu_printf("distance\n");
-#endif //__CELLOS_LV2__
+#endif //__SPU__
 
 
 		output.addContactPoint(

Extras/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/SpuLocalSupport.h

@@ -36,7 +36,7 @@ struct	SpuConvexPolyhedronVertexData
 };
 
 
-inline btPoint3 localGetSupportingVertexWithoutMargin(int shapeType, void* shape, btVector3& localDir,struct	SpuConvexPolyhedronVertexData* convexVertexData)//, int *featureIndex)
+inline btPoint3 localGetSupportingVertexWithoutMargin(int shapeType, void* shape, btVector3 localDir,struct	SpuConvexPolyhedronVertexData* convexVertexData)//, int *featureIndex)
 {
     switch (shapeType)
     {

Extras/BulletMultiThreaded/SpuSampleTaskProcess.cpp

@@ -19,17 +19,12 @@ subject to the following restrictions:
 #ifdef USE_SAMPLE_PROCESS
 
 
-#include "btThreadSupportInterface.h"
-
-//#include "SPUAssert.h"
-#include <string.h>
-
-
 #include "SpuSampleTaskProcess.h"
-
-
 #include <stdio.h>
 
+#ifdef __SPU__
+
+
 
 void	SampleThreadFunc(void* userPtr,void* lsMemory)
 {
@@ -37,6 +32,7 @@ void	SampleThreadFunc(void* userPtr,void* lsMemory)
 	printf("hello world\n");
 }
 
+
 void*	SamplelsMemoryFunc()
 {
 	//don't create local store memory, just return 0
@@ -44,6 +40,15 @@ void*	SamplelsMemoryFunc()
 }
 
 
+#else
+
+
+#include "btThreadSupportInterface.h"
+
+//#	include "SPUAssert.h"
+#include <string.h>
+
+
 
 extern "C" {
 	extern char SPU_SAMPLE_ELF_SYMBOL[];
@@ -193,4 +198,8 @@ void SpuSampleTaskProcess::flush()
 
 
 }
+
+#endif
+
+
 #endif //USE_SAMPLE_PROCESS

Extras/BulletMultiThreaded/SpuSampleTaskProcess.h

@@ -34,7 +34,7 @@ struct SpuSampleTaskDesc
 	
 	uint16_t 	m_taskId;
 }
-#ifdef __CELLOS_LV2__
+#if defined(__CELLOS_LV2__) || defined(USE_LIBSPE2)
 __attribute__ ((aligned (16)))
 #endif
 ;
@@ -83,5 +83,77 @@ public:
 };
 
 
+#if defined(USE_LIBSPE2) && defined(__SPU__)
+////////////////////MAIN/////////////////////////////
+#include "../SpuLibspe2Support.h"
+#include <spu_intrinsics.h>
+#include <spu_mfcio.h>
+#include <SpuFakeDma.h>
+
+void * SamplelsMemoryFunc();
+void SampleThreadFunc(void* userPtr,void* lsMemory);
+
+int main(unsigned long long speid, addr64 argp, addr64 envp)
+{
+	printf("SPU is up \n");
+	
+	ATTRIBUTE_ALIGNED128(btSpuStatus status);
+	ATTRIBUTE_ALIGNED16( SpuSampleTaskDesc taskDesc ) ;
+	unsigned int received_message = Spu_Mailbox_Event_Nothing;
+        bool shutdown = false;
+
+	cellDmaGet(&status, argp.ull, sizeof(btSpuStatus), DMA_TAG(3), 0, 0);
+	cellDmaWaitTagStatusAll(DMA_MASK(3));
+
+	status.m_status = Spu_Status_Free;
+	status.m_lsMemory.p = SamplelsMemoryFunc();
+
+	cellDmaLargePut(&status, argp.ull, sizeof(btSpuStatus), DMA_TAG(3), 0, 0);
+	cellDmaWaitTagStatusAll(DMA_MASK(3));
+	
+	
+	while (!shutdown)
+	{
+		received_message = spu_read_in_mbox();
+		
+
+		
+		switch(received_message)
+		{
+		case Spu_Mailbox_Event_Shutdown:
+			shutdown = true;
+			break; 
+		case Spu_Mailbox_Event_Task:
+			// refresh the status
+			printf("SPU recieved Task \n");
+			cellDmaGet(&status, argp.ull, sizeof(btSpuStatus), DMA_TAG(3), 0, 0);
+			cellDmaWaitTagStatusAll(DMA_MASK(3));
+		
+			btAssert(status.m_status==Spu_Status_Occupied);
+			
+			cellDmaGet(&taskDesc, status.m_taskDesc.p, sizeof(SpuSampleTaskDesc), DMA_TAG(3), 0, 0);
+			cellDmaWaitTagStatusAll(DMA_MASK(3));
+			
+			SampleThreadFunc((void*)&taskDesc, reinterpret_cast<void*> (taskDesc.m_mainMemoryPtr) );
+			break;
+		case Spu_Mailbox_Event_Nothing:
+		default:
+			break;
+		}
+
+		// set to status free and wait for next task
+		status.m_status = Spu_Status_Free;
+		cellDmaLargePut(&status, argp.ull, sizeof(btSpuStatus), DMA_TAG(3), 0, 0);
+		cellDmaWaitTagStatusAll(DMA_MASK(3));		
+				
+		
+  	}
+  	return 0;
+}
+//////////////////////////////////////////////////////
+#endif
+
+
+
 #endif // SPU_SAMPLE_TASK_PROCESS_H
 

Extras/BulletMultiThreaded/SpuSolverTask/SpuParallellSolverTask.h

@@ -25,16 +25,21 @@ Written by: Marten Svanfeldt
 #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h"
 #include "../SpuSync.h"
 #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h"
+#include "LinearMath/btAlignedAllocator.h"
 
 
 ATTRIBUTE_ALIGNED16(struct) ManifoldCellHolder
 {
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
 	uint32_t					m_hashCellIndex;		
 	class btPersistentManifold*	m_manifold;
 };
 
 ATTRIBUTE_ALIGNED16(struct) ConstraintCellHolder
 {
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
 	uint32_t					m_hashCellIndex;		
 	uint32_t					m_constraintType;
 	class btTypedConstraint*	m_constraint;
@@ -103,6 +108,8 @@ inline unsigned int spuGetHashCellIndex(int x, int y, int z)
 
 ATTRIBUTE_ALIGNED16(struct) SpuSolverBody
 {
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
 	btVector3			m_linearVelocity;
 	btVector3			m_angularVelocity;
 
@@ -113,6 +120,8 @@ ATTRIBUTE_ALIGNED16(struct) SpuSolverBody
 
 ATTRIBUTE_ALIGNED16(struct) SpuSolverInternalConstraint
 {
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
 	uint32_t			m_localOffsetBodyA;
 	uint32_t			m_localOffsetBodyB;
 
@@ -135,6 +144,8 @@ ATTRIBUTE_ALIGNED16(struct) SpuSolverInternalConstraint
 
 ATTRIBUTE_ALIGNED16(struct) SpuSolverConstraint
 {
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
 	uint16_t			m_localOffsetBodyA;
 	uint16_t			m_localOffsetBodyB;
 
@@ -204,6 +215,8 @@ ATTRIBUTE_ALIGNED16(struct) SpuSolverConstraint
 
 ATTRIBUTE_ALIGNED16(struct) SpuSolverDataDesc
 {
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
 	SpuSolverHash*					m_solverHash;
 	SpuSolverBody*					m_solverBodyList;
 	SpuSolverInternalConstraint*	m_solverInternalConstraintList;
@@ -214,6 +227,8 @@ ATTRIBUTE_ALIGNED16(struct) SpuSolverDataDesc
 
 ATTRIBUTE_ALIGNED16(struct) SpuSolverTaskDesc
 {
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
 	uint32_t						m_solverCommand;
 	uint32_t						m_taskId;
 	SpuSolverDataDesc				m_solverData;