ThreadsCounter.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef _THREADS_COUNTER_H_
#define _THREADS_COUNTER_H_
 
#include "TD_PackPush.h"
#include "OdMutex.h"
 
class FIRSTDLL_EXPORT OdMutexPtr
{
public:
  OdMutexPtr(): m_ptr(0){}
  ~OdMutexPtr();
  OdMutex* get() { if(!m_ptr) create(); return m_ptr; }
  void clear();
private:
  void create();
 
private:
  static OdMutex s_mt;
  OdMutex* m_ptr;
};
 
class OdMutexPtrAutoLock
{
public:
  OdMutexPtrAutoLock(OdMutex* mutex) : m_mutex(mutex), m_bEnable(false)
  {
    lock();
  }
 
  ~OdMutexPtrAutoLock()
  {
    unlock();
  }
 
  void lock() { set(true); }
  void unlock() { set(false); }
 
protected:
  OdMutexPtrAutoLock(): m_mutex(NULL), m_bEnable(false){}
  void set(bool bEnable)
  {
    if(m_mutex && (m_bEnable != bEnable))
    {
      m_bEnable = bEnable;
      if(bEnable)
        m_mutex->lock();
      else
        m_mutex->unlock();
    }
  }
protected:
  OdMutex* m_mutex;
private:
  bool m_bEnable;
};
 
class ThreadsCounterReactor
{
  public:
    ThreadsCounterReactor() { }
 
    virtual void addRef() = 0;
 
    virtual void release() = 0;
 
    virtual void increase(unsigned /*nThreads*/, const unsigned* /*aThreads*/, unsigned /*nThreadAttributes*/) { }
    virtual void decrease(unsigned /*nThreads*/, const unsigned* /*aThreads*/, unsigned /*nThreadAttributes*/) { }
 
    virtual void startThread(unsigned /*nThreadId*/, unsigned /*nThreadAttributes*/) { }
    virtual void stopThread(unsigned /*nThreadId*/, unsigned /*nThreadAttributes*/) { }
  protected:
    virtual ~ThreadsCounterReactor() { }
};
 
// Function for execute in the main thread
typedef void (*MainThreadFunc)(void*);
// Function for initiate execution in the main thread by external process
typedef void (*ExecuteMainThreadFunc)(MainThreadFunc, void*);
 
class OdRxThreadPoolService;
 
class FIRSTDLL_EXPORT ThreadsCounter
{
public:
  enum ThreadAttributes
  {
    kNoAttributes = 0, // Simple Mt-process which doesn't require any special initializations
 
    kMtLoadingAttributes = (1 << 0), // Actual for both MtLoading and loading of DB's in multiple threads
    kMtRegenAttributes   = (1 << 1), // Multithread regeneration
    kStRegenAttributes   = (1 << 2), // Regeneration w/o cache (local heaps not required)
    kMtDisplayAttributes = (1 << 3), // Multithread display
    kMtModelerAttributes = (1 << 4), // Modeling operations in parallel threads
    kAllAttributes       = 0xFFFFFFFF // Applicable for Mt functionality tests
  };
protected:
  ThreadsCounter()
    : m_count(1)
    , m_mainThreadFunc(NULL)
    , m_threadPool(NULL) { }
  ~ThreadsCounter() { }
public:
  operator bool() const { return m_count > 1; }
 
  bool addReactor(ThreadsCounterReactor *pReactor);
  bool removeReactor(ThreadsCounterReactor *pReactor);
  bool hasReactor(ThreadsCounterReactor *pReactor) const;
  int nReactors() const;
 
  /* Following methods are intended for internal usage by ODA Platform libraries and not recommended for usage outside. */
 
  void setThreadPoolService(OdRxThreadPoolService *pService) { m_threadPool = pService; }
  OdRxThreadPoolService *getThreadPoolService() { return m_threadPool; }
 
  void increase(unsigned nThreads, const unsigned* aThreads, unsigned nThreadAttributes = ThreadsCounter::kNoAttributes)
  { ++m_count; increaseProc(nThreads, aThreads, nThreadAttributes); }
  void decrease(unsigned nThreads, const unsigned* aThreads)
  { --m_count; decreaseProc(nThreads, aThreads); }
 
  void startThread() { startThreadProc(); }
  void stopThread() { stopThreadProc(); }
 
  bool hasThread(unsigned nThreadId, unsigned *pThreadAttributes)
  { return hasThreadProc(nThreadId, pThreadAttributes); }
 
  void setMainThreadFunc(ExecuteMainThreadFunc func) { m_mainThreadFunc = func; }
  ExecuteMainThreadFunc getMainThreadFunc() { return m_mainThreadFunc; }
 
protected:
  void increaseProc(unsigned nThreads, const unsigned* aThreads, unsigned nThreadAttributes);
  void decreaseProc(unsigned nThreads, const unsigned* aThreads);
  void startThreadProc();
  void stopThreadProc();
  bool hasThreadProc(unsigned nThreadId, unsigned *pThreadAttributes);
 
protected:
  OdRefCounter           m_count;
  ExecuteMainThreadFunc  m_mainThreadFunc;
  OdRxThreadPoolService *m_threadPool;
};
 
FIRSTDLL_EXPORT ThreadsCounter&   odThreadsCounter();
 
FIRSTDLL_EXPORT bool              odExecuteMainThreadAction(MainThreadFunc mtFunc, void *pArg, bool bExecST = true);
 
FIRSTDLL_EXPORT unsigned          odGetCurrentThreadId();
FIRSTDLL_EXPORT void              odThreadYield();
 
#define TD_AUTOLOCK_P(Mutex)      OdMutexPtrAutoLock autoLock(Mutex);
#define TD_AUTOLOCK_P_DEF(Mutex)  OdMutexPtrAutoLock autoLock(odThreadsCounter() ? Mutex.get() : NULL);
 
#include "TD_PackPop.h"
 
#endif //_THREADS_COUNTER_H_