tjthread.h

/***************************************************************************
                          tjthread.h  -  description
                             -------------------
    begin                : Mon Dec 12 2005
    copyright            : (C) 2000-2021 by Thies H. Jochimsen
    email                : thies@jochimsen.de
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef TJTHREAD_H
#define TJTHREAD_H
 
 
#include <tjutils/tjutils.h>
 
 
// for debugging
class ThreadComponent {
 public:
  static const char* get_compName();
};
 
 
 
 
class Mutex {
 
 public:
 
  Mutex();
 
  ~Mutex();
 
  void lock();
 
  void unlock();
 
 
 private:
  friend class Event;
 
  // disable copying
  Mutex(const Mutex&) {}
  Mutex& operator = (const Mutex&) {return *this;}
 
  void* id;
 
};
 
 
class MutexLock {
 
 public:
 
  MutexLock(Mutex& mutex) : m(mutex) {m.lock();}
 
  ~MutexLock() {m.unlock();}
 
 private:
 
  // disable copying
  MutexLock(const MutexLock& ml) : m(ml.m) {} // bogus
  MutexLock& operator = (const MutexLock&) {return *this;}
 
  Mutex& m;
};
 
 
 
 
class Event {
 
 public:
 
  Event();
 
  ~Event();
 
  void wait();
 
  void signal();
 
  void reset();
 
 
 private:
 
  // disable copying
  Event(const Event&) {}
  Event& operator = (const Event&) {return *this;}
 
  void* id;
 
  // Extra stuff for pthread
  Mutex mutex;
  bool active;
 
};
 
 
 
 
class ThreadIndex; // forward declaration
 
class Thread {
 
 public:
 
  Thread();
 
  virtual ~Thread();
 
  bool start(unsigned int stack_size=0);
 
  bool wait();
 
 
  virtual void run() = 0;
 
 
  static int self();
 
 
 private:
 
  // disable copying
  Thread(const Thread&) {}
  Thread& operator = (const Thread&) {return *this;}
 
 
  void clear_id();
 
  void* id;
 
  ThreadIndex* index;  // give each thread a unique index
 
};
 
 
 
 
template<typename In, typename Out, typename Local>
class ThreadedLoop {
 
 public:
 
  ThreadedLoop() : mainbegin(0), mainend(0) {}
 
  virtual ~ThreadedLoop() {destroy();}
 
  bool init(unsigned int numof_threads, unsigned int loopsize);
 
  void destroy();
 
  bool execute(const In& in, STD_vector<Out>& outvec);
 
 private:
 
  virtual bool kernel(const In& in, Out& out, Local& local, unsigned int begin, unsigned int end) = 0;
 
 
  class WorkThread : public Thread {
 
    friend class ThreadedLoop<In,Out,Local>;
 
    WorkThread(ThreadedLoop<In,Out,Local>* tl) : tloop(tl) {}
 
    void run();
 
    ThreadedLoop<In,Out,Local>* tloop;
    unsigned int begin;
    unsigned int end;
 
    Event process;
    Event finished;
    volatile bool status;
 
    Out* out_cache;
    
    Local local;
 
  };
 
 
  unsigned int mainbegin;
  unsigned int mainend;
  Local mainlocal;
  friend class WorkThread;
  STD_vector<WorkThread*> threads;
  const In* in_cache;
  volatile bool cont;
 
};
 
 
 
 
#endif