Thread.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream 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; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream 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 have received a copy of the GNU General Public License
   along with GTK+ IOStream
 */
#ifndef THREAD_H_
#define THREAD_H_

#ifdef USE_USE_GLIB_THREADS
#include <glib.h>
#else
#include <pthread.h>
#include <errno.h>
#include <stdio.h>
#endif

#include <string.h>
#include "Debug.H"

#define THREAD_CREATE_ERROR -0+THREAD_ERROR_OFFSET 
#define THREAD_MUTEX_UNINIT_ERROR -1+THREAD_ERROR_OFFSET 
#define THREAD_MUTEX_DEADLK_ERROR -2+THREAD_ERROR_OFFSET 
#define THREAD_MUTEX_DONTOWN_ERROR -3+THREAD_ERROR_OFFSET 
#define THREAD_MUTEX_DESTROY_LOCKED_ERROR -4+THREAD_ERROR_OFFSET 
#define THREAD_MUTEX_LOCKBUSY_WARNING -5+THREAD_ERROR_OFFSET 
#define THREAD_NOTFOUND_ERROR -6+THREAD_ERROR_OFFSET 
#define THREAD_COND_WAITBUSY_ERROR -7+THREAD_ERROR_OFFSET 
#define THREAD_SCHED_ERROR -8+THREAD_ERROR_OFFSET 

class ThreadDebug : public Debug {
public:
    ThreadDebug(void) {
#ifndef NDEBUG
        errors[THREAD_CREATE_ERROR]=std::string("The thread couldn't be started.");
        errors[THREAD_MUTEX_UNINIT_ERROR]=std::string("The mutex has not been properly initialized.");
        errors[THREAD_MUTEX_DEADLK_ERROR]=std::string("The mutex has already been locked. Deadlock error.");
        errors[THREAD_MUTEX_DONTOWN_ERROR]=std::string("The mutex is not owned by the thread attempting to unlock, error.");
        errors[THREAD_MUTEX_DESTROY_LOCKED_ERROR]=std::string("You are trying to destroy the mutex which is locked, error.");
        errors[THREAD_MUTEX_LOCKBUSY_WARNING]=std::string("You are trying to lock a mutex which is already locked, you didn't acquire lock this time, try again.");
        errors[THREAD_NOTFOUND_ERROR]=std::string("That thread couldn't be found.");
        errors[THREAD_COND_WAITBUSY_ERROR]=std::string("One or more threads is waiting on the Cond variable. Can't destroy. ");
        errors[THREAD_SCHED_ERROR]=std::string("Problem setting the scheduling. ");

#endif
    }
};

class Thread {

#ifdef USE_GLIB_THREADS
    GThread* thread; 
    GError *threadErrorPtr; 
#else
    pthread_t thread; 
#endif

public:
    Thread(void) {
#ifdef USE_GLIB_THREADS
        thread=NULL;
        threadErrorPtr=NULL;
#else
        thread=0;
#endif
    }

    virtual ~Thread(void) {
#ifdef USE_GLIB_THREADS
        g_thread_join(thread);
        thread=NULL;
#else
//         void *retVal;
        pthread_cancel(thread); // this returns error of ESRCH if the thread is already finished

//        int threadResp=pthread_join(thread, &retVal);
        // on destruction, not interested in the return value here, just want to make sure the thread has exited.
//        if (threadResp!=0) {
//            errno=threadResp;
//            perror("Thread::meetThread : Couldn't meet the thread");
//            cerr<<"Most likely that the thread isn't running."<<endl;
//        }
#endif
    }

    void *stop(void){
        int retVal = pthread_cancel(thread);
        if (retVal==ESRCH)
            ThreadDebug().evaluateError(THREAD_NOTFOUND_ERROR, " When trying to stop.");
            return NULL;

        return meetThread();
    }

#ifdef USE_GLIB_THREADS
    int run(void (*start_routine) (void *), void *data, int priority=0) {
      priority=0;
#else
    int run(void *(*start_routine) (void *), void *data, int priority=0) {
#endif
#ifdef USE_GLIB_THREADS
        thread = g_thread_create((GThreadFunc)start_routine, (gpointer) data, TRUE, &threadErrorPtr);
        if (thread==NULL)
          return ThreadDebug().evaluateError(THREAD_CREATE_ERROR);
#else
        pthread_attr_t attr; // by default assumed PTHREAD_EXPLICIT_SCHED
        pthread_attr_init(&attr);
        int threadResp=0;

        printf("entering set priority\n");
        if (priority>0)
          if (threadResp=setPriority(&attr, priority))
            return threadResp;
        printf("exited set priority\n");

        if (threadResp=pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE))
          return ThreadDebug().evaluateError(threadResp, "Thread::run : Thread setting detatch state failed.");
//    int pthread_setcanceltype(int type, int *oldtype);

          printf("create\n");
        if (threadResp=pthread_create(&thread, &attr, start_routine, data))
          return ThreadDebug().evaluateError(threadResp, "Thread::run : Thread creation failed.");

        pthread_attr_destroy(&attr);

        if (threadResp!=0)
            return ThreadDebug().evaluateError(THREAD_CREATE_ERROR);
#endif
        return 0;
    }

#ifndef USE_GLIB_THREADS
  int setPriority(pthread_attr_t *attributes, int priority){
    int res=0;
    if ((res = pthread_attr_setinheritsched(attributes, PTHREAD_EXPLICIT_SCHED)))
        return ThreadDebug().evaluateError(res, "Cannot request explicit scheduling for thread");

    if ((res = pthread_attr_setscope(attributes, PTHREAD_SCOPE_SYSTEM)))
      return ThreadDebug().evaluateError(res, "Cannot set scheduling scope for thread");

    if ((res = pthread_attr_setschedpolicy(attributes, SCHED_FIFO)))
      return ThreadDebug().evaluateError(res, "Cannot request schedule policy for thread");

    struct sched_param rt_param;
    memset(&rt_param, 0, sizeof(rt_param));
    rt_param.sched_priority = priority;
    if ((res = pthread_attr_setschedparam(attributes, &rt_param)))
      return ThreadDebug().evaluateError(res, "Cannot set scheduling priority for thread");

    return res;
  }

  int getPriority(){
    int res;
    struct sched_param rt_param;
    memset(&rt_param, 0, sizeof(rt_param));
    int policy;
    if ((res=pthread_getschedparam(thread, &policy, &rt_param)) != 0)
      return ThreadDebug().evaluateError(res," Getting sched param.");
    printf("Thread policy is %d priority is %d\n",policy, rt_param.sched_priority);
    if (policy != SCHED_FIFO)
      return ThreadDebug().evaluateError(THREAD_SCHED_ERROR, "Scheduling is NOT SCHED_FIFO!\n");
    return rt_param.sched_priority;
  }
#endif

    void *meetThread(void) {
        if (thread) {
#ifdef USE_GLIB_THREADS
            g_thread_join(thread);
            thread=NULL;
#else
            void *retVal;
            int threadResp=pthread_join(thread, &retVal);
            if (threadResp!=0) {
                errno=threadResp;
                perror("Thread::meetThread : Couldn't meet the thread");
            }
            thread=0;
            return retVal;
#endif
        }
        return NULL;
    }

    void exit(void *retVal) {
#ifndef USE_GLIB_THREADS
        pthread_exit(retVal);
#endif
    }

    bool running() {
#ifndef USE_GLIB_THREADS
        return thread!=(int)NULL;
#else
        return thread!=0;
#endif
    }
};

class ThreadedMethod : public Thread {
#ifdef USE_GLIB_THREADS

    static void threadMainStatic(void *data) {
        static_cast<ThreadedMethod*>(data)->threadMain();
    }
#else

    static void *threadMainStatic(void *data) {
        return static_cast<ThreadedMethod*>(data)->threadMain();
    }
#endif
public:
    virtual void *threadMain(void)=0;

    virtual int run(int priority=0) {
        return Thread::run(threadMainStatic, static_cast<void*>(this), priority);
    }
};

#ifndef USE_USE_GLIB_THREADS

class Mutex {
protected:
    pthread_mutex_t mut; 
public:
    Mutex() {
        pthread_mutex_init(&mut, NULL); //defaults to a fast mutex PTHREAD_MUTEX_INITIALIZER
    }

    virtual ~Mutex() {
        pthread_mutex_destroy(&mut);
//        int retVal=pthread_mutex_destroy(&mut);
//        if (retVal!=0) // returned with error
//            if (retVal==EBUSY)
//                ThreadDebug().evaluateError(THREAD_MUTEX_DESTROY_LOCKED_ERROR);
    }

    int lock() {
        int retVal=pthread_mutex_lock(&mut);
        if (retVal!=0) { // returned with error
            if (retVal==EINVAL)
                return ThreadDebug().evaluateError(THREAD_MUTEX_UNINIT_ERROR);
            if (retVal==EDEADLK)
                return ThreadDebug().evaluateError(THREAD_MUTEX_DEADLK_ERROR);

        }
        return NO_ERROR;
    }

    int tryLock() {
        int retVal=pthread_mutex_trylock(&mut);
        if (retVal!=0) { // returned with error
            if (retVal==EINVAL)
                return ThreadDebug().evaluateError(THREAD_MUTEX_UNINIT_ERROR);
            if (retVal==EBUSY)
                return ThreadDebug().evaluateError(THREAD_MUTEX_LOCKBUSY_WARNING);

        }
        return NO_ERROR;
    }

    int unLock() {
        int retVal=pthread_mutex_unlock(&mut);
        if (retVal!=0) { // returned with error
            if (retVal==EINVAL)
                return ThreadDebug().evaluateError(THREAD_MUTEX_UNINIT_ERROR);
            if (retVal==EPERM) // this result is returned from error checking mutexes only
                return ThreadDebug().evaluateError(THREAD_MUTEX_DONTOWN_ERROR);

        }
        return NO_ERROR;
    }
};

class Cond : public Mutex {
    pthread_cond_t cond; 
public:
    Cond(){
        // pthread_condattr_t cond_attr; // currently not used
        pthread_cond_init(&cond, NULL);
    }

    virtual ~Cond(){
        // pthread_condattr_t cond_attr; // currently not used
        int retVal = pthread_cond_destroy(&cond);
        if (retVal==EBUSY)
            ThreadDebug().evaluateError(THREAD_COND_WAITBUSY_ERROR);
    }

    void wait(){
       pthread_cond_wait(&cond, &mut);
    }

    void signal(){
        pthread_cond_signal(&cond);
    }

    void boroadcast(){
        pthread_cond_broadcast(&cond);
    }
};

class WaitingThread : public ThreadedMethod {
public:
    Cond cond;

    virtual ~WaitingThread(void){
        cond.lock(); // signal the waiting thread so it isn't waiting and it is possible to shutdown.
        cond.signal();
        // don't unlock so that the waiting thread can't enter again during shutdown ... don't call here cond.unLock();
    }
};
#endif // ifndef USE_USE_GLIB_THREADS

#endif // THREAD_H_