thread.h

Go to the documentation of this file.

// Copyright (C) 1999-2005 Open Source Telecom Corporation.
// Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
//
// 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 CCXX_STRING_H_
#include <cc++/string.h>
#endif

#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;
    String _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);

#ifndef WIN32

  void force_unlock_after_cancellation();

#endif // WIN32

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