OpenSdkThread.cc

Go to the documentation of this file.

/*
 * This file is part of openSDK.
 *
 * Copyright (C) 2006-2007 openSDK team
 *
 * openSDK is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2.
 *
 * openSDK is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with openSDK; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *     $Id: OpenSdkThread.cc,v 1.7 2007/03/24 11:32:23 nuno-lopes Exp $
 */

#include <iostream>
#include <OpenSdkThread.h>
#include <Platform.h>

using namespace std;

static void* threadFunc(void*arg);

//static var initialization
std::vector<OpenSdkThread*> *OpenSdkThread::threadVector;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

#define LOCK() pthread_mutex_lock(&mutex);
#define UNLOCK() pthread_mutex_unlock(&mutex);


int OpenSdkThread::runFunction(FuncPointer func, void *arg)
{
        std::vector<OpenSdkThread*>::iterator it = threadVector->begin();

        do {
                OpenSdkThread *ost = *it;

                pthread_mutex_lock(&ost->stateMutex);

                if (ost->state == Idle) {
                        ost->state = Running;
                        pthread_mutex_unlock(&ost->stateMutex);

                        ost->func = func;
                        ost->arg = arg;
                        pthread_mutex_unlock(&ost->runMutex);
                        return 0;
                }

                pthread_mutex_unlock(&ost->stateMutex);

                if(++it == threadVector->end()) {
//                      it = threadPool->begin(); // uncomment to enable continuous thread search
                        cerr << "****************** OpenSdkThread::runFunction: no thread available ******************" << endl;
                        return -1;
                }

        } while (true);
}


void OpenSdkThread::initThreadPool()
{
        cout << "Initializing thread pool ..." << endl;

        threadVector = new std::vector<OpenSdkThread*>;

        for(int i = 0; i<THREAD_POOL_SIZE; i++) {
                OpenSdkThread *ost = new OpenSdkThread();
                threadVector->push_back(ost);
        }

        cout << "thread pool created with " << THREAD_POOL_SIZE << " threads." << endl;
}

void OpenSdkThread::cleanThreadPool()
{
        LOCK();
        for (std::vector<OpenSdkThread*>::iterator it = OpenSdkThread::threadVector->begin();
                it != OpenSdkThread::threadVector->end(); ++it) {
                (*it)->state = Dead;
                pthread_mutex_unlock(&((*it)->runMutex));
        }
        UNLOCK();

        int guard = 42;
        while (--guard) {
                opensdk_yield();

                LOCK();
                if (threadVector->empty()) {
                        UNLOCK();
                        delete threadVector;
                        return;
                }
                UNLOCK();
        }
}


OpenSdkThread::OpenSdkThread()
{
        pthread_mutex_init(&(this->runMutex), NULL);
        pthread_mutex_init(&(this->stateMutex), NULL);

        pthread_mutex_lock(&(this->runMutex));

        pthread_t threadId;
        int threadRet = pthread_create(&threadId, NULL, threadFunc, this);

        if (threadRet == 0) {
                // thread created
                this->state = Idle;
                pthread_detach(threadId);
        } else {
                // thread NOT created
                cerr << "ERROR: failed to create thread" << endl;
                exit(0xdead);
        }
}


OpenSdkThread::~OpenSdkThread()
{
        pthread_mutex_destroy(&(this->runMutex));
        pthread_mutex_destroy(&(this->stateMutex));
}


void OpenSdkThread::deleteThread(void)
{
        LOCK();

        for (std::vector<OpenSdkThread*>::iterator it = OpenSdkThread::threadVector->begin();
                it != OpenSdkThread::threadVector->end(); ++it) {
                if (*it == this) {
                        threadVector->erase(it);
                        UNLOCK();
                        return;
                }
        }

        UNLOCK();
        cerr << "[OpenSdkThread::deleteThread] the impossible happened: thread not found in the list" << endl;
}


static void* threadFunc(void *arg)
{
        OpenSdkThread *ost = (OpenSdkThread*)arg;

        while (true) {
                pthread_mutex_lock(&(ost->runMutex)); // unlocks are made elsewhere, to control when this thread runs or not

                if (ost->state == Dead) {
                        ost->deleteThread();

                        // at this point it is safe to unlock this mutex because it isn't listed in the thread pool
                        // we need to unlock the mutex because mutexes should be unlocked before being destroy
                        pthread_mutex_unlock(&(ost->runMutex));
                        delete ost;
                        return NULL;
                }

                ost->func(ost->arg);

                pthread_mutex_lock(&(ost->stateMutex));
                ost->state = Idle;
                pthread_mutex_unlock(&(ost->stateMutex));
        }
}

---