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 "vrfutil/profiler.h"

#include <boost/noncopyable.hpp>
#include <boost/unordered/unordered_map.hpp>

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

#include <vector>

class DtConsoleCommandOwner;
class DtSubCommandManager;
class DtVrfSimOptionsInterface;
class DtParallelTickManager;
class DtCriticalSection;
class DtSimManager;

class DT_DLL_vrfcore DtParallelTickManager : boost::noncopyable
{
public:
   enum AccessType
   {
      EXCLUSIVE,
      SHARED,
      UNLOCKED
   };

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

      void run();

   public:
      virtual ~CallbackInterface();

      virtual void runCallback() = 0;
   };

   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(CallbackInterface*, const std::string& tag, bool def=true);
   virtual void addCallback(CallbackInterface&, 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);

   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);
   }


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

   virtual void changeAccess(AccessType from, AccessType to);

   class ThreadLocalInfo;

   virtual ThreadLocalInfo& threadLocalInfo();

private:
   virtual void createCallbackQueue(bool force=false);

   typedef tbb::mutex Mutex;
   typedef tbb::interface5::condition_variable ConditionVariable;
   typedef tbb::interface5::unique_lock<Mutex> ScopedLock;

   mutable Mutex myMutex;
   mutable ConditionVariable myReadCondition;
   mutable ConditionVariable myWriteCondition;
   bool myWriteLock;
   unsigned myNumWriters;
   unsigned myNumReaders;
   unsigned myNumWaitingReaders;

   typedef tbb::cache_aligned_allocator<ThreadLocalInfo*> ThreadLocalAllocator;
   //typedef tbb::enumerable_thread_specific<
   typedef tbb::enumerable_thread_specific<
      ThreadLocalInfo*,
      ThreadLocalAllocator,
      tbb::ets_key_per_instance> ThreadLocalContainer;

   ThreadLocalContainer myThreadLocals;

   DtVrfSimOptionsInterface* myOptions;
   DtCallbackQueue* myCallbackQueue;

   mutable EnabledMap myEnabledMap;
   bool myWaitFlag;

   DtSubCommandManager* myCommandManager;
   DtConsoleCommandOwner* myCommandOwner;
};

class DT_DLL_vrfcore DtCriticalSection : boost::noncopyable
{
public:
   typedef DtParallelTickManager::AccessType AccessType;

   explicit DtCriticalSection(DtSimManager*, AccessType to);
   explicit DtCriticalSection(DtSimManager*);
   explicit DtCriticalSection(DtCriticalSection&, AccessType to);
   explicit DtCriticalSection(DtCriticalSection&);

   ~DtCriticalSection();

   void reset(AccessType access);

   void unlock();
   void lockShared();
   void lock();

   void release()
   {
      reset(from);
   }

protected:
   explicit DtCriticalSection(DtParallelTickManager*, AccessType to);
   explicit DtCriticalSection(DtParallelTickManager*);

   friend class DtParallelTickManager;

   DtParallelTickManager* mgr;
   DtParallelTickManager::ThreadLocalInfo* info;

   AccessType from;
   AccessType to;
};

class DT_DLL_vrfcore DtParallelTickManager::ThreadLocalInfo : boost::noncopyable
{
public:
   explicit ThreadLocalInfo(DtParallelTickManager* m);

   DtParallelTickManager::AccessType state() const;

private:
   friend class DtCriticalSection;

   void push(DtCriticalSection& cs);
   void pop(DtCriticalSection& cs);

   typedef std::vector<DtCriticalSection*> Stack;
   Stack myLocks;
};