diff options
Diffstat (limited to 'libs/pbd3/pbd/thread.h')
-rw-r--r-- | libs/pbd3/pbd/thread.h | 127 |
1 files changed, 127 insertions, 0 deletions
diff --git a/libs/pbd3/pbd/thread.h b/libs/pbd3/pbd/thread.h new file mode 100644 index 0000000000..c1d5c3c78d --- /dev/null +++ b/libs/pbd3/pbd/thread.h @@ -0,0 +1,127 @@ +/* + Copyright (C) 1998-99 Paul Barton-Davis + + 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. + + 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., 675 Mass Ave, Cambridge, MA 02139, USA. + + $Id$ +*/ + +#ifndef __qm_thread_h__ +#define __qm_thread_h__ + +#include <pthread.h> + +/* A generic base class for Quasimodo objects requiring their own + thread to do work. +*/ + +class QMThread + +{ + public: + QMThread (const char *name, + void *(start)(void *), void *, + bool realtime = false, int rt_priority = 10); + + virtual ~QMThread(); + + int run (); + void poke (); + void pause (); + void stop (); + void *wait (); + + /* This doesn't guarantee anything about the state of + the thread, but if you do things the right way, and + make sure that the do_work() routine checks + work_no_more() at the right times, and that the + thread is awake, then calling this will cause + the thread to exit fairly quickly. + */ + + void halt() { _must_exit = true ; } + + void exit (void *status); + pthread_t thread_id() { return _thread; } + + bool thread_ok () { return _have_thread; } + bool thread_active() { return _thread_active; } + + bool thread_running () { + /* XXX not atomic */ + return _running && _thread_active; + } + + bool thread_waiting () { return _thread_waiting; } + + static void try_to_kill_all_threads() { + all_threads_must_die = true; + } + + protected: + void *main (); + + bool work_no_more () { return (!_running || _must_exit || all_threads_must_die); } + + bool myself () { + return pthread_equal (_thread, pthread_self()); + } + + void suspend() { + _running = false; + } + + void lock (pthread_mutex_t *lock) { + pthread_mutex_lock (lock); + } + + void unlock (pthread_mutex_t *lock) { + pthread_mutex_unlock (lock); + } + + virtual void *do_work () = 0; + + private: + const char *_name; + bool _must_exit; + bool _running; + bool _thread_active; + bool _thread_waiting; + bool _have_thread; + + size_t work_cnt; + + pthread_mutex_t status_lock; + pthread_cond_t wake_up; /* protected by status_lock */ + pthread_cond_t asleep; /* protected by status_lock */ + pthread_cond_t running; /* protected by status_lock */ + pthread_cond_t exited; /* protected by status_lock */ + pthread_t _thread; + + void lock () { + pthread_mutex_lock (&status_lock); + } + + void unlock () { + pthread_mutex_unlock (&status_lock); + } + + static bool all_threads_must_die; + + static void signal_catcher (int sig); + void setup_signals (); +}; + +#endif // __qm_thread_h__ |