279 lines
6.9 KiB
C++
279 lines
6.9 KiB
C++
|
|
|
|
#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(); }
|