tahoma2d/toonz/sources/common/tcore/tthread_x.cpp

#include "tthread.h"
#include <pthread.h>

//---------------------------------------------------------------------------
//    TMutex & TMutexImp
//---------------------------------------------------------------------------

class TMutexImp {
  pthread_mutex_t id;

public:
  TMutexImp();
  ~TMutexImp();
  void lock();
  void unlock();
};

//---------------------------------------------------------------------------
TMutex lockForTheList;

class TThreadGroupImp {
  list<TThread *> threads;

public:
  TThreadGroupImp();
  ~TThreadGroupImp();
  void add(TThread *);
  void remove(TThread *);
  void wait();
};

//---------------------------------------------------------------------------

TMutexImp::TMutexImp() { pthread_mutex_init(&id, 0); }

//---------------------------------------------------------------------------

TMutexImp::~TMutexImp() { pthread_mutex_destroy(&id); }

//---------------------------------------------------------------------------

void TMutexImp::lock() { pthread_mutex_lock(&id); }

//---------------------------------------------------------------------------

void TMutexImp::unlock() { pthread_mutex_unlock(&id); }

//---------------------------------------------------------------------------

TMutex::TMutex() : m_imp(new TMutexImp) {}

//---------------------------------------------------------------------------

TMutex::~TMutex() { delete m_imp; }

//---------------------------------------------------------------------------

void TMutex::lock() { m_imp->lock(); }

//---------------------------------------------------------------------------

void TMutex::unlock() { m_imp->unlock(); }

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//    TThread & TThreadImp
//---------------------------------------------------------------------------

class TThreadImp {
  pthread_t threadId;

public:
  TThreadImp();
  ~TThreadImp();

  TThread *thread;

  void start();

  bool setThreadPriority(TThread::TThreadPriority p);
  bool setPreferredProcessor(int processorId);

  TMutex secureLock;
  bool isRunning;

  static void incNThreads() {
    mutex.lock();
    nThreads++;
    mutex.unlock();
  }
  static void decNThreads() {
    mutex.lock();
    nThreads--;
    mutex.unlock();
  }

  // some static stuff
  static TUINT32 nThreads;
  static TMutex mutex;

  friend class TThreadGroupImp;
  void setOwner(TThreadGroupImp *_owner) { owner = _owner; }
  TThreadGroupImp *owner;
};

TUINT32 TThreadImp::nThreads = 0;
TMutex TThreadImp::mutex     = TMutex();
//---------------------------------------------------------------------------

TThreadImp::TThreadImp() : isRunning(false), owner(0), thread(0) {}

//---------------------------------------------------------------------------

TThreadImp::~TThreadImp() {
  // CloseHandle(threadId);
}
//---------------------------------------------------------------------------

static void * /*__stdcall*/ fun(void *data) {
  TThreadImp *t = (TThreadImp *)data;

  t->secureLock.lock();
  if (t->isRunning) {
    t->secureLock.unlock();
    assert(!"thread is already running");
    return 0;
  }
  t->isRunning = true;

  t->secureLock.unlock();

  t->thread->run();

  t->decNThreads();
  if (t->owner) t->owner->remove(t->thread);

  return 0;
}

//---------------------------------------------------------------------------

void TThreadImp::start() {
  incNThreads();
  pthread_create(&threadId, 0, fun, (void *)this);
}

//---------------------------------------------------------------------------

bool TThreadImp::setThreadPriority(TThread::TThreadPriority) {
  assert(!"not implemented");
  return false;
}

//---------------------------------------------------------------------------

bool TThreadImp::setPreferredProcessor(int processorId) {
#ifdef __sgi
#if (OP_RELEASE == rel_2)
  assert(!"Not implemented");
  return false;
#else
  int rc = pthread_setrunon_np(processorId);
  return (rc != -1);
#endif
#else
  assert(0);
  return false;
#endif
}

//---------------------------------------------------------------------------

TThread::TThread() : m_imp(new TThreadImp()) { m_imp->thread = this; }

//---------------------------------------------------------------------------

TThread::~TThread() { delete m_imp; }

//---------------------------------------------------------------------------

void TThread::start() { m_imp->start(); }

//---------------------------------------------------------------------------

bool TThread::setPreferredProcessor(int processorId) {
  return m_imp->setPreferredProcessor(processorId);
}

//---------------------------------------------------------------------------

bool TThread::setThreadPriority(TThread::TThreadPriority p) {
  return m_imp->setThreadPriority(p);
}

//=======================
//    TThreadGroupImp

TThreadGroupImp::TThreadGroupImp() {}

//---------------------------------------------------------------------------

TThreadGroupImp::~TThreadGroupImp() {}

//---------------------------------------------------------------------------

void TThreadGroupImp::add(TThread *t) {
  lockForTheList.lock();
  threads.push_back(t);
  lockForTheList.unlock();
  t->m_imp->setOwner(this);
}
//---------------------------------------------------------------------------

void TThreadGroupImp::remove(TThread *t) {
  lockForTheList.lock();
  threads.remove(t);
  lockForTheList.unlock();
  t->m_imp->setOwner(0);
}
//---------------------------------------------------------------------------

static void * /*__stdcall*/ mainFun(void *data) {
  // cout << "mainfun" << endl;
  list<TThread *> *threads = (list<TThread *> *)data;
  // lockForTheList.lock();
  ULONG s = threads->size();
  // lockForTheList.unlock();
  // cout <<"ci sono " << s << "thread in ballo..." << endl;

  while (s != 0) {
    lockForTheList.lock();
    s = threads->size();
    lockForTheList.unlock();
  }
  return 0;
}

//---------------------------------------------------------------------------
void TThreadGroupImp::wait() {
  // cout << "wait()" << endl;
  lockForTheList.lock();
  ULONG count = threads.size();

  for (list<TThread *>::iterator it = threads.begin(); it != threads.end();
       it++) {
    TThread *t = *it;
    t->start();
  }
  lockForTheList.unlock();

  if (count == 0) return;
  void *mainRet = 0;
  pthread_t mainThread;
  // cout << "creo il main" << endl;
  pthread_create(&mainThread, 0, mainFun, &threads);
  // cout << mainThread << endl;
  pthread_join(mainThread, &mainRet);
}

//---------------------------------------------------------------------------

TThreadGroup::TThreadGroup()
    : m_imp(new TThreadGroupImp())

{}

//---------------------------------------------------------------------------

TThreadGroup::~TThreadGroup() { delete m_imp; }

//---------------------------------------------------------------------------

void TThreadGroup::add(TThread *t) { m_imp->add(t); }

//---------------------------------------------------------------------------

void TThreadGroup::wait() { m_imp->wait(); }