OMP_Thread.h

#ifndef OMP_Thread_H
#define OMP_Thread_H
 
//base class header
#include "CORE_Object.h"
 
//runner option
#include "CORE_Run.h"
 
//OMP pragmas
#include "openMP.h"
 
 
class OMP_Thread : public CORE_Object {
    // ATTRIBUTES
  
private:
 
    static tInteger MAX_THREADS_NUMBER;
    
    // ASSOCIATIONS
  
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    OMP_Thread(void) {
    }
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~OMP_Thread(void) {
    }
  
  
public:
    // NEW methods
    static inline CORE_UniquePointer<OMP_Thread> New() {
        CORE_UniquePointer<OMP_Thread> p(new OMP_Thread(),OMP_Thread::Delete());
        return p;
    }
 
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    // SET methods
public:
    static inline void SetThreadsNumber(const tIndex& nThreads) {
        if ((nThreads>GetMaxThreadsNumber() || (nThreads==0))) OMP_SET_THREADS_NUMBER(GetMaxThreadsNumber());
        else OMP_SET_THREADS_NUMBER(nThreads);
        tInteger nUsedThreads=GetThreadsNumber();
        if (nUsedThreads<nThreads) {
            std::cout<<"Warning: OpenMP threads number wanted: "<<nThreads<<", only "<<GetThreadsNumber()<<" available ! ";
        }
#ifdef DEBUG
        if (nUsedThreads>1) {
            if (CORE_Object::IsMemoryStackEnabled()) {
                std::cout<<"Warning: memory checked is  forced to be disabled because of multi-threadings ";
            }
            CORE_Object::DisableMemoryStack();
        }     
#endif
    }
   
    static inline tBoolean IsOpenMPMultiThreaded()  {
        return OMP_IS_ENABLED();
    }
    
    
    // GET methods
 
    
    static inline tInteger GetThreadId() {
        return OMP_GET_THREAD_ID();
    }
    
    static inline tInteger GetThreadsNumber() {
        tInteger n=1;
        OMP_PARALLEL_SHARED((n)) {
            if (OMP_GET_THREAD_ID()==0) {
                n=OMP_GET_THREADS_NUMBER();
            }
        }
        return n;
    }
    
    static inline  const tInteger& GetMaxThreadsNumber() {
        return MAX_THREADS_NUMBER;
    }
    
    
    static tULLInt GetTime()  {
        return OMP_GET_TIME();
    }
    static inline tULLInt GetDuration(const tULLInt& startTime)  {
        return GetTime()-startTime;
    }
 
    static tInteger SetThreadsOptions(const CORE_OptionsList& options) {
         
        tInteger nThreads=1;
        if (!options.getOptionValue("threads-number",nThreads)) {
            nThreads=1;
        }
        SetThreadsNumber(nThreads);
    
        return nThreads;
        
    }
    
  
};
 
#endif