---

thread.h

Go to the documentation of this file.

// Copyright (C) 1999-2001 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__

#ifndef WIN32
#define __CCXX_POSIX

#ifndef _REENTRANT
#define _REENTRANT
#endif

#ifndef _THREAD_SAFE
#define _THREAD_SAFE
#endif
#else // WIN32
#include <setjmp.h>
#endif // !WIN32

#ifndef __CCXX_CONFIG_H__
#include <cc++/config.h>
#endif

#ifndef __CCXX_EXCEPTION_H__
#include <cc++/exception.h>
#endif

#ifndef WIN32
#if defined(__FreeBSD__) && __FreeBSD__ <= 3
#define _SYSV_SEMAPHORES
#endif

#ifndef HAVE_PTHREAD_H
#include <pthread.h>
#ifndef _SYSV_SEMAPHORES
#include <semaphore.h>
#endif
#endif
#endif // !WIN32

#if _MSC_VER > 1000
#pragma once
#endif

#ifndef WIN32
#include <time.h>
#include <signal.h>
#include <setjmp.h>
#include <unistd.h>

#ifdef  __linux__
#define _SIG_THREAD_ALARM
#endif

#ifdef  _THR_UNIXWARE
#undef  PTHREAD_MUTEXTYPE_RECURSIVE
#endif

typedef pthread_t       cctid_t;
typedef unsigned long   timeout_t;
#else // WIN32
typedef DWORD   cctid_t;
typedef DWORD   timeout_t;

#define MAX_SEM_VALUE   1000000
#if defined(__MINGW32__) || defined(__CYGWIN32__)
#include <Windows32/CommonFunctions.h>
#else
__declspec(dllimport) long __stdcall InterlockedIncrement(long *);
__declspec(dllimport) long __stdcall InterlockedDecrement(long *);
__declspec(dllimport) long __stdcall InterlockedExchange(long *, long);
#endif

#endif // !WIN32

#ifdef  __NAMESPACES__
namespace ost {
#endif

enum throw_t {
        THROW_NOTHING, 
        THROW_OBJECT, 
        THROW_EXCEPTION
};
typedef enum throw_t throw_t;
class Thread;

#define TIMEOUT_INF ~((timeout_t) 0)

#define ENTER_CRITICAL  EnterMutex();
#define LEAVE_CRITICAL  LeaveMutex();
#define ENTER_DEFERRED  setCancel(THREAD_CANCEL_DEFERRED);
#define LEAVE_DEFERRED  setCancel(THREAD_CANCEL_IMMEDIATE);

enum thread_cancel_t
{
        THREAD_CANCEL_INITIAL=0,
        THREAD_CANCEL_DEFERRED=1,
        THREAD_CANCEL_IMMEDIATE,
        THREAD_CANCEL_DISABLED,
        THREAD_CANCEL_DEFAULT=THREAD_CANCEL_DEFERRED
};
typedef enum thread_cancel_t thread_cancel_t;

enum thread_suspend_t
{
        THREAD_SUSPEND_ENABLE,
        THREAD_SUSPEND_DISABLE
};
typedef enum thread_suspend_t thread_suspend_t;

#ifndef WIN32
// 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 psleep(x)       (sleep)(x)

static RETSIGTYPE ccxx_sigsuspend(int);
extern "C" void execHandler(Thread *th);

#endif // !WIN32


CCXX_EXPORT(Thread*) getThread(void);
CCXX_EXPORT(throw_t) getException(void);
CCXX_EXPORT(void) setException(throw_t mode);
CCXX_EXPORT(void) ccxx_sleep(timeout_t msec);
CCXX_EXPORT(void) ccxx_yield(void);

#undef Yield
#define sleep(x)        ccxx_sleep((x) * 1000)
#define yield()         ccxx_yield()

#ifdef WIN32
CCXX_EXPORT(DWORD) waitThread(HANDLE hRef, timeout_t timeout);
#endif

class Conditional;
class CCXX_CLASS_EXPORT Event;

class CCXX_CLASS_EXPORT Mutex
{
        friend class Conditional;
        friend class Event;
private:
#ifndef WIN32
#ifndef PTHREAD_MUTEXTYPE_RECURSIVE
        volatile int _level;
        volatile Thread *_tid;
#endif

        pthread_mutex_t _mutex;
#else
        HANDLE mutex;
#endif

public:
        Mutex();

        virtual ~Mutex();

        void EnterMutex(void);

        bool TryEnterMutex(void);

        void LeaveMutex(void);
};

class MutexLock
{
private:
        Mutex& mutex;
public:
        MutexLock( Mutex& _mutex ) : mutex( _mutex ) 
                { mutex.EnterMutex(); }
        // this should be not-virtual
        ~MutexLock()
                { mutex.LeaveMutex(); }
};

class CCXX_CLASS_EXPORT ThreadLock
{
private:
#ifdef HAVE_PTHREAD_RWLOCK
        pthread_rwlock_t _lock;
#else
        Mutex mutex;
#endif

public:
        ThreadLock();

        virtual ~ThreadLock();

        void ReadLock(void);

        void WriteLock(void);

        bool TryReadLock(void);

        bool TryWriteLock(void);

        void Unlock(void);
};

class CCXX_CLASS_EXPORT MutexCounter : public Mutex
{
private:
        int     counter;

public:
        MutexCounter();
        MutexCounter(int initial);

        friend CCXX_EXPORT(int) operator++(MutexCounter &mc);
        friend CCXX_EXPORT(int) operator--(MutexCounter &mc);
};

class CCXX_CLASS_EXPORT AtomicCounter
{
#ifndef WIN32
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();
#else
private:
        long atomic;

public:
        inline AtomicCounter()
                {atomic = 0;};

        inline AtomicCounter(int value)
                {atomic = value;};

        inline int operator++(void)
                {return InterlockedIncrement(&atomic);};

        inline int operator--(void)
                {return InterlockedDecrement(&atomic);};

        int operator+=(int change);

        int operator-=(int change);

        inline int operator+(int change)
                {return atomic + change;};

        inline int operator-(int change)
                {return atomic - change;};
        
        inline int operator=(int value)
                {return InterlockedExchange(&atomic, value);};

        inline bool operator!(void)
                {return (atomic == 0) ? true : false;};

        inline operator int()
                {return atomic;};
#endif
};

// FIXME: implement Conditional class for win32
#ifndef WIN32

class Conditional : public Mutex
{
private:
        pthread_cond_t _cond;

public:
        Conditional();

        virtual ~Conditional();

        void Signal(bool broadcast);

        void Wait(timeout_t timer = 0); 
};
#endif

class CCXX_CLASS_EXPORT Semaphore
{
private:
#ifndef WIN32
#ifdef  _SYSV_SEMAPHORES
        int _semaphore;
#else
        sem_t _semaphore;
#endif
#else // WIN32
        HANDLE  semObject;
#endif // !WIN32

public:
        Semaphore(size_t resource = 0);

        virtual ~Semaphore();

        void Wait(void);

        bool TryWait(void);

        void Post(void);

        // FIXME: how implement getValue for posix compatibility ?
#ifndef WIN32
#ifndef __CYGWIN32__
        int getValue(void);
#endif
#endif
};

class CCXX_CLASS_EXPORT Event
{
private:
#ifndef WIN32
        Mutex mutex;
        pthread_cond_t _cond;
        bool _signaled;
        int _count;
#else
        HANDLE cond;
#endif

public:
        Event();

        virtual ~Event();

        void Reset(void);

        void Signal(void);

        bool Wait(timeout_t timer);
        bool Wait(void);
};

class CCXX_CLASS_EXPORT 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 CCXX_CLASS_EXPORT 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);

        virtual ~FixedBuffer();

        FixedBuffer &operator=(const FixedBuffer &fb);

        bool isValid(void);
};

class Thread
{
#ifndef WIN32
friend class PosixThread;
friend RETSIGTYPE ccxx_sigsuspend(int);
#endif
private:
        friend class Slog;

        static Thread *_main;

        Thread *_parent;
#ifndef WIN32
        pthread_t _tid;
        pthread_attr_t _attr;
        AtomicCounter _suspendcount;
#else
        DWORD _tid;
        HANDLE _cancellation;
#endif
        thread_cancel_t _cancel;
        jmp_buf _env;
        Semaphore *_start;
        int _msgpos;
        char _msgbuf[128];
        throw_t _throw;

#ifndef WIN32
        friend void execHandler(Thread *th);
        friend Thread *getThread(void);
#else
        bool _active:1;
        bool _suspendEnable:1;
        static unsigned __stdcall Execute(Thread *th);
        HANDLE  _hThread;
#endif

protected:
        virtual void Run(void) = 0;

        CCXX_MEMBER_EXPORT(virtual void) Final(void)
                {return;};

        CCXX_MEMBER_EXPORT(virtual void) Initial(void)
                {return;};

        CCXX_MEMBER_EXPORT(virtual void*) getExtended(void)
                {return NULL;};

        CCXX_MEMBER_EXPORT(virtual void) Notify(Thread *th)
                {return;};

        CCXX_MEMBER_EXPORT(void) Sleep(timeout_t msec)
#ifndef WIN32
                {ccxx_sleep(msec);}
#endif
        ;

        inline void Exit(void)
                {longjmp(_env, 1);};

        CCXX_MEMBER_EXPORT(void) Yield(void);

        CCXX_MEMBER_EXPORT(void) testCancel(void);

        CCXX_MEMBER_EXPORT(void) setCancel(thread_cancel_t mode);

        CCXX_MEMBER_EXPORT(void) setSuspend(thread_suspend_t mode);

        CCXX_MEMBER_EXPORT(void) Terminate(void);

        inline void clrParent(void)
                {_parent = NULL;};

#ifdef WIN32
        // FIXME: should be private
        CCXX_MEMBER_EXPORT(DWORD) WaitHandle(HANDLE obj, timeout_t timeout);
#endif

public:
        CCXX_MEMBER_EXPORT(CCXX_EMPTY) Thread(bool isMain);

        CCXX_MEMBER_EXPORT(CCXX_EMPTY) Thread(int pri = 0, size_t stack = 0);

        // FIXME: win32 lack copy constructor
#ifndef WIN32

        Thread(const Thread &th);
#endif

        CCXX_MEMBER_EXPORT(virtual) ~Thread()
                {Terminate();};

        CCXX_MEMBER_EXPORT(int) Start(Semaphore *start = 0);

        CCXX_MEMBER_EXPORT(int) Detach(Semaphore *start = 0);

        inline Thread *getParent(void)
                {return _parent;};

        CCXX_MEMBER_EXPORT(void) Suspend(void);

        CCXX_MEMBER_EXPORT(void) Resume(void);

        inline thread_cancel_t getCancel(void)
                {return _cancel;};

        bool isRunning(void)
#ifdef WIN32
                {return (_tid != 0) ? true : false;}
#endif
        ;

        bool isThread(void)
#ifdef WIN32
                {return ((_tid == GetCurrentThreadId())) ? true : false;}
#endif
        ;

        friend CCXX_EXPORT(throw_t) getException(void);

        friend CCXX_EXPORT(void) setException(throw_t mode);

        friend inline int start(Thread &th, Semaphore *start = 0)
                {return th.Start(start);};

        friend inline void operator++(Thread &th)
                {th._start->Post();};

        friend inline void operator--(Thread &th)
                {th._start->Wait();};

        friend CCXX_EXPORT(void) ccxx_sleep(timeout_t msec);

#ifdef WIN32
        // FIXME: not defined in posix
        inline bool isCancelled(void)
                {return waitThread(_cancellation, 0) == WAIT_OBJECT_0; };

        inline bool isCancelled(timeout_t timer)
                {return waitThread(_cancellation, timer) == WAIT_OBJECT_0; };
                
        friend CCXX_EXPORT(DWORD) waitThread(HANDLE hRef, timeout_t timeout);
        friend CCXX_EXPORT(void) ccxx_yield(void);
#endif
};

inline void suspend(Thread &th)
{ th.Suspend(); }

inline void resume(Thread &th)
{ th.Resume(); }

#ifndef WIN32
extern "C" void sigHandler(int signo);

typedef int             signo_t;

class PosixThread: public Thread
{
private:
#ifndef WIN32
        friend void execHandler(Thread *th);
#endif
#ifndef _SIG_THREAD_ALARM
        static PosixThread *_timer;
        static Mutex _arm;
#endif
        
        time_t  _alarm;
        friend void sigHandler(int signo);
        inline static void SignalThread(Thread* th,signo_t signo)
                {pthread_kill(th->_tid, signo);};
protected:
                
        inline void SignalParent(signo_t signo)
                { SignalThread(_parent,signo); };
        
        inline void SignalMain(signo_t signo)
                { SignalThread(_main,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;};
        
        void setTimer(timeout_t timer);
        
        timeout_t getTimer(void);
        
        void endTimer(void);
        
        void WaitSignal(signo_t signo);
        
        void setSignal(int signo, bool mode);
public:
        
        inline void SignalThread(int signo)
                {SignalThread(this, signo);};

        friend void siginstall(int signo);
};
inline void signal(PosixThread &th, int signo)
        {th.SignalThread(signo);};
#endif

class CCXX_CLASS_EXPORT ThreadKey
{
private:
#ifndef WIN32
        pthread_key_t key;
#else
        DWORD   key;
#endif

public:
        ThreadKey();
        virtual ~ThreadKey();
        void *getKey(void);
        void setKey(void *);
};

class CCXX_CLASS_EXPORT TimerPort
{
#ifndef WIN32
        struct timeval timer;
#else
        DWORD timer;
#endif
        bool active;

public:
        TimerPort();

        void setTimer(timeout_t timeout = 0);

        void incTimer(timeout_t timeout);

        void endTimer(void);

        timeout_t getTimer(void);

        timeout_t getElapsed(void);
};

/*
 * on some systems, signal(signum, handler) is a macro
 */
#undef signal

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();};

inline void signal(Event &ev)
        {ev.Signal();};

inline void wait(Event &ev)
        {ev.Wait();};

inline void wait(Event &ev, timeout_t timer)
        {ev.Wait(timer);};

inline void reset(Event &ev)
        {ev.Reset();};

inline void signal(Semaphore &sem)
        {sem.Post();};

inline void wait(Semaphore &sem)
        {sem.Wait();};

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);};


// FIXME: not in win32 implementation
#ifndef WIN32

struct  timespec *gettimeout(struct timespec *spec, timeout_t timeout); 
void    wait(signo_t signo);
void    pdetach(void);
#endif // !WIN32

// FIXME: no way to implement in win32
#ifndef WIN32
#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();

        virtual ~Poller();

        pollfd *getList(int cnt);

        inline  pollfd *getList(void)
                {return ufds;};
};
#endif
#endif // !WIN32

#ifdef  COMMON_STD_EXCEPTION

class ThrException : public Exception
{
public:
        ThrException(const std::string &what_arg) : Exception(what_arg) {};
};

class SyncException : public ThrException
{
public:
        SyncException(const std::string &what_arg) : ThrException(what_arg) {};
};
#endif

#ifdef  __NAMESPACES__
};
#endif

#endif

---