parallelExecutionContainer.h

Go to the documentation of this file.

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


#pragma once

#if _MSC_VER < 1400
#define TBB_SUPPORTED FALSE
#else
#define TBB_SUPPORTED TRUE
#endif

#include <vrfutil/executionContainer.h>

#if (TBB_SUPPORTED)
#pragma message("Using TBB for parallel execution.")
#include <tbb/tbb.h>
#else
#pragma message("MAK WARNING: DtParallelExecutionContainer parallel execution not supported on VC7 or earlier due to missing TBB dependency.")
#endif

#include <vector>

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:

#if (TBB_SUPPORTED)

      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) 
      : myExecVec()
      , myUseParallel(parallel)
      , myGrainSize(10) 
      {
      }

   virtual ~DtParallelExecutionContainer() { }

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

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

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

   virtual void deleteAndClear();

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

   virtual bool contains(Texec *item) { return std::find(begin(), end(), item) != end(); }

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

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

   virtual void setParallel(bool parallel) { myUseParallel = parallel; }

   virtual bool isParallel() const { return myUseParallel; }

   virtual void setGrainSize(int theGrainSize) { myGrainSize = theGrainSize; }

   virtual int getGrainSize() const { return myGrainSize; }

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

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

   PecContainerType myExecVec;

private:
   bool myUseParallel;
   
   int myGrainSize;
};

template<class Texec>
inline void DtParallelExecutionContainer<Texec>::deleteAndClear()
{
   for (PecIteratorType item = begin(); item != end(); ++item)
   {
      delete (*item);
   }
   clear();
}

template<class Texec>
inline void DtParallelExecutionContainer<Texec>::executeMethod(void (Texec::*theMethodPtr)())
{
   if (empty())
   {
      return;
   }

   if (myUseParallel)
   {
      executeMethodParallel(theMethodPtr);
   }
   else
   {
      executeMethodSerial(theMethodPtr);
   }
}

template<class Texec>
inline void DtParallelExecutionContainer<Texec>::executeMethodParallel(void (Texec::*theMethodPtr)())
{
#if (TBB_SUPPORTED)
   try
   {
      tbb::blocked_range<size_t> range(0, myExecVec.size(), myGrainSize);
      ExecutableItem execST(myExecVec, theMethodPtr);
      tbb::parallel_for(range, execST);
   }
   catch (tbb::captured_exception& ex)
   {
      DtTHROW_NEW(DtException, ex.what());
   }
#else

   executeMethodSerial(theMethodPtr);
#endif
}

template<class Texec>
inline void DtParallelExecutionContainer<Texec>::executeMethodSerial(void (Texec::*theMethodPtr)()) 
{
   for (PecIteratorType item = begin(); item != end(); ++item)
   {
      ((**item).*theMethodPtr)();
   }
}