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;

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;

  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;

  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;    

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

  int               _tid;      
  QThread*          _thread;   
  GmThreadManager*  _tm;       
  QWaitCondition    _idleCond; 
};


#endif