base_thread.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2007 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#if COMPILE_THREADS
#ifndef BASE_THREAD_HH
#define BASE_THREAD_HH 1

#include "base_thread_common.hh"

namespace base {

// Abbrev:
#define gThread base::global.mThread

// Function decorations:
#define FN_MAIN_THREAD  // means only the MAIN thread can execute function
#define FN_REENTRANT    // function is threadable without locking
#define FN_LOCKED       // function is threadable but must be locked

// Macros:
#define THREAD_CODE( CODE ) CODE
#define THREAD_RUN( func, funcArg, priority ) gThread.Run( (func), (funcArg), (priority) )

void* SuballocateThreadMemory( const uint bytes );  // solves compiling dependency

class Thread : public Threadable
{

friend void* SuballocateThreadMemory( const uint bytes );

public:
    typedef void(*ThreadFunc)(long);  
    enum ePriority { ePriority_DEFAULT, ePriority_LOW, ePriority_HIGH, };  

public:
    struct Tid
    {
    private:
        Tid( pthread_t tidPthread ) : mPthread(tidPthread) { }
        pthread_t   mPthread;  // POSIX pthread ID
    friend class Thread;
    };

public:
    struct RunArgs
    {
        RunArgs( ThreadFunc        func,
                 long              funcArg,
                 Thread::ePriority priority         = Thread::ePriority_DEFAULT,
                 uint              threadMemorySize = base::defs::DEFAULT_THREAD_MEMORY_SIZE,
                 bool              joinable         = false );

        ThreadFunc          mFunc;              
        long                mFuncArg;           
        Thread::ePriority   mPriority;          
        uint                mThreadMemorySize;  
        bool                mJoinable;          
    };

public:
    class Condition
    {
    friend class Thread;
    public:
        Condition( void );
        ~Condition();
    private:
        pthread_cond_t  mCondition;; 
        pthread_mutex_t mMutex;
    };

private:
    friend class Global;
    Thread( void );
    ~Thread();

public:
    Tid         Run( const RunArgs& runArgs );
    void        Yield( void );
    void        Sleep( Milliseconds millisecs );
    bool        Wait( Tid tid );
    void        Wait( Condition& condition );
    void        Awaken( Condition& condition );
    uint        Cnt( void );
    bool        IfMain( void );
    Tid         GetTid( void );
    void*       SuballocateThreadMemory( uint bytes );

private:
    void                InitPthreadAttr();
    CLASS_METHOD void*  Run2( void* runArgs );
    void                Run3( const RunArgs& runArgs );
    void                NewThreadMemory( const uint threadMemorySize );
    void                DeleteThreadMemory( void );

private:
#if DEBUG
    bool                    mValid;
#endif
    Atomic::Int             mThreadCnt;         
    Tid                     mMainTid;           
    vector<pthread_attr_t>  mPthreadAttr;       
    pthread_key_t           mThreadMemoryKey;   
    CLASS_VAR uint          msDefaultThreadMemorySize;  

//..............................................................................

// Compatibility macros to help write locking code involving atomic TIDs
// based on either gcc Thread Local Storage (TLS) or generic pthreads.
// An "atomic TID" is meant to be an operand in atomic operations for locking.
// Don't confuse an atomic TID with with a pthreads TID.
// class FastLock
// {
//     void Lock( void )
//     {
//         mOwner = THREAD_ATOMIC_TID();
//         if ( THREAD_ATOMIC_TID_EQUAL(mOwner) )
//     }
//     Thread::AtomicTid  mOwner;
// };
// Atomic TID is a thread-local variable.
// A new thread receives an "atomic TID" then
// the Thread class increments it for the next thread.
#if COMPILE_GCC_TLS
#define THREAD_ATOMIC_TID()             (restrict::gAtomicTid)
#define THREAD_ATOMIC_TID_EQUAL(TID)    ((THREAD_ATOMIC_TID()) == (TID))
public:  typedef volatile Atomic::Int   AtomicTid;
private: CLASS_VAR int                  msAtomicTidNext;
#else
#define THREAD_ATOMIC_TID()             ( pthread_self() )
#define THREAD_ATOMIC_TID_EQUAL(TID)    ( pthread_equal( pthread_self(), (TID) ) )
public:  typedef volatile pthread_t     AtomicTid;
#endif

};

//------------------------------------------------------------------------------

#if COMPILE_GCC_TLS
// On FreeBSD 6.2, __thread malfunctions as a class member.
// __thread and volatile aren't compatible.
namespace restrict { extern __thread int gAtomicTid; }
#endif

} // namespace base

#endif // BASE_THREAD_HH
#endif // COMPILE_THREADS

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:07 2007