thread.h

Go to the documentation of this file.

// Copyright (C) 1999-2005 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, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  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 GNU
// Common C++.  If you copy code from other releases into a copy of GNU
// 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 GNU 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_

#include <cc++/config.h>

#ifndef WIN32
#define CCXX_POSIX
#endif // !WIN32

#include <ctime>

#ifndef WIN32
#include <pthread.h>
#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

#endif // !WIN32

#ifdef  HAVE_GCC_CXX_BITS_ATOMIC
#include <ios>
#endif

#ifdef  CCXX_NAMESPACES
namespace ost {
#ifdef __BORLANDC__
# if __BORLANDC__ >= 0x0560
using std::time_t;
using std::tm;
# endif
#endif
#endif

#ifdef  HAVE_GCC_CXX_BITS_ATOMIC
using namespace __gnu_cxx;
#endif

class __EXPORT Thread;
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)

#ifdef  signal
#undef  signal
#endif

#endif // !WIN32

#undef Yield

class __EXPORT Conditional;
class __EXPORT Event;

class __EXPORT Mutex
{
private:
        static bool _debug;
        const char *_name;
#ifndef WIN32
#ifndef PTHREAD_MUTEXTYPE_RECURSIVE
        int volatile _level;
        Thread *volatile _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 // WIN32

# if defined(MUTEX_UNDERGROUND_WIN32_MUTEX) && defined(MUTEX_UNDERGROUND_WIN32_CRITICALSECTION)
# error "Can't determine underground for Mutex"
# endif

#ifdef MUTEX_UNDERGROUND_WIN32_MUTEX
        HANDLE _mutex;
#endif
#ifdef MUTEX_UNDERGROUND_WIN32_CRITICALSECTION
        CRITICAL_SECTION _criticalSection;
#endif

#endif // WIN32

public:
        Mutex(const char *name = NULL);

        virtual ~Mutex();

        static void setDebug(bool mode)
                {_debug = mode;};

        inline void nameMutex(const char *name)
                {_name = name;};

        void enterMutex(void);

        inline void enter(void)
                {enterMutex();};

        inline void leave(void)
                {leaveMutex();};

        inline bool test(void)
                {return tryEnterMutex();};

        bool tryEnterMutex(void);

        void leaveMutex(void);
};

class __EXPORT MutexLock
{
private:
        Mutex& mutex;
public:
        MutexLock( Mutex& _mutex ) : mutex( _mutex )
                { mutex.enterMutex(); }

        // this should be not-virtual
        ~MutexLock()
                { mutex.leaveMutex(); }
};

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 __EXPORT ReadLock
{
private:
        ThreadLock& tl;

public:
        ReadLock( ThreadLock& _tl ) : tl( _tl )
                { tl.readLock(); }
        // this should be not-virtual
        ~ReadLock()
                { tl.unlock(); }
};

class __EXPORT WriteLock
{
private:
        ThreadLock& tl;

public:
        WriteLock( ThreadLock& _tl ) : tl( _tl )
                { tl.writeLock(); }
        // this should be not-virtual
        ~WriteLock()
                { tl.unlock(); }
};


class __EXPORT MutexCounter : public Mutex
{
private:
        volatile int    counter;

public:
        MutexCounter(const char *id = NULL);

        MutexCounter(int initial, const char *id = NULL);

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

class __EXPORT AtomicCounter
{
#ifndef CCXX_USE_WIN32_ATOMIC
private:
#if     defined(HAVE_ATOMIC_AIX)
        volatile int counter;
#elif   defined(HAVE_GCC_BITS_ATOMIC)
        volatile _Atomic_word counter;
#elif   defined(HAVE_GCC_CXX_BITS_ATOMIC)
        volatile _Atomic_word counter;
//      __gnu_cxx::_Atomic_word counter;
#elif   defined(HAVE_ATOMIC)
        atomic_t atomic;
#else
        volatile int counter;
        pthread_mutex_t _mutex;
#endif

public:
        AtomicCounter();

        AtomicCounter(int value);

        ~AtomicCounter();

        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 __EXPORT Conditional
{
private:
        pthread_cond_t _cond;
        pthread_mutex_t _mutex;

public:
        Conditional(const char *id = NULL);

        virtual ~Conditional();

        void signal(bool broadcast);

        bool wait(timeout_t timer = 0, bool locked = false);

        void enterMutex(void);

        inline void lock(void)
                {enterMutex();};

        bool tryEnterMutex(void);

        inline bool test(void)
                {return tryEnterMutex();};

        void leaveMutex(void);

        inline void unlock(void)
                {return leaveMutex();};
};
#endif

class __EXPORT Semaphore
{
private:
#ifndef WIN32
        unsigned _count, _waiters;
        pthread_mutex_t _mutex;
        pthread_cond_t _cond;
#else
        HANDLE  semObject;
#endif // !WIN32

public:
        Semaphore(unsigned resource = 0);

