Enter your search terms GNU-Darwin Web Submit search form

thread.h Go to the documentation of this file. // Copyright (C) 1999-2000 Open Source Telecom Corporation. // // 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. // // As a special exception to the GNU General Public License, permission is // granted for additional uses of the text contained in its release // of Common C++. // // The exception is that, if you link the Common C++ library with other // files to produce an executable, this does not by itself cause the // resulting executable to be covered by the GNU General Public License. // Your use of that executable is in no way restricted on account of // linking the Common C++ library code into it. // // This exception does not however invalidate any other reasons why // the executable file might be covered by the GNU General Public License. // // This exception applies only to the code released under the // name Common C++. If you copy code from other releases into a copy of // Common C++, as the General Public License permits, the exception does // not apply to the code that you add in this way. To avoid misleading // anyone as to the status of such modified files, you must delete // this exception notice from them. // // If you write modifications of your own for Common C++, it is your choice // whether to permit this exception to apply to your modifications. // If you do not wish that, delete this exception notice. // #ifndef __CCXX_THREAD_H__ #define __CCXX_THREAD_H__ #define __CCXX_POSIX #ifndef _REENTRANT #define _REENTRANT #endif #ifndef _THREAD_SAFE #define _THREAD_SAFE #endif #ifndef __CCXX_CONFIG_H__ #ifdef PACKAGE #undef PACKAGE #endif #ifdef VERSION #undef VERSION #endif #include <cc++/config.h> #endif #ifndef HAVE_PTHREAD_H #include <pthread.h> #include <semaphore.h> #endif #ifndef __CCXX_MACROS_H__ #include <cc++/macros.h> #else #ifdef __CCXX_NAMESPACE_H__ #include <cc++/macros.h> #endif #endif #include <time.h> #include <signal.h> #include <setjmp.h> #include <unistd.h> #ifdef __linux__ #define _SIG_THREAD_STOPCONT #define _SIG_THREAD_ALARM #endif #ifdef _THR_UNIXWARE #define _EFTSAFE #undef PTHREAD_MUTEXTYPE_RECURSIVE #undef _POSIX_THREAD_PRIORITY_SCHEDULING #define sigwait(x, y) _thr_sigwait(x, y) #endif typedef pthread_t cctid_t; typedef unsigned long timeout_t; typedef int signo_t; typedef enum { THROW_NOTHING, THROW_OBJECT, THROW_EXCEPTION } throw_t; #define TIMEOUT_INF ~((timeout_t) 0) // use a define so that if the sys/types.h header already defines caddr_t // as it may on BSD systems, we do not break it by redefining again. #undef caddr_t #define caddr_t char * #define ENTER_CRITICAL EnterMutex(); #define LEAVE_CRITICAL LeaveMutex(); #define ENTER_DEFERRED setCancel(THREAD_CANCEL_DEFERRED); #define LEAVE_DEFERRED setCancel(THREAD_CANCEL_IMMEDIATE); // These macros override common functions with thread-safe versions. In // particular the common "libc" sleep() has problems since it normally // uses SIGARLM (as actually defined by "posix"). The pthread_delay and // usleep found in libpthread are gaurenteed not to use SIGALRM and offer // higher resolution. psleep() is defined to call the old process sleep. #undef sleep #define sleep(x) ccxx_sleep((x) * 1000) #define yield() ccxx_yield() #define psleep(x) (sleep)(x) typedef enum { THREAD_CANCEL_INITIAL=0, THREAD_CANCEL_DEFERRED=1, THREAD_CANCEL_IMMEDIATE, THREAD_CANCEL_DISABLED, THREAD_CANCEL_DEFAULT=THREAD_CANCEL_DEFERRED, THREAD_CANCEL_INVALID } thread_cancel_t; typedef enum { THREAD_SUSPEND_ENABLE, THREAD_SUSPEND_DISABLE } thread_suspend_t; #define THREAD_SIGNAL_BLOCKED false #define THREAD_SIGNAL_UNBLOCK true #ifdef _SIG_THREAD_STOPCONT #define _SIG_THREAD_SUSPEND SIGSTOP #define _SIG_THREAD_RESUME SIGCONT #else #ifndef SIGUSR3 #ifdef SIGWINCH #define SIGUSR3 SIGWINCH #else #define SIGUSR3 SIGINT #endif #endif #define _SIG_THREAD_SUSPEND SIGUSR3 #define _SIG_THREAD_RESUME SIGUSR3 #endif class Thread; Thread *getThread(void); extern "C" { void execHandler(Thread *th); void sigHandler(int signo); }; class ThreadLock { private: #ifdef HAVE_PTHREAD_RWLOCK pthread_rwlock_t _lock; #else pthread_mutex_t _lock; #endif public: ThreadLock(); ~ThreadLock(); void ReadLock(void); void WriteLock(void); bool TryReadLock(void); bool TryWriteLock(void); void Unlock(void); }; class Mutex { private: #ifndef PTHREAD_MUTEXTYPE_RECURSIVE volatile int _level; volatile Thread *_tid; #endif protected: pthread_mutex_t _mutex; public: Mutex(); ~Mutex() {pthread_mutex_destroy(&_mutex);}; #ifdef PTHREAD_MUTEXTYPE_RECURSIVE inline void EnterMutex(void) {pthread_mutex_lock(&_mutex);}; #else void EnterMutex(void); #endif bool TryEnterMutex(void); #ifdef PTHREAD_MUTEXTYPE_RECURSIVE inline void LeaveMutex(void) {pthread_mutex_unlock(&_mutex);}; #else void LeaveMutex(void); #endif }; class MutexCounter : public Mutex { private: int counter; public: MutexCounter(int initial = 0); friend int operator ++(MutexCounter &mc); friend int operator --(MutexCounter &mc); }; class AtomicCounter { private: #ifdef HAVE_ATOMIC atomic_t atomic; #else int counter; Mutex lock; #endif public: AtomicCounter(); AtomicCounter(int value); int operator++(void); int operator--(void); int operator+=(int change); int operator-=(int change); int operator+(int change); int operator-(int change); int operator=(int value); bool operator!(void); operator int(); }; class Semaphore { protected: sem_t _semaphore; public: Semaphore(size_t resource = 0); ~Semaphore() #ifndef __linux__ {sem_destroy(&_semaphore);} #endif ; void Wait(void) #ifndef __linux__ {sem_wait(&_semaphore);} #endif ; bool TryWait(void) #ifndef __linux__ { return ( sem_trywait(&_semaphore) == 0 ) ? true : false; } #endif ; void Post(void) #ifndef __linux__ {sem_post(&_semaphore);} #endif ; int getValue(void); }; class Event : public Mutex { protected: pthread_cond_t _cond; bool _signaled; int _count; public: Event(); ~Event() {pthread_cond_destroy(&_cond);}; void Reset(void) {_signaled = false;}; void Signal(void); bool Wait(timeout_t timer = 0); }; class Buffer { private: Mutex lock_head, lock_tail; Semaphore size_head, size_tail; size_t _size; size_t _used; protected: virtual int OnPeek(void *buf) = 0; virtual int OnWait(void *buf) = 0; virtual int OnPost(void *buf) = 0; public: Buffer(size_t capacity); virtual ~Buffer() {return;}; inline size_t getSize(void) {return _size;}; inline size_t getUsed(void) {return _used;}; int Wait(void *buf); int Post(void *buf); int Peek(void *buf); virtual bool isValid(void) {return true;}; }; class FixedBuffer : public Buffer { private: char *buf, *head, *tail; size_t objsize; protected: int OnPeek(void *buf); int OnWait(void *buf); int OnPost(void *buf); public: FixedBuffer(size_t capacity, size_t objsize); FixedBuffer(const FixedBuffer &fb); ~FixedBuffer(); FixedBuffer &operator=(const FixedBuffer &fb); bool isValid(void); }; class Thread { private: friend class Slog; static Thread *_main; #ifndef _SIG_THREAD_ALARM static Thread *_timer; static Mutex _arm; #endif Thread *_parent; pthread_t _tid; pthread_attr_t _attr; thread_cancel_t _cancel; jmp_buf _env; time_t _alarm; Semaphore *_start; int _msgpos; char _msgbuf[128]; throw_t _throw; friend void execHandler(Thread *th); friend void sigHandler(int signo); friend Thread *getThread(void); protected: virtual void Run(void) = 0; virtual void First(void) {return;}; virtual void Final(void) {return;}; virtual void Initial(void) {return;}; virtual void *getExtended(void) {return NULL;}; virtual void Notify(Thread *th) {return;}; inline void SignalParent(signo_t signo) {_parent->SignalThread(signo);}; inline void SignalMain(signo_t signo) {_main->SignalThread(signo);}; virtual void OnTimer(void) {return;}; virtual void OnHangup(void) {return;}; virtual void OnException(void) {return;}; virtual void OnDisconnect(void) {return;}; virtual void OnPolling(void) {return;}; virtual void OnSignal(int signo) {return;}; inline void Sleep(timeout_t msec) {ccxx_sleep(msec);}; inline void Exit(void) {longjmp(_env, 1);}; void setTimer(timeout_t timer); timeout_t getTimer(void); void endTimer(void); void WaitSignal(signo_t signo); void Yield(void); void testCancel(void); void setCancel(thread_cancel_t mode); void setSuspend(thread_suspend_t mode); void setSignal(int signo, bool mode); void Terminate(void); inline void clrParent(void) {_parent = NULL;}; public: Thread(bool flag); Thread(Semaphore *start = NULL, int pri = 0, size_t stack = 0); Thread(const Thread &th); virtual ~Thread() {Terminate();}; int Start(Semaphore *start = NULL); inline Thread *getParent(void) {return _parent;}; inline void SignalThread(int signo) {pthread_kill(_tid, signo);}; #ifdef _THR_SUNOS5 inline void Suspend(void) {thr_suspend((thread_t)_tid);}; #else inline void Suspend(void) {pthread_kill(_tid, _SIG_THREAD_SUSPEND);}; #endif #ifdef _THR_SUNOS5 inline void Resume(void) {thr_continue((thread_t)_tid);}; #else inline void Resume(void) {pthread_kill(_tid, _SIG_THREAD_RESUME);}; #endif inline int getCancel(void) {return _cancel;}; bool isRunning(void); bool isThread(void); friend throw_t getException(void); friend void setException(throw_t mode); friend void ccxx_sleep(timeout_t msec); friend void suspend(Thread &th) {pthread_kill(th._tid, _SIG_THREAD_SUSPEND);}; friend void resume(Thread &th) {pthread_kill(th._tid, _SIG_THREAD_RESUME);}; friend inline void operator++(Thread &th) {th._start->Post();}; friend inline void operator--(Thread &th) {th._start->Wait();}; friend inline int start(Thread &th, Semaphore *start) {return th.Start(start);}; friend void siginstall(int signo); }; class ThreadKey { private: pthread_key_t key; public: ThreadKey(); ~ThreadKey(); void *getKey(void); void setKey(void *); }; class TimerPort { struct timeval timer; bool active; protected: TimerPort(); public: void setTimer(timeout_t timeout = 0); void incTimer(timeout_t timeout); void endTimer(void); timeout_t getTimer(void); }; inline void *getKey(ThreadKey &tk) {return tk.getKey();}; inline void setKey(ThreadKey &tk, void *ptr) {tk.setKey(ptr);}; inline void operator ++(Mutex &m) {m.EnterMutex();}; inline void operator --(Mutex &m) {m.LeaveMutex();}; inline void operator ++(Semaphore &s) {s.Post();}; inline void operator --(Semaphore &s) {s.Wait();}; inline void operator ++(Event &s) {s.Signal();}; inline void operator --(Event &s) {s.Wait();}; /* * on some systems, signal(signum, handler) is a macro */ #undef signal inline void signal(Thread &th, int signo) {th.SignalThread(signo);}; inline void signal(Event &ev) {ev.Signal();}; inline void signal(Semaphore &sem) {sem.Post();}; inline void wait(Semaphore &sem) {sem.Wait();}; inline void wait(Event &ev, timeout_t timer) {ev.Wait(timer);}; inline void reset(Event &ev) {ev.Reset();}; inline int get(Buffer &b, void *o) {return b.Wait(o);}; inline int put(Buffer &b, void *o) {return b.Post(o);}; inline int peek(Buffer &b, void *o) {return b.Peek(o);}; int operator++(MutexCounter &mc); int operator--(MutexCounter &mc); struct timespec *gettimeout(struct timespec *spec, timeout_t timeout); void ccxx_sleep(timeout_t msec); void ccxx_yield(void); void wait(signo_t signo); void pdetach(void); #ifdef __CCXX_NAMESPACE_H__ #undef __CCXX_NAMESPACE_H__ #include <cc++/namespace.h> #endif #if defined(HAVE_POLL_H) || defined(HAVE_SYS_POLL_H) #if defined(HAVE_SYS_STREAM_H) #if defined(__linux__) #define __CCXX_USE_POLL 1 #endif #else #define __CCXX_USE_POLL 1 #endif #endif #ifdef __CCXX_USE_POLL class Poller { private: int nufds; pollfd *ufds; public: Poller(); ~Poller(); pollfd *getList(int cnt); inline pollfd *getList(void) {return ufds;}; }; #endif #endif