btThreadSupportPosix.cpp

Go to the documentation of this file.

 
/*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2018 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.
*/
 
#if BT_THREADSAFE && !defined(_WIN32)
 
#include "LinearMath/btScalar.h"
#include "LinearMath/btAlignedObjectArray.h"
#include "LinearMath/btThreads.h"
#include "LinearMath/btMinMax.h"
#include "btThreadSupportInterface.h"
 
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
 
#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE 600  //for definition of pthread_barrier_t, see http://pages.cs.wisc.edu/~travitch/pthreads_primer.html
#endif                     //_XOPEN_SOURCE
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>  //for sysconf
 
#if __cplusplus >= 201103L
 
#include <thread>
 
int btGetNumHardwareThreads()
{
        return btMax(1u, btMin(BT_MAX_THREAD_COUNT, std::thread::hardware_concurrency()));
}
 
#else
 
int btGetNumHardwareThreads()
{
        return btMax(1, btMin<int>(BT_MAX_THREAD_COUNT, sysconf(_SC_NPROCESSORS_ONLN)));
}
 
#endif
 
// btThreadSupportPosix helps to initialize/shutdown libspe2, start/stop SPU tasks and communication
class btThreadSupportPosix : public btThreadSupportInterface
{
public:
        struct btThreadStatus
        {
                int m_taskId;
                int m_commandId;
                int m_status;
 
                ThreadFunc m_userThreadFunc;
                void* m_userPtr;  //for taskDesc etc
 
                pthread_t thread;
                //each tread will wait until this signal to start its work
                sem_t* startSemaphore;
                btCriticalSection* m_cs;
                // this is a copy of m_mainSemaphore,
                //each tread will signal once it is finished with its work
                sem_t* m_mainSemaphore;
                unsigned long threadUsed;
        };
 
private:
        typedef unsigned long long UINT64;
 
        btAlignedObjectArray<btThreadStatus> m_activeThreadStatus;
        // m_mainSemaphoresemaphore will signal, if and how many threads are finished with their work
        sem_t* m_mainSemaphore;
        int m_numThreads;
        UINT64 m_startedThreadsMask;
        void startThreads(const ConstructionInfo& threadInfo);
        void stopThreads();
        int waitForResponse();
        btCriticalSection* m_cs;
public:
        btThreadSupportPosix(const ConstructionInfo& threadConstructionInfo);
        virtual ~btThreadSupportPosix();
 
        virtual int getNumWorkerThreads() const BT_OVERRIDE { return m_numThreads; }
        // TODO: return the number of logical processors sharing the first L3 cache
        virtual int getCacheFriendlyNumThreads() const BT_OVERRIDE { return m_numThreads + 1; }
        // TODO: detect if CPU has hyperthreading enabled
        virtual int getLogicalToPhysicalCoreRatio() const BT_OVERRIDE { return 1; }
 
        virtual void runTask(int threadIndex, void* userData) BT_OVERRIDE;
        virtual void waitForAllTasks() BT_OVERRIDE;
 
        virtual btCriticalSection* createCriticalSection() BT_OVERRIDE;
        virtual void deleteCriticalSection(btCriticalSection* criticalSection) BT_OVERRIDE;
};
 
#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.
 
btThreadSupportPosix::btThreadSupportPosix(const ConstructionInfo& threadConstructionInfo)
{
        m_cs = createCriticalSection();
        startThreads(threadConstructionInfo);
}
 
// cleanup/shutdown Libspe2
btThreadSupportPosix::~btThreadSupportPosix()
{
        stopThreads();
        deleteCriticalSection(m_cs);
        m_cs=0;
}
 
#if (defined(__APPLE__))
#define NAMED_SEMAPHORES
#endif
 
static sem_t* createSem(const char* baseName)
{
        static int semCount = 0;
#ifdef NAMED_SEMAPHORES
        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);
        }
#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)
{
        btThreadSupportPosix::btThreadStatus* status = (btThreadSupportPosix::btThreadStatus*)argument;
 
        while (1)
        {
                checkPThreadFunction(sem_wait(status->startSemaphore));
                void* userPtr = status->m_userPtr;
 
                if (userPtr)
                {
                        btAssert(status->m_status);
                        status->m_userThreadFunc(userPtr);
                        status->m_cs->lock();
                        status->m_status = 2;
                        status->m_cs->unlock();
                        checkPThreadFunction(sem_post(status->m_mainSemaphore));
                        status->threadUsed++;
                }
                else
                {
                        //exit Thread
                        status->m_cs->lock();
                        status->m_status = 3;
                        status->m_cs->unlock();
                        checkPThreadFunction(sem_post(status->m_mainSemaphore));
                        break;
                }
        }
 
        return 0;
}
 
void btThreadSupportPosix::runTask(int threadIndex, void* userData)
{
        btThreadStatus& threadStatus = m_activeThreadStatus[threadIndex];
        btAssert(threadIndex >= 0);
        btAssert(threadIndex < m_activeThreadStatus.size());
        threadStatus.m_cs = m_cs;
        threadStatus.m_commandId = 1;
        threadStatus.m_status = 1;
        threadStatus.m_userPtr = userData;
        m_startedThreadsMask |= UINT64(1) << threadIndex;
 
        // fire event to start new task
        checkPThreadFunction(sem_post(threadStatus.startSemaphore));
}
 
int btThreadSupportPosix::waitForResponse()
{
 
        btAssert(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)
        {
                m_cs->lock();
                bool hasFinished = (2 == m_activeThreadStatus[t].m_status);
                m_cs->unlock(); 
                if (hasFinished)
                {
                        last = t;
                        break;
                }
        }
 
        btThreadStatus& threadStatus = m_activeThreadStatus[last];
 
        btAssert(threadStatus.m_status > 1);
        threadStatus.m_status = 0;
 
        // need to find an active spu
        btAssert(last >= 0);
        m_startedThreadsMask &= ~(UINT64(1) << last);
 
        return last;
}
 
void btThreadSupportPosix::waitForAllTasks()
{
        while (m_startedThreadsMask)
        {
                waitForResponse();
        }
}
 
void btThreadSupportPosix::startThreads(const ConstructionInfo& threadConstructionInfo)
{
        m_numThreads = btGetNumHardwareThreads() - 1;  // main thread exists already
        m_activeThreadStatus.resize(m_numThreads);
        m_startedThreadsMask = 0;
 
        m_mainSemaphore = createSem("main");
        //checkPThreadFunction(sem_wait(mainSemaphore));
 
        for (int i = 0; i < m_numThreads; i++)
        {
                btThreadStatus& threadStatus = m_activeThreadStatus[i];
                threadStatus.startSemaphore = createSem("threadLocal");
                threadStatus.m_userPtr = 0;
                threadStatus.m_cs = m_cs;
                threadStatus.m_taskId = i;
                threadStatus.m_commandId = 0;
                threadStatus.m_status = 0;
                threadStatus.m_mainSemaphore = m_mainSemaphore;
                threadStatus.m_userThreadFunc = threadConstructionInfo.m_userThreadFunc;
                threadStatus.threadUsed = 0;
                checkPThreadFunction(pthread_create(&threadStatus.thread, NULL, &threadFunction, (void*)&threadStatus));
 
        }
}
 
void btThreadSupportPosix::stopThreads()
{
        for (size_t t = 0; t < size_t(m_activeThreadStatus.size()); ++t)
        {
                btThreadStatus& threadStatus = m_activeThreadStatus[t];
 
                threadStatus.m_userPtr = 0;
                checkPThreadFunction(sem_post(threadStatus.startSemaphore));
                checkPThreadFunction(sem_wait(m_mainSemaphore));
 
                checkPThreadFunction(pthread_join(threadStatus.thread, 0));
                destroySem(threadStatus.startSemaphore);
        }
        destroySem(m_mainSemaphore);
        m_activeThreadStatus.clear();
}
 
class btCriticalSectionPosix : public btCriticalSection
{
        pthread_mutex_t m_mutex;
 
public:
        btCriticalSectionPosix()
        {
                pthread_mutex_init(&m_mutex, NULL);
        }
        virtual ~btCriticalSectionPosix()
        {
                pthread_mutex_destroy(&m_mutex);
        }
 
        virtual void lock()
        {
                pthread_mutex_lock(&m_mutex);
        }
        virtual void unlock()
        {
                pthread_mutex_unlock(&m_mutex);
        }
};
 
btCriticalSection* btThreadSupportPosix::createCriticalSection()
{
        return new btCriticalSectionPosix();
}
 
void btThreadSupportPosix::deleteCriticalSection(btCriticalSection* cs)
{
        delete cs;
}
 
btThreadSupportInterface* btThreadSupportInterface::create(const ConstructionInfo& info)
{
        return new btThreadSupportPosix(info);
}
 
#endif  // BT_THREADSAFE && !defined( _WIN32 )