Programming

void update() {
   thread1->update();  // fluid solver
   thread2->update();  // particle system
   thread3->update();  // camera1 optical flow
   thread4->update();  // camera2 optical flow
   // all of the above threads have their own data and work independantly

   etc.
   .
   .. wait till all the above threads are done.
   .. once they are done, feed the data from each of them into other ones
   .. e.g. fluid velocity info is added to particle systems reedy for next frame's update
   .. e.g. camera optical flow data is fed into fluid solver, ready for next frame's update
   
   render all
}

#include "ofxThread.h"

class MSAThread : public ofxThread {

	bool bHasRunThisFrame;
	bool bAutoLoop;
	int interval;

public:

	// create the thread, if autoLoop is true, start running straight away and loop, 
	// otherwise wait for the runOnce command
	void start(int frameRate = 30, bool initAutoLoop = false){	
		interval = 1000/frameRate;
		bAutoLoop = initAutoLoop;
		if(!bAutoLoop) bHasRunThisFrame = true;		// don't run straight away
		startThread(true, false);   // blocking, verbose
	}
	
	// run the update function once in another thread
	void runOnce() {					
		if(lock()) {
			bAutoLoop = false; 
			bHasRunThisFrame = false;
			unlock();
		}
	}

	// run the update function in another thread
	void threadedFunction() {						
		while(isThreadRunning()) {
			if( lock() ){
				if(bAutoLoop || !bHasRunThisFrame) {
					update();
					bHasRunThisFrame = true;
					unlock();
					ofSleepMillis(interval); 
				} else {
					unlock();
				}
			}
		}
	}
	
	// main thread waits for the update function to finish 
	void waitForFinish() { if(lock()) { unlock(); } }	
	
	// this is the function that gets overvidden
	virtual void update() = 0;							
};

class ofxThread{

	public:
		ofxThread();
		virtual ~ofxThread();
		bool isThreadRunning();
		void startThread(bool _blocking = true, bool _verbose = true);
		bool lock();
		bool unlock();
		void stopThread();

	protected:

		//-------------------------------------------------
		//you need to overide this with the function you want to thread
		virtual void threadedFunction(){
			if(verbose)printf("ofxThread: overide threadedFunction with your own\n");
		}

		//-------------------------------------------------

		#ifdef TARGET_WIN32
			static unsigned int __stdcall thread(void * objPtr){
				ofxThread* me	= (ofxThread*)objPtr;
				me->threadedFunction();
				return 0;
			}

		#else
			static void * thread(void * objPtr){
				ofxThread* me	= (ofxThread*)objPtr;
				me->threadedFunction();
				return 0;
			}
		#endif


	#ifdef TARGET_WIN32
			HANDLE            myThread;
			CRITICAL_SECTION  critSec;  	//same as a mutex
	#else
			pthread_t        myThread;
			pthread_mutex_t  myMutex;
	#endif

	bool threadRunning;
	bool blocking;
	bool verbose;
};


//-------------------------------------------------
ofxThread::ofxThread(){
	threadRunning = false;
}

//-------------------------------------------------
ofxThread::~ofxThread(){
	stopThread();
}

//-------------------------------------------------
bool ofxThread::isThreadRunning(){
	//should be thread safe - no writing of vars here
	return threadRunning;
}

//-------------------------------------------------
void ofxThread::startThread(bool _blocking, bool _verbose){

	//have to put this here because the thread can be running
	//before the call to create it returns
	threadRunning	= true;

	#ifdef TARGET_WIN32
		InitializeCriticalSection(&critSec);
		myThread = (HANDLE)_beginthreadex(NULL, 0, this->thread,  (void *)this, 0, NULL);
	#else
		pthread_mutex_init(&myMutex, NULL);
		pthread_create(&myThread, NULL, thread, (void *)this);
	#endif

	blocking		=	_blocking;
	verbose			= _verbose;
}

//-------------------------------------------------
//returns false if it can't lock
bool ofxThread::lock(){
	if(!threadRunning){
		if(verbose)printf("ofxThread: need to call startThread first\n");
		return false;
	}

	#ifdef TARGET_WIN32
		if(blocking)EnterCriticalSection(&critSec);
		else {
			if(!TryEnterCriticalSection(&critSec)){
				if(verbose)printf("ofxThread: mutext is busy \n");
				return false;
			}
		}
		if(verbose)printf("ofxThread: we are in -- mutext is now locked \n");
	#else

		if(blocking){
			if(verbose)printf("ofxThread: waiting till mutext is unlocked\n");
			pthread_mutex_lock(&myMutex);
			if(verbose)printf("ofxThread: we are in -- mutext is now locked \n");
		}else{
			int value = pthread_mutex_trylock(&myMutex);
			if(value == 0){
				if(verbose)printf("ofxThread: we are in -- mutext is now locked \n");
			}
			else{
				if(verbose)printf("ofxThread: mutext is busy - already locked\n");
				return false;
			}
		}
	#endif

	return true;
}

//-------------------------------------------------
bool ofxThread::unlock(){

	if(!threadRunning){
		if(verbose)printf("ofxThread: need to call startThread first\n");
		return false;
	}

	#ifdef TARGET_WIN32
		LeaveCriticalSection(&critSec);
	#else
		pthread_mutex_unlock(&myMutex);
	#endif

	if(verbose)printf("ofxThread: we are out -- mutext is now unlocked \n");

	return true;
}

//-------------------------------------------------
void ofxThread::stopThread(){
	if(threadRunning){
		#ifdef TARGET_WIN32
			CloseHandle(myThread);
		#else
			pthread_mutex_destroy(&myMutex);
			pthread_detach(myThread);
		#endif
		if(verbose)printf("ofxThread: thread stopped\n");
		threadRunning = false;
	}else{
		if(verbose)printf("ofxThread: thread already stopped\n");
	}
}

void MSAThread::threadedFunction() {						
	while(isThreadRunning()) {
		if( lock() ){
			if(bAutoLoop || !bHasRunThisFrame) {
				update();
				bHasRunThisFrame = true;
				unlock();
//				ofSleepMillis(interval); 
			} else {
				unlock();
			}
		}
	}
}

// CriticalSection.h
// 
// A class using Resource Management technique(RM: see 
// http://www.relisoft.com/resource/resource.html for
// discussion) to handle critical section code that 
// guarantees no memory leaks or open locks.
//
// Revision Log
//
// Date       Who SAR     Notes
// ========== === ======= =====================================
//                        (c) Reliable Software, 1997, 98
//                        Bartosz Milewski, www.relisoft.com
// 

#ifdef SAMPLE_CODE

   // somewhere with the resource to protect
   CCriticalSection _critSect;

   // later in the code...
   {
      CLock lock(_critSect);
      // perform action which may throw
      myVar += 10;
      // guaranteed automatic destructor of lock
      // when it goes out of scope
   }
}
#endif


#ifndef RFC_CRITICAL_SECTION_H
#define RFC_CRITICAL_SECTION_H

#include <windows.h>

class CCriticalSection
{
   friend class CLock;
public:
   CCriticalSection() { InitializeCriticalSection(&_critSectStruct); }
   ~CCriticalSection() { DeleteCriticalSection(&_critSectStruct); }
private: 
   // these must only be used by CLock object, never directly
   void Enter() { EnterCriticalSection(&_critSectStruct); }
   void Leave() { LeaveCriticalSection(&_critSectStruct); }

   CCriticalSection(CCriticalSection& o); // not allowed
   CCriticalSection& operator=(CCriticalSection& o); // not allowed

   CRITICAL_SECTION _critSectStruct;
};

class CLock 
{
public:
    CLock(CCriticalSection& critSect) 
        : _critSectObj(critSect) 
    {
        _critSectObj.Enter();
    }
    ~CLock()
    {
        _critSectObj.Leave();
    }
private:
    CCriticalSection & _critSectObj;
};

#endif