gmThreadManager.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/
 
#ifndef _GEMA_THREAD_MANAGER_H_
#define _GEMA_THREAD_MANAGER_H_
 
#include "gmCoreConfig.h"
#include "gmLog.h"
 
#include <assert.h>
 
#include <QWaitCondition>
#include <QMutex>
#include <QQueue>
 
class QThread;
class GmSimulationData;
class GmThread;
class GmInternalThread;
class LuaEnv;
 
struct QtHardwareInfo;
 
template <class T, bool Align> class GmTLS; // We can not include gmThreadLocalStorage.h without creating a circular reference
 
#ifdef Q_OS_WIN 
#define GmThreadLocal __declspec(thread)
#else
#define GmThreadLocal __thread
#endif
 
// Global variable for thread id optimized management.  Defined in the .cpp file.
extern GmThreadLocal int GmThreadManagerThreadId;
 
enum GmThreadTaskResult
{
  GM_THREAD_OK       = 1, 
  GM_THREAD_CANCELED = 2, 
  GM_THREAD_ABORTED  = 3, 
};
 
class GMC_API_EXPORT GmThreadTask
{
public:
  GmThreadTask() : _taskIndex(-1) {}
 
  virtual ~GmThreadTask() {}
 
  virtual GmThreadTaskResult run(const GmThread* thread) = 0;
 
  virtual QString taskDescription() { return ""; }
 
  int taskIndex() const { return _taskIndex; }
 
  void setTaskIndex(int index) { _taskIndex = index; }
 
private:
  int _taskIndex;
};
 
 
class GMC_API_EXPORT GmThreadManager
{
public:
  GmThreadManager(GmSimulationData* simData);
  ~GmThreadManager();
 
  void setWorkerThreadLuaEnv(LuaEnv* mainEnv, const QList<LuaEnv*>& envList);
 
  LuaEnv* threadLuaEnv(int tid) const;
 
  void addTask(GmThreadTask* task, int tid = 0);
  GmThreadTaskResult runTasks (int nthreads);
  void               execTasks(int nthreads);
 
  const QVector<int>& taskAffinity() const { return _taskAffinity; }
 
  int numTasks() const;
 
  bool cancelRequested() const { return _cancelRequested; }
 
  bool cancelPending() const { return _cancelRequested || _abortRequested; }
 
 
  void setCancelFlag(bool mode = true) { _cancelRequested = mode; }
 
  const GmLogCategory& logger() { return _logger; }
 
  static int maxWorkerThreads() { assert(_maxNumThreads >= 0); return _maxNumThreads; }
 
  static int maxProcThreads() { assert(_maxProcThreads > 0); return _maxProcThreads; }
 
  static int numProcCores() { assert(_numProcCores > 0); return _numProcCores; }
 
  static int currentId() { return GmThreadManagerThreadId; }
 
  static bool inMainThread() { return currentId() == 0; }
 
private:
  friend class GmThread;
 
  enum ThreadPriority
  {
    BelowNormal,
    Normal,
    AboveNormal,
    High,
  };
 
  enum ProcAffinityMode
  {
    NoAffinity,
    QoSAffinity,
    SoftAffinity,
    HardAffinity,
  };
 
  struct ThreadConfig
  {
    int              _maxThreads;             
    int              _maxOpenMPThreads;       
    int              _maxBlasThreads;         
    ThreadPriority   _procPriority;           
    ThreadPriority   _threadPriority;         
    ProcAffinityMode _affMode;                
    QVector<quint64> _procMask;               
    QVector<quint64> _threadMask;             
    bool             _L3ThreadScheduling;     
#ifdef Q_OS_WIN 
    QVector<QPair<int, quint64>> _threadSingleGroupMasks; 
#endif
  };
 
  void parseConfigOptions(GmSimulationData* simData);
  void initProcAffinity();
 
#ifdef Q_OS_WIN 
  void winInitProcOrThreadSoftAffinity(bool thread, const QVector<quint64>& maskVector);
#endif
 
  int clearTaskQueues();
  int numTasksInQueues() const;
 
#ifdef ENABLE_TESTS
  // Allows test function to have access to the ThreadManager logger
  friend GMC_API_EXPORT void TEST_GmThreadManager(const GmLogCategory& logger, GmLogLevel level);
#endif
 
  typedef QQueue<GmThreadTask*> GmTaskQueue; 
 
  static int                 _maxNumThreads;   
  static int                 _maxProcThreads;  
  static int                 _numProcCores;    
 
  QtHardwareInfo*            _hwInfo;          
  ThreadConfig               _config;          
 
  GmThread*                  _mainThread;      
  QList<GmThread*>           _threadList;      
  GmTLS<GmTaskQueue, false>* _taskQueues;      
  int                        _numTasks;        
  int                        _npendingTasks;   
  QVector<int>               _taskAffinity;    
  int                        _maxAffinityId;   
 
  int                    _active;          
  bool                   _cancelRequested; 
  bool                   _abortRequested;  
                         
  QMutex                 _taskMutex;       
  QWaitCondition         _managerCond;     
                         
  GmLogCategory          _logger;          
 
  GmTLS<LuaEnv*, false>* _luaEnv;          
};
 
 
class GMC_API_EXPORT GmThread
{
public:
  GmThread(GmThreadManager* manager, int tid);
  GmThread(GmThreadManager* manager);
 
  ~GmThread();
 
  int id() const { return _tid; }
 
  GmThreadManager* threadManager() const { return _tm; }
 
  QThread* thread() const { return _thread; }
 
  bool cancelPending() const { return _tm->cancelPending(); }
 
  inline LuaEnv* luaEnv() const { return _tm->threadLuaEnv(_tid); }
 
private:
  friend class GmThreadManager;
  friend class GmInternalThread;
 
  void start();
  bool wait(unsigned long time = ULONG_MAX);
  void run();
 
  void initThreadAffinity();
 
  int               _tid;      
  QThread*          _thread;   
  GmThreadManager*  _tm;       
  QWaitCondition    _idleCond; 
};
 
 
#endif