GThread.h

Go to the documentation of this file.

#ifndef G3D_GThread_h
#define G3D_GThread_h

#include "G3D/platform.h"
#include "G3D/ReferenceCount.h"
#include "G3D/ThreadSet.h"
#include "G3D/Vector2int32.h"
#include "G3D/SpawnBehavior.h"
#include <string>

#ifndef G3D_WINDOWS
# include <pthread.h>
# include <signal.h>
#endif


namespace G3D {
 
typedef shared_ptr<class GThread> GThreadRef;



class GThread : public ReferenceCountedObject {
private:
 // "Status" is a reserved word on FreeBSD
 enum GStatus {STATUS_CREATED, STATUS_STARTED, STATUS_RUNNING, STATUS_COMPLETED};

 // Not implemented on purpose, don't use
 GThread(const GThread &);
 GThread& operator=(const GThread&);
 bool operator==(const GThread&);

#ifdef G3D_WINDOWS
 static DWORD WINAPI internalThreadProc(LPVOID param);
#else
 static void* internalThreadProc(void* param);
#endif //G3D_WINDOWS

 volatile GStatus m_status;

 // Thread handle to hold HANDLE and pthread_t
#ifdef G3D_WINDOWS
 HANDLE m_handle;
 HANDLE m_event;
#else
 pthread_t m_handle;
#endif //G3D_WINDOWS

 std::string m_name;

protected:

 virtual void threadMain() = 0;

public:

 static int numCores();

 typedef shared_ptr<class GThread> Ref;

 GThread(const std::string& name);

 virtual ~GThread();

 static GThreadRef create(const std::string& name, void (*proc)(void*), void* param = NULL);

 bool start(SpawnBehavior behavior = USE_NEW_THREAD);

 void terminate();

 bool running() const;

 bool started() const;

 bool completed() const;

 void waitForCompletion();

 const std::string& name() {
 return m_name;
 }

 static const SpawnBehavior USE_CURRENT_THREAD = G3D::USE_CURRENT_THREAD;
 static const SpawnBehavior USE_NEW_THREAD = G3D::USE_NEW_THREAD;

 enum {
 NUM_CORES = -100
 };
 
 template<class Class>
 static void runConcurrently2D
 (const Vector2int32& start, 
 const Vector2int32& upTo, 
 Class* object,
 void (Class::*method)(int x, int y),
 int maxThreads = NUM_CORES) {
 _internal_runConcurrently2DHelper(start, upTo, object, method, static_cast<void (Class::*)(int, int, int)>(NULL), maxThreads);
 }

 template<class Class>
 static void runConcurrently2D
 (const Vector2int32& start, 
 const Vector2int32& upTo, 
 Class* object,
 void (Class::*method)(int x, int y, int threadID),
 int maxThreads = NUM_CORES) {
 _internal_runConcurrently2DHelper(start, upTo, object, static_cast<void (Class::*)(int, int)>(NULL), method, maxThreads);
 }

};



 // Can't use an inherited class inside of its parent on g++ 4.2.1 if it is later a template parameter

 template<class Class>
 class _internalGThreadWorker : public GThread {
 public:
 const int threadID;
 const Vector2int32 start;
 const Vector2int32 upTo;
 const Vector2int32 stride;
 Class* object;
 void (Class::*method1)(int x, int y);
 void (Class::*method2)(int x, int y, int threadID);
 
 _internalGThreadWorker(int threadID,
 const Vector2int32& start, 
 const Vector2int32& upTo, 
 Class* object,
 void (Class::*method1)(int x, int y),
 void (Class::*method2)(int x, int y, int threadID),
 const Vector2int32& stride) : 
 GThread("runConcurrently2D worker"),
 threadID(threadID),
 start(start),
 upTo(upTo), 
 stride(stride),
 object(object), 
 method1(method1),
 method2(method2) {}
 
 virtual void threadMain() {
 for (int y = start.y; y < upTo.y; y += stride.y) {
 // Run whichever method was provided
 if (method1) {
 for (int x = start.x; x < upTo.x; x += stride.x) {
 (object->*method1)(x, y);
 }
 } else {
 for (int x = start.x; x < upTo.x; x += stride.x) {
 (object->*method2)(x, y, threadID);
 }
 }
 }
 }
 };


 template<class Class>
 void _internal_runConcurrently2DHelper
 (const Vector2int32& start, 
 const Vector2int32& upTo, 
 Class* object,
 void (Class::*method1)(int x, int y),
 void (Class::*method2)(int x, int y, int threadID),
 int maxThreads) {
 
 // Create a group of threads
 if (maxThreads == GThread::NUM_CORES) {
 maxThreads = GThread::numCores();
 }

 const int numRows = upTo.y - start.y;
 const int numThreads = min(maxThreads, numRows);
 const Vector2int32 stride(1, numThreads);
 ThreadSet threadSet;
 for (int t = 0; t < numThreads; ++t) {
 threadSet.insert(shared_ptr<_internalGThreadWorker<Class> >(new _internalGThreadWorker<Class>(t, start + Vector2int32(0, t), upTo, object, method1, method2, stride)));
 }

 // Run the threads, reusing the current thread and blocking until
 // all complete
 threadSet.start(USE_CURRENT_THREAD);
 threadSet.waitForCompletion();
 }


} // namespace G3D

#endif //G3D_GTHREAD_H