parallelExecutionContainer.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2014-2015 VT MAK
 * All rights reserved.
 ****************************************************************************/


#pragma once

#if defined(_WIN32) && _MSC_VER < 1400
#define DtVRL_TBB_UNSUPPORTED 1 
#elif __rhentws7__
#define DtVRL_TBB_ARENA_UNSUPPORTED 1
#endif

#include <vl/executionContainer.h>
#include <vl/entityPublisher.h>

#ifndef DtVRL_TBB_UNSUPPORTED
#include <tbb/tbb.h>
#include <tbb/task_arena.h>
#else
#pragma message("Warning, DtParallelExecutionContainer parallel execution not supported on VC7 or earlier due to missing TBB dependency.")
#endif

#include <vector>
#include <algorithm>

DT_DLL_VL bool DtEnableParallelExecutionAccess(bool enable);

DT_DLL_VL void DtLockParallelExecutionAccess();

DT_DLL_VL void DtUnlockParallelExecutionAccess();

DT_DLL_VL void DtEnterParallelExecutionSection();

DT_DLL_VL void DtLeaveParallelExecutionSection();

class DT_DLL_VL DtScopedParallelExecutionLock {
public:
   explicit DtScopedParallelExecutionLock() { DtLockParallelExecutionAccess(); }

   ~DtScopedParallelExecutionLock() { DtUnlockParallelExecutionAccess(); }

private:
   DtScopedParallelExecutionLock(const DtScopedParallelExecutionLock&);
   DtScopedParallelExecutionLock& operator=(const DtScopedParallelExecutionLock&);
};


template <class Texec> 
class DtParallelExecutionContainer : public DtExecutionContainer<Texec>
{
public:

   typedef typename std::vector<Texec *>             PecContainerType;
   typedef typename PecContainerType::iterator       PecIteratorType;

private:
   class ExecutableItem
   {
   private:
      const PecContainerType& myCV;

      void (Texec::*myMethodPtr)();

   public:

#ifndef DtVRL_TBB_UNSUPPORTED
      void operator()( const tbb::blocked_range<size_t>& r ) const 
      {
         for( size_t i=r.begin(); i!=r.end(); ++i ) 
         {
            ((*myCV[i]).*myMethodPtr)();
         }
      }
#endif
      ExecutableItem(const PecContainerType& theCV, void (Texec::*theMethodPtr)()) 
         : myCV(theCV) 
         , myMethodPtr(theMethodPtr)
      {
      }
   };

public:

   DtParallelExecutionContainer(bool parallel = true) : useParallel(parallel), myNumThreads(-1), myExecVec() {}
   virtual ~DtParallelExecutionContainer() { }

   virtual void add(Texec *item) {  myExecVec.push_back(item); }

   virtual void remove(Texec *item) { myExecVec.erase(std::remove(begin(), end(), item), end()); }

   virtual void clear() { myExecVec.clear(); }

   virtual bool empty() { return myExecVec.empty(); }

   virtual unsigned int count() { return myExecVec.size(); }

   virtual void deleteAndClear();

   virtual PecIteratorType      begin()        { return  myExecVec.begin();  }
   virtual PecIteratorType      end()          { return  myExecVec.end();    }


   virtual void executeMethod(void (Texec::*theMethodPtr)());

   virtual void setParallel(bool parallel) { useParallel = parallel; }
   virtual bool isParallel() const { return useParallel; }

   virtual void setMaxNumberThreads( int numThreads ) { myNumThreads = numThreads; };
   virtual int maxNumberThreads() const { return myNumThreads; };

protected:
   virtual void executeMethodParallel(void (Texec::*theMethodPtr)());

   virtual void executeMethodSerial(void (Texec::*theMethodPtr)());

   virtual void beginParallel() { DtEnterParallelExecutionSection(); }

   virtual void endParallel()   { DtLeaveParallelExecutionSection(); }

   PecContainerType myExecVec;

private:
   bool useParallel;

   int myNumThreads;
};

// Delete all referenced objects and then clear the list.
template<class Texec>
inline void DtParallelExecutionContainer<Texec>::deleteAndClear()
{
   for (PecIteratorType item = begin(); item != end(); ++item)
   {
      delete (*item);
   }
   clear();
}

// Execute method on all contained objects
template<class Texec>
inline void DtParallelExecutionContainer<Texec>::executeMethod(void (Texec::*theMethodPtr)()) 
{
   if (useParallel)
   {
      executeMethodParallel(theMethodPtr);
   }
   else
   {
      executeMethodSerial(theMethodPtr);
   }
}

// Execute method on all contained objects in parallel
template<class Texec>
inline void DtParallelExecutionContainer<Texec>::executeMethodParallel(void (Texec::*theMethodPtr)())
{
#ifndef DtVRL_TBB_UNSUPPORTED
   size_t size = myExecVec.size();
   tbb::blocked_range<size_t> range(0, size);
   ExecutableItem execST(myExecVec, theMethodPtr);
#ifndef DtVRL_TBB_ARENA_UNSUPPORTED
   tbb::task_arena limited_arena(myNumThreads);
   beginParallel();
   limited_arena.execute([&] { tbb::parallel_for(range, execST); });
   endParallel();
#else
   beginParallel();
   tbb::parallel_for(range, execST);
   endParallel();
#endif
#else
   executeMethodSerial(theMethodPtr);
#endif
}

// Execute method on all contained objects serially
template<class Texec>
inline void DtParallelExecutionContainer<Texec>::executeMethodSerial(void (Texec::*theMethodPtr)()) 
{
   for (PecIteratorType item = begin(); item != end(); ++item)
   {
      ((**item).*theMethodPtr)();
   }
}