parallelTickManager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2014 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include "vrfcore/vrfcoreDefines.h"
#include "vrfutil/callbackQueue.h"

#include <tbb/mutex.h>
#include <tbb/compat/condition_variable>

#include <boost/noncopyable.hpp>

#include <boost/unordered/unordered_map.hpp>

class DtConsoleCommandOwner;
class DtSubCommandManager;
class DtVrfSimOptionsInterface;

class DT_DLL_vrfcore DtParallelTickManager : boost::noncopyable
{
public:
   class DT_DLL_vrfcore ParallelScopeGuard :  boost::noncopyable
   {
      DtParallelTickManager* myParallelTickManager;
      bool myReadFlag;

   public:
      explicit ParallelScopeGuard(DtParallelTickManager*, bool read=false);
      ~ParallelScopeGuard();

      bool release();
      void acquire(DtParallelTickManager*, bool read=false);
   };

   class DT_DLL_vrfcore SerialScopeGuard : boost::noncopyable
   {
      DtParallelTickManager* myParallelTickManager;
      bool myWriteFlag;

   public:
      explicit SerialScopeGuard(DtParallelTickManager*, bool write=true);
      ~SerialScopeGuard();

      bool upgradeToWriter();
      void downgradeToReader();

      void release();
      void acquire(DtParallelTickManager*, bool write=true);
   };

   class DT_DLL_vrfcore CallbackInterface : private DtCallbackQueue::CallbackInterface
   {
      friend class DtParallelTickManager;

      void run();

   public:
      virtual ~CallbackInterface();

      virtual void runCallback() = 0;
   };

   class DT_DLL_vrfcore SerialCallbackInterface : public CallbackInterface
   {
      DtParallelTickManager* myManager;

      void run();

   public:
      explicit SerialCallbackInterface(DtParallelTickManager* = 0);

      void setParallelTickManager(DtParallelTickManager*);
   };

   typedef boost::unordered_map<std::string, bool> EnabledMap;

   explicit DtParallelTickManager(DtVrfSimOptionsInterface* options);
   virtual ~DtParallelTickManager();

   virtual void setCallbackQueue(DtCallbackQueue*);

   virtual DtCallbackQueue* queue() const;


   virtual void flushQueue(bool useThisThread);
   virtual void flushQueue();


   virtual bool mainThreadWait() const;
   virtual void setMainThreadWait(bool);


   virtual bool active() const;
   virtual void setActive(bool);

   virtual bool enabled(const std::string&, bool def) const;

   virtual bool executeCommand(const std::string&, bool on);

   virtual void printInfo(std::ostream&) const;


   virtual void addCallback(CallbackInterface*, bool runNow=false);
   virtual void addCallback(CallbackInterface&, bool runNow=false);
   virtual void addCallback(SerialCallbackInterface*, bool runNow=false);
   virtual void addCallback(SerialCallbackInterface&, bool runNow=false);

   virtual void addCallback(CallbackInterface*, const std::string& tag, bool def=true);
   virtual void addCallback(CallbackInterface&, const std::string& tag, bool def=true);
   virtual void addCallback(SerialCallbackInterface*, const std::string& tag, bool def=true);
   virtual void addCallback(SerialCallbackInterface&, const std::string& tag, bool def=true);

   void addCallback(CallbackInterface*, const char* tag, bool def=true);
   void addCallback(CallbackInterface&, const char* tag, bool def=true);
   void addCallback(SerialCallbackInterface*, const char* tag, bool def=true);
   void addCallback(SerialCallbackInterface&, const char* tag, bool def=true);

   template <typename Container>
   void addCallbacks(Container& cont, bool runNow=false)
   {
      typedef typename Container::iterator iterator;
      for (iterator i=cont.begin(), end=cont.end(); i != end; ++i)
         addCallback(*i, runNow);
   }

   template <typename Container>
   void addCallbacks(Container& cont, const std::string& tag, bool def=true)
   {
      bool runNow = !enabled(tag, def);
      typedef typename Container::iterator iterator;
      for (iterator i=cont.begin(), end=cont.end(); i != end; ++i)
         addCallback(*i, runNow);
   }

   template <typename Container>
   void addCallbacks(Container& cont, const char* tag, bool def=true)
   {
      addCallbacks(cont, std::string(tag), def);
   }

private:

   virtual void lock();
   virtual void unlock();
   virtual void readLock();
   virtual void readUnlock();
   virtual bool upgradeToWriter();
   virtual void downgradeToReader();

   virtual void createCallbackQueue(bool force=false);

   typedef tbb::mutex Mutex;
   typedef tbb::interface5::condition_variable Condition;
   typedef tbb::interface5::unique_lock<Mutex> Lock;

   Mutex myMutex;
   Condition myCondition;
   size_t myReaderCount;

   DtVrfSimOptionsInterface* myOptions;
   DtCallbackQueue* myCallbackQueue;

   mutable EnabledMap myEnabledMap;
   bool myWaitFlag;

   DtSubCommandManager* myCommandManager;
   DtConsoleCommandOwner* myCommandOwner;
};