---

thread.h

Go to the documentation of this file.

// Copyright (C) 1999-2002 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
#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) || defined(_AIX)
#define CCXX_SYSV_SEMAPHORES
#endif

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

#undef CCXX_USE_WIN32_ATOMIC
#ifndef WIN32
#include <time.h>
#include <signal.h>
#include <unistd.h>

#ifdef  _THR_UNIXWARE
#undef  PTHREAD_MUTEXTYPE_RECURSIVE
#endif

typedef pthread_t       cctid_t;
typedef unsigned long   timeout_t;

/*
#if defined(__CYGWIN32__) 
__declspec(dllimport) long __stdcall InterlockedIncrement(long *);
__declspec(dllimport) long __stdcall InterlockedDecrement(long *);
__declspec(dllimport) long __stdcall InterlockedExchange(long *, long);
#define CCXX_USE_WIN32_ATOMIC 1
#endif
*/

#else // WIN32
typedef DWORD   cctid_t;
typedef DWORD   timeout_t;

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

#endif // !WIN32

#ifdef  CCXX_NAMESPACES
namespace ost {
#endif

class CCXX_CLASS_EXPORT Thread;
class CCXX_CLASS_EXPORT ThreadKey;

#define TIMEOUT_INF ~((timeout_t) 0)

#define ENTER_CRITICAL  enterMutex();
#define LEAVE_CRITICAL  leaveMutex();
#define ENTER_DEFERRED  setCancel(cancelDeferred);
#define LEAVE_DEFERRED  setCancel(cancelImmediate);

#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)

#endif // !WIN32

#undef 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 object.  This is protected rather than private
         * because some mixed mode pthread operations require a mutex as
         * well as their primary pthread object.  A good example of this
         * is the Event class, as waiting on a conditional object must be
         * associated with an accessable mutex.  An alternative would be
         * to make such classes "friend" classes of the Mutex.
         */
        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 CCXX_USE_WIN32_ATOMIC
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
};

#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  CCXX_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 CCXX_CLASS_EXPORT Thread
{
public:
        typedef enum Throw {
                throwNothing,  
                throwObject,   
                throwException 
        } Throw;
        
        typedef enum Cancel
        {
                cancelInitial=0,  
                cancelDeferred=1, 
                cancelImmediate,  
                cancelDisabled,   
                cancelManual,     
                cancelDefault=cancelDeferred
        } Cancel;

        typedef enum Suspend
        {
                suspendEnable, 
                suspendDisable 
        } Suspend;

#ifndef WIN32

friend class PosixThread;
#endif

friend class DummyThread;
private:
        friend class Slog;

        static Thread* _main;

        Thread *_parent;
        enum Cancel _cancel;
        Semaphore *_start;

        // private data
        friend class ThreadImpl;
        class ThreadImpl* priv;

#ifndef WIN32
        friend Thread *getThread(void);
#else
        static unsigned __stdcall Execute(Thread *th);
#endif

        // close current thread, free all and call Notify
        void close();
        
protected:
        virtual void run(void) = 0;

        virtual void final(void)
                {return;};

        virtual void initial(void)
                {return;};

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

        virtual void notify(Thread*)
                {return;};

        void exit(void);

        bool testCancel(void);

        void setCancel(Cancel mode);

        void setSuspend(Suspend mode);

        void terminate(void);

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

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

public:
        Thread(bool isMain);

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

#ifndef WIN32

        Thread(const Thread &th);
#endif

        virtual ~Thread();

        static void sleep(timeout_t msec);

        static void yield(void);

        int start(Semaphore *start = 0);

        int detach(Semaphore *start = 0);

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

        void suspend(void);

        void resume(void);

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

        bool isRunning(void);

        bool isThread(void);

        friend CCXX_EXPORT(Throw) getException(void);

        friend CCXX_EXPORT(void) setException(Throw mode);

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

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

#ifdef WIN32
        // FIXME: not defined in posix
        bool isCancelled();

        friend CCXX_EXPORT(DWORD) waitThread(HANDLE hRef, timeout_t timeout);
#endif
};

CCXX_EXPORT(Thread*) getThread(void);
CCXX_EXPORT(Thread::Throw) getException(void);
CCXX_EXPORT(void) setException(Thread::Throw mode);

#if !defined(WIN32) && !defined(__CYGWIN32__)  && !defined(__MINGW32__)
typedef int             signo_t;

class PosixThread: public Thread
{
private:
#ifndef WIN32

        friend class ThreadImpl;
        friend class Thread;
#endif
#ifndef CCXX_SIG_THREAD_ALARM
        static PosixThread *_timer;
        static Mutex _arm;
#endif
        
        time_t  _alarm;
        static void signalThread(Thread* th,signo_t 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)
                {return;};
        
        void setTimer(timeout_t timer);
        
        timeout_t getTimer(void) const;
        
        void endTimer(void);
        
        void waitSignal(signo_t signo);
        
        void setSignal(int signo, bool active);
public:

        CCXX_MEMBER_EXPORT(CCXX_EMPTY) PosixThread(int pri = 0, size_t stack = 0);
        
        inline void signalThread(int signo)
                {signalThread(this, signo);};

        friend void sigInstall(int signo);
};
#endif

class ThreadKey
{
private:
#ifndef WIN32
        pthread_key_t key;
        typedef void (*TDestruct)(void*);
        friend class ThreadImpl;
        ThreadKey(TDestruct destruct);
#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) const;

        timeout_t getElapsed(void) const;
};

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
#if !defined(WIN32)

// FIXME: private declaration ???
struct  timespec *getTimeout(struct timespec *spec, timeout_t timeout); 

#if !defined(__CYGWIN32__) && !defined(__MINGW32__)
void    wait(signo_t signo);
#endif

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

class InterruptException : public ThrException
{
public:
        InterruptException() : ThrException("interrupted") {};
};

#endif

#ifdef  CCXX_NAMESPACES
};
#endif

#endif

---