mitkSPMD.h

/*=========================================================================

  Program:   3DMed
  Date:      $Date: 2014-02-25 18:30:00 +0800 $
  Version:   $Version: 4.6.0 $
  Copyright: MIPG, Institute of Automation, Chinese Academy of Sciences

=========================================================================*/

#ifndef __mitkSPMD_h
#define __mitkSPMD_h

#include "mitkObject.h"

class mitkMutex;
class mitkConditionVariable;
class mitkSPMD;

class MITK_COMMON_API mitkBarrier:public mitkObject
{
public:
    void Synchronize();
    friend class mitkSPMD;
private:
    mitkBarrier(int NumberOfThreads);
    virtual ~mitkBarrier();
    mitkBarrier(const mitkBarrier&);
    void operator = (const mitkBarrier&);

    int m_NumberOfThreads;
    int m_Count;
    mitkConditionVariable *m_CV;
};

class MITK_COMMON_API mitkSPMD:public mitkObject
{
public:
    MITK_TYPE(mitkSPMD,mitkObject)
    void SetNumberOfThreads(int NumberOfThreads);
    int GetNumberOfThreads() const
    {
        return m_NumberOfThreads;
    }
    void RunSPMD();
    static int  GetGlobalDefaultNumberOfThreads();
    
protected:
    mitkSPMD();
    virtual ~mitkSPMD();
    // create thread specific structures here is subclasses
    virtual void SPMDInit(){};
    // call by threads
    virtual void ThreadExecute(int ThreadID)=0;
    // destroy thread specific structures here is subclasses
    virtual void SPMDFinish(){};

    void Synchronize()
    {
        if (m_Barrier) m_Barrier->Synchronize();
    }

    mitkBarrier *GetBarrier(){return m_Barrier;}

private:
    mitkSPMD(const mitkSPMD&);
    void operator = (const mitkSPMD&);
    int m_NumberOfThreads;
    mitkBarrier *m_Barrier;

};

class MITK_COMMON_API mitkSPMDDelegate: public mitkSPMD
{
public:
    MITK_TYPE(mitkSPMDDelegate,mitkSPMD)
    void SetParameter(void *param)
    {
        m_Param=param;
    }
protected:
    mitkSPMDDelegate() {m_Param=NULL;}
    virtual ~mitkSPMDDelegate(){}
    void *GetParameter()
    {
        return m_Param;
    }
private:
    mitkSPMDDelegate(const mitkSPMDDelegate&);
    void operator = (const mitkSPMDDelegate&);
    void *m_Param;
};

class mitkSPMDStatic: public mitkSPMDDelegate
{
public:
    mitkSPMDStatic(void (*ThreadedFunction)(int,int,void *,mitkBarrier*),
                        void (*InitFunction)(int,void *)=NULL,
                        void (*FinishFunction)(int,void *)=NULL)
    {
        m_ThreadedFunction=ThreadedFunction;    
        m_InitFunction=InitFunction;
        m_FinishFunction=FinishFunction;        
    }

protected:
    virtual ~mitkSPMDStatic(){}
    virtual void SPMDInit()
    {
        if (m_InitFunction) m_InitFunction(GetNumberOfThreads(),GetParameter());    
    }
    virtual void ThreadExecute(int ThreadID)
    {
        m_ThreadedFunction(ThreadID,GetNumberOfThreads(),GetParameter(),GetBarrier());
    }
    virtual void SPMDFinish()
    {
        if (m_FinishFunction) m_FinishFunction(GetNumberOfThreads(),GetParameter());
    }
private:
    mitkSPMDStatic(const mitkSPMDStatic&);
    void operator = (const mitkSPMDStatic&);
    void (*m_InitFunction)(int,void *);
    void (*m_FinishFunction)(int,void *);
    void (*m_ThreadedFunction)(int,int,void *,mitkBarrier*);
};

template<class T>
class mitkSPMDMember: public mitkSPMDDelegate
{
public:
    mitkSPMDMember(T* object,void (T::*ThreadedMember)(int,int,void*,mitkBarrier*),
                        void (T::*InitMember)(int,void*)=NULL,
                        void (T::*FinishMember)(int,void*)=NULL)
    {
        m_object=object;
        m_ThreadedMember=ThreadedMember;    
        m_InitMember=InitMember;
        m_FinishMember=FinishMember;
    }
protected:
    virtual ~mitkSPMDMember(){}
    virtual void SPMDInit()
    {
        if (m_InitMember) (m_object->*m_InitMember)(GetNumberOfThreads(),GetParameter());
    }
    virtual void ThreadExecute(int ThreadID)
    {
        (m_object->*m_ThreadedMember)(ThreadID,GetNumberOfThreads(),GetParameter(),GetBarrier());
    }
    virtual void SPMDFinish()
    {
        if (m_FinishMember) (m_object->*m_FinishMember)(GetNumberOfThreads(),GetParameter());
    }
    
private:
    mitkSPMDMember(const mitkSPMDMember&);
    void operator = (const mitkSPMDMember&);    
    T *m_object;
    void (T::*m_InitMember)(int,void*);
    void (T::*m_FinishMember)(int,void*);
    void (T::*m_ThreadedMember)(int,int,void*,mitkBarrier*);
};

#define MITK_SPMD_MEMBER1(Class,ObjectPointer,ThreadedMember)\
mitkSPMDMember<Class>(ObjectPointer,&Class::ThreadedMember)

#define MITK_SPMD_MEMBER2(Class,ObjectPointer,ThreadedMember,InitMember)\
mitkSPMDMember<Class>(ObjectPointer,&Class::ThreadedMember,&Class::InitMember)

#define MITK_SPMD_MEMBER3(Class,ObjectPointer,ThreadedMember,InitMember,FinishMember)\
mitkSPMDMember<Class>(ObjectPointer,&Class::ThreadedMember,&Class::InitMember,&Class::FinishMember)


#endif

---