        virtual ~Semaphore();

        bool wait(timeout_t timeout = 0);

        void post(void);

        // FIXME: how implement getValue for posix compatibility ?
        // not portable...

#if     0

        int getValue(void);
#endif
};

class __EXPORT SemaphoreLock
{
private:
        Semaphore& sem;

public:
        SemaphoreLock( Semaphore& _sem ) : sem( _sem )
                { sem.wait(); }
        // this should be not-virtual
        ~SemaphoreLock()
                { sem.post(); }
};

class __EXPORT Event
{
private:
#ifndef WIN32
        pthread_mutex_t _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 __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 Cancellation;
        friend class postream_type;
        friend class Slog;

        Semaphore joinSem;
        static Thread* _main;

        Thread *_parent;
        Cancel _cancel;
        Semaphore *_start;

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

public:
        static Thread *get(void);

private:
#ifdef  WIN32
        static unsigned __stdcall Execute(Thread *th);
#endif

        // close current thread, free all and call Notify
        void close();

private:
        char _name[32];
        static size_t _autostack;

#ifdef WIN32
        DWORD waitHandle(HANDLE obj, timeout_t timeout);
#endif

protected:
        void setName(const char *text);

        virtual void run(void) = 0;

        virtual void final(void);

        virtual void initial(void);

        virtual void* getExtended(void);

        virtual void notify(Thread*);

        void exit(void);

        void sync(void);

        bool testCancel(void);

        void setCancel(Cancel mode);

        void setSuspend(Suspend mode);

        void terminate(void);

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

public:
        Thread(bool isMain);

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

#ifndef WIN32

        Thread(const Thread &th);
#endif

        virtual ~Thread();

        static void setStack(size_t size = 0)
                {_autostack = size;};

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

        bool isDetached(void) const;

        void join(void);

        bool isThread(void) const;

        cctid_t getId(void) const;

        const char *getName(void) const
                {return _name;};

        static Throw getException(void);

        static 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
        bool isCancelled() const;

        static DWORD waitThread(HANDLE hRef, timeout_t timeout);
#endif

        static Cancel enterCancel(void);

        static void exitCancel(Cancel cancel);
};

class __EXPORT Cancellation
{
private:
        Thread::Cancel prior;

public:
        Cancellation(Thread::Cancel cancel);
        ~Cancellation();
};

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

        virtual void onHangup(void);

        virtual void onException(void);

        virtual void onDisconnect(void);

        virtual void onPolling(void);

        virtual void onSignal(int);

        void setTimer(timeout_t timer, bool periodic = false);

        timeout_t getTimer(void) const;

        void endTimer(void);

#if defined(HAVE_SIGWAIT) || defined(HAVE_SIGWAIT2)

        void waitSignal(signo_t signo);
#endif

        void setSignal(int signo, bool active);

        pthread_attr_t *getPthreadAttrPtr(void);

        pthread_t getPthreadId(void);

public:

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

        inline void signalThread(int signo)
                {signalThread(this, signo);};

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

class __EXPORT 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 __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 decTimer(timeout_t timeout);

        void sleepTimer(void);

        void endTimer(void);

        timeout_t getTimer(void) const;

        timeout_t getElapsed(void) const;
};



// 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

#ifdef USE_POLL

class Poller
{
private:
        int nufds;
        pollfd *ufds;

public:
        Poller();

        virtual ~Poller();

        pollfd *getList(int cnt);

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

inline Thread *getThread(void)
        {return Thread::get();}

class __EXPORT SysTime
{
private:
                static Mutex timeLock;

protected:
                inline static void lock(void)
                        {timeLock.enterMutex();}

                inline static void unlock(void)
                        {timeLock.leaveMutex();}

public:
        static time_t getTime(time_t *tloc = NULL);
        static time_t time(time_t *tloc)
                        { return getTime(tloc); };

        static int getTimeOfDay(struct timeval *tp);
        static int gettimeofday(struct timeval *tp, struct timezone *)
                        { return getTimeOfDay(tp); };

        static struct tm *getLocalTime(const time_t *clock, struct tm *result);
        static struct tm *locatime(const time_t *clock, struct tm *result)
                        { return getLocalTime(clock, result); };

                static struct tm *getGMTTime(const time_t *clock, struct tm *result);
                static struct tm *gmtime(const time_t *clock, struct tm *result)
                        { return getGMTTime(clock, result);};
};

#ifndef HAVE_LOCALTIME_R

inline struct tm *localtime_r(const time_t *t, struct tm *b)
        {return SysTime::getLocalTime(t, b);};
inline char *ctime_r(const time_t *t, char *buf)
        {return ctime(t);};
inline struct tm *gmtime_r(const time_t *t, struct tm *b) \
{return SysTime::getGMTTime(t, b);};
inline char *asctime_r(const struct tm *tm, char *b) \
        {return asctime(tm);};

#endif

#ifdef  CCXX_NAMESPACES
}
#endif

#endif