Torque3D/Engine/lib/bullet/examples/MultiThreading/b3PosixThreadSupport.cpp

#ifndef _WIN32
/*
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 <stdio.h>
#include "b3PosixThreadSupport.h"
#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); \
	}

// 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);
}

// cleanup/shutdown Libspe2
b3PosixThreadSupport::~b3PosixThreadSupport()
{
	stopThreads();
}

#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);

	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
#else
	sem_t* tempSem = new sem_t;
	checkPThreadFunction(sem_init(tempSem, 0, 0));
#endif
	return tempSem;
}

static void destroySem(sem_t* semaphore)
{
#ifdef NAMED_SEMAPHORES
	checkPThreadFunction(sem_close(semaphore));
#else
	checkPThreadFunction(sem_destroy(semaphore));
	delete semaphore;
#endif
}

static void* threadFunction(void* argument)
{
	b3PosixThreadSupport::b3ThreadStatus* status = (b3PosixThreadSupport::b3ThreadStatus*)argument;

	while (1)
	{
		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_status = 2;
			checkPThreadFunction(sem_post(status->m_mainSemaphore));
			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);
			break;
		}
	}

	printf("Thread TERMINATED\n");
	return 0;
}

///send messages to SPUs
void b3PosixThreadSupport::runTask(int uiCommand, void* uiArgument0, int taskId)
{
	///	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 B3_THREAD_SCHEDULE_TASK:
		{
			b3ThreadStatus& spuStatus = m_activeThreadStatus[taskId];
			b3Assert(taskId >= 0);
			b3Assert(taskId < m_activeThreadStatus.size());

			spuStatus.m_commandId = uiCommand;
			spuStatus.m_status = 1;
			spuStatus.m_userPtr = (void*)uiArgument0;

			// fire event to start new task
			checkPThreadFunction(sem_post(spuStatus.startSemaphore));
			break;
		}
		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)
{
	b3Assert(m_activeThreadStatus.size());

	// 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;
			}
		}

		b3ThreadStatus& spuStatus = m_activeThreadStatus[last];

		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(m_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
	b3Assert(last >= 0);

	*puiArgument0 = spuStatus.m_taskId;
	*puiArgument1 = spuStatus.m_status;
}

void b3PosixThreadSupport::startThreads(ThreadConstructionInfo& threadConstructionInfo)
{
	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++)
	{
		printf("starting thread %d\n", i);

		b3ThreadStatus& spuStatus = m_activeThreadStatus[i];

		spuStatus.startSemaphore = createSem("threadLocal");

		checkPThreadFunction(pthread_create(&spuStatus.thread, NULL, &threadFunction, (void*)&spuStatus));

		spuStatus.m_userPtr = 0;

		spuStatus.m_taskId = i;
		spuStatus.m_commandId = 0;
		spuStatus.m_status = 0;
		spuStatus.m_mainSemaphore = m_mainSemaphore;
		spuStatus.m_lsMemory = threadConstructionInfo.m_lsMemoryFunc();
		spuStatus.m_userThreadFunc = threadConstructionInfo.m_userThreadFunc;
		spuStatus.m_lsMemoryReleaseFunc = threadConstructionInfo.m_lsMemoryReleaseFunc;
		spuStatus.threadUsed = 0;

		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)
	{
		b3ThreadStatus& spuStatus = m_activeThreadStatus[t];

		// printf("%s: Thread %i used: %ld\n", __FUNCTION__, int(t), spuStatus.threadUsed);

		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);
	printf("main semaphore destroyed\n");
	m_activeThreadStatus.clear();
}

class b3PosixCriticalSection : public b3CriticalSection
{
	pthread_mutex_t m_mutex;

public:
	b3PosixCriticalSection()
	{
		pthread_mutex_init(&m_mutex, NULL);
	}
	virtual ~b3PosixCriticalSection()
	{
		pthread_mutex_destroy(&m_mutex);
	}

	B3_ATTRIBUTE_ALIGNED16(unsigned int mCommonBuff[32]);

	virtual unsigned int getSharedParam(int i)
	{
		if (i < 32)
		{
			return mCommonBuff[i];
		}
		else
		{
			b3Assert(0);
		}
		return 0;
	}
	virtual void setSharedParam(int i, unsigned int p)
	{
		if (i < 32)
		{
			mCommonBuff[i] = p;
		}
		else
		{
			b3Assert(0);
		}
	}

	virtual void lock()
	{
		pthread_mutex_lock(&m_mutex);
	}
	virtual void unlock()
	{
		pthread_mutex_unlock(&m_mutex);
	}
};

#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()
	{
		pthread_barrier_destroy(&m_barr);
	}

	virtual void sync()
	{
		int rc = pthread_barrier_wait(&m_barr);
		if (rc != 0 && rc != PTHREAD_BARRIER_SERIAL_THREAD)
		{
			printf("Could not wait on barrier\n");
			exit(-1);
		}
	}
	virtual void setMaxCount(int numThreads)
	{
		int result = pthread_barrier_init(&m_barr, NULL, numThreads);
		m_numThreads = numThreads;
		b3Assert(result == 0);
	}
	virtual int getMaxCount()
	{
		return m_numThreads;
	}
};
#else
/* Not OK to use barriers on this platform - insert alternate code here */
class b3PosixBarrier : public b3Barrier
{
	pthread_mutex_t m_mutex;
	pthread_cond_t m_cond;

	int m_numThreads;
	int m_called;

public:
	b3PosixBarrier()
		: m_numThreads(0)
	{
	}
	virtual ~b3PosixBarrier()
	{
		if (m_numThreads > 0)
		{
			pthread_mutex_destroy(&m_mutex);
			pthread_cond_destroy(&m_cond);
		}
	}

	virtual void sync()
	{
		pthread_mutex_lock(&m_mutex);
		m_called++;
		if (m_called == m_numThreads)
		{
			m_called = 0;
			pthread_cond_broadcast(&m_cond);
		}
		else
		{
			pthread_cond_wait(&m_cond, &m_mutex);
		}
		pthread_mutex_unlock(&m_mutex);
	}
	virtual void setMaxCount(int numThreads)
	{
		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);
		m_numThreads = numThreads;
	}
	virtual int getMaxCount()
	{
		return m_numThreads;
	}
};

#endif  //_POSIX_BARRIERS

b3Barrier* b3PosixThreadSupport::createBarrier()
{
	b3PosixBarrier* barrier = new b3PosixBarrier();
	barrier->setMaxCount(getNumTasks());
	return barrier;
}

b3CriticalSection* b3PosixThreadSupport::createCriticalSection()
{
	return new b3PosixCriticalSection();
}

void b3PosixThreadSupport::deleteBarrier(b3Barrier* barrier)
{
	delete barrier;
}

void b3PosixThreadSupport::deleteCriticalSection(b3CriticalSection* cs)
{
	delete cs;
}
#endif  //_WIN32