Thread.hpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2003 Pascal Havé
//
//  This program 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, or (at your option)
//  any later version.
//
//  This program 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 this program; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
//  $Id: Thread.hpp,v 1.6 2007/05/20 23:02:46 delpinux Exp $

#ifndef THREAD_HPP
#define THREAD_HPP

#include <cstddef>
#include <config.h>
#include <Assert.hpp>


class Runnable {
public:
  virtual ~Runnable() { }
  
  virtual void run() = 0;

  virtual void clean() { }
};


#ifdef HAVE_PTHREAD
#include <pthread.h>
#include <semaphore.h>

extern "C" {  
  inline void clean_function(void * t) {
    reinterpret_cast<Runnable *>(t)->clean();
  }

  inline void * thread_function(void * t) {
    Runnable *f = reinterpret_cast<Runnable *>(t);
    ASSERT(f != NULL);
    pthread_cleanup_push(clean_function,f);
    f->run(); // Appel par virtual
    pthread_cleanup_pop(0);
    pthread_exit(NULL);
    return NULL;
  }
}

class Thread
  : public Runnable
{
protected:
  pthread_t thread;             
public:
  bool start()
  {
    if (thread) return false;
#ifndef NDEBUG
    const int ret = 
#endif /* NDEBUG */
      pthread_create(&thread,NULL,
                     thread_function,
                     this);
    ASSERT(ret == 0);
    return true;
  }

  void cancel() const
  {
    pthread_cancel(thread);
  }

  static inline void cancellable(const bool& b)
  {
    pthread_setcancelstate((b)?PTHREAD_CANCEL_ENABLE:PTHREAD_CANCEL_DISABLE
                           ,NULL);
  }

  static inline void cancellable()
  {
    pthread_testcancel();
  }

  inline bool join()
  {
    if (thread) {
      void * ret;
      pthread_join(thread,&ret);
      return false;
    }
    return true;
  }

  inline const pthread_t& getId() const
  {
    return thread;
  }

  Thread()
    : thread(0)
  {
    ;
  }

  virtual ~Thread()
  {
    this->join();
  }
};

class Mutex
{
protected:
  pthread_mutex_t mutex;        
public:
  inline void lock()
  {
    pthread_mutex_lock(&mutex); 
  }

  inline void unlock()
  {
    pthread_mutex_unlock(&mutex);
  }

  inline int trylock()
  {
    return pthread_mutex_trylock(&mutex);
  }

  Mutex()
  { 
    pthread_mutex_init(&mutex,NULL);
  }

  ~Mutex()
  {
    pthread_mutex_destroy(&mutex);
  }
};

class Semaphore
{
protected:
  sem_t semaphore;              
public:

  inline void wait()
  {
    sem_wait(&semaphore);
  }

  inline void post()
  {
    sem_post(&semaphore);
  }

  inline int trywait()
  {
    return sem_trywait(&semaphore);
  }

  Semaphore()
  { 
    sem_init(&semaphore,
             0, // Interprocessus?
             1  // Number of threads which can access simultaneously to the protected zone
             );
  }

  ~Semaphore()
  {
    sem_destroy(&semaphore);
  }
};

#else  // HAVE_PTHREAD


class Thread
  : public Runnable
{
public:
  typedef size_t Id;            
public:
  bool start()
  {
    this->run();
    return true;
  }

  void cancel() const
  {
    ;
  }

  static inline void cancellable(const bool& b)
  {
    ;
  }

  static inline void cancellable()
  {
    ;
  }

  inline bool join()
  {
    return true;
  }

  inline Id getId() const
  {
    return 0;
  }

  Thread()
  {
    ;
  }

  virtual ~Thread()
  {
    ;
  }
};

class Mutex
{
public:
  inline void lock()
  {
    ;
  }

  inline void unlock()
  {
    ;
  }

  inline int trylock()
  {
    return 0;
  }

  Mutex()
  { 
    ;
  }

  ~Mutex()
  {
    ;
  }
};

class Semaphore
{
public:
  inline void wait()
  {
    ;
  }

  inline void post()
  {
    ;
  }

  inline int trywait()
  {
    return 0;
  }

  Semaphore()
  { 
    ;
  }

  ~Semaphore()
  {
    ;
  }
};


#endif // HAVE_PTHREAD

#endif /* THREAD_HPP */

---