gzThread.h

Go to the documentation of this file.

// *****************************************************************************
// File         : gzThread.h
// Module       : gzBase
// Description  : Class definition of Thread classes.
// Author       : Anders Modén      
// Product      : GizmoBase 2.1.1
//      
// Copyright © 2003- Saab Training Systems AB, Sweden       
//          
// NOTE:    GizmoBase is a platform abstraction utility layer for C++. It contains 
//          design patterns and C++ solutions for the advanced programmer.
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981104  Created file    
//
// ******************************************************************************

#ifndef __GZ_THREAD_H__
#define __GZ_THREAD_H__

#include "gzBasicTypes.h"
#include "gzMemory.h"
#include "gzMutex.h"
#include "gzReference.h"
#include "gzStackInfo.h"

const gzULong GZ_SLEEP_SECOND=1000;

const gzULong GZ_SLEEP_INFINITE=0xFFFFFFFFUL;

#if defined GZ_WINDOWS

#if !defined GZ_WINCE

#include <process.h>

typedef gzUInt  gzThreadReturnValue;

typedef struct 
        {
            gzUInt info;        // Thread ID
            HANDLE handle;
        } gzThreadInfo;
#else

typedef gzULong  gzThreadReturnValue;

typedef struct 
        {
            gzULong info;       // Thread ID
            HANDLE handle;
            HANDLE thread;

        } gzThreadInfo;
#endif

#elif defined GZ_UNIX

// --------------------------------  UNIX ----------------------------------

#include <unistd.h>

typedef struct 
        {
            pthread_t info;     // Thread ID

        } gzThreadInfo;

typedef gzVoid *        gzThreadReturnValue;

#endif


// ******************** class definitions ***************************************

//******************************************************************************
// Class    : gzThread
//                                  
// Purpose  : - 
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981104  Created 
//                                  
//******************************************************************************
enum gzThreadPriority { GZ_THREAD_PRIO_LOWEST, GZ_THREAD_PRIO_LOW, GZ_THREAD_PRIO_NORMAL, GZ_THREAD_PRIO_HIGH, GZ_THREAD_PRIO_HIGHEST };

const gzULong GZ_THREADSLOTS=10000;     // Number of possible enums

class GZ_BASE_EXPORT gzThread : public gzMemoryCheck , 
                                public gzProgramExecution
{
public:
    
    gzThread(gzThreadPriority prio=GZ_THREAD_PRIO_NORMAL);

    virtual ~gzThread();
    
    virtual gzVoid      stop(gzBool waitForStop=FALSE);

    virtual gzBool      run();



    gzBool      isRunning();    

    gzBool      isStopping();

    gzVoid      tickAlive();

    gzVoid      setTickLimit(gzDouble tickLimit);

    gzDouble    getTickLimit();

    gzVoid      setThreadPriority(gzThreadPriority prio);

    gzVoid      kill();

    gzVoid      setAutoDelete(gzBool deleteAfterTermination);

    gzThreadInfo getThreadInfo() const;


    // static utilities

    static gzVoid   gzDelayFunction( gzULong milliseconds , gzEvent *event=NULL);
    static gzVoid   gzMicroDelayFunction( gzULong microseconds);

    static gzULong  getThreadID();
    static gzULong  getThreadEnum(gzULong threadID=0);
    
protected:

    friend gzThreadReturnValue GZ_CALLBACK sprocess(gzVoid *pek);
        
    virtual gzVoid process();

    virtual gzVoid onProgramExecution();

    gzVoid      wrapproc();

    gzVoid      tickAlive_unsafe();
    gzBool      isRunning_unsafe();
    gzBool      isStopping_unsafe();

    gzMutex             m_mutex;

    gzBool              m_stop:1;

    gzBool              m_run:1;

    gzBool              m_autoDelete:1;
    
    gzThreadInfo        m_pInfo;

    gzDouble            m_tickAliveTime;

    gzDouble            m_tickLimit;

    gzThreadPriority    m_priority;

};

#define gzSleep gzThread::gzDelayFunction

#define gzMicroSleep gzThread::gzMicroDelayFunction

typedef enum { GZ_TICK_ACCUM , GZ_TICK_SKIP } gzTickPolicy;

//******************************************************************************
// Class    : gzThreadTicker
//                                  
// Purpose  : To provide a uniform ticking mechanism in combination with thread 
//            pool management.
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  001012  Created 
//                                  
//******************************************************************************
class gzThreadTicker
{
public:

    GZ_BASE_EXPORT gzThreadTicker(gzULong pool,gzThreadPriority prio=GZ_THREAD_PRIO_NORMAL);

    GZ_BASE_EXPORT virtual ~gzThreadTicker();

    GZ_BASE_EXPORT virtual gzVoid onInitialize(){}

    GZ_BASE_EXPORT virtual gzVoid onTerminate(){}

    GZ_BASE_EXPORT virtual gzVoid onTick(){}

    GZ_BASE_EXPORT gzVoid setTickInterval(gzDouble interval);

    GZ_BASE_EXPORT gzVoid setTickPolicy(gzTickPolicy policy);

    GZ_BASE_EXPORT gzBool triggerTick(gzDouble waitDelay=0);

    GZ_BASE_EXPORT gzVoid disableThreadTicker();

    GZ_BASE_EXPORT gzVoid enableThreadTicker();

    GZ_BASE_EXPORT gzVoid deleteThreadTicker();

    GZ_BASE_EXPORT gzBool isEnabled();

    GZ_BASE_EXPORT gzULong getPoolID();

    GZ_PROPERTY_EXPORT_( gzULong    ,   MinPoolSleepTicks   ,GZ_BASE_EXPORT);

private:

    friend class gzThreadPoolTicker;

    gzDouble            m_interval;

    gzDouble            m_nextTick;

    gzDouble            m_oneShot;

    gzULong             m_poolID;

    gzTickPolicy        m_policy;

    gzThreadPriority    m_priority;

    gzMutex             m_lock;

    gzMutex             m_trigger;

    gzBool              m_enabled;
};

//******************************************************************************
// Class    : gzThreadPoolTicker
//                                  
// Purpose  : Provides the tick manager for a certain thread pool
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  001012  Created 
//                                  
//******************************************************************************
class gzThreadPoolTicker : public gzReference , public gzThread
{
public:

    GZ_BASE_EXPORT virtual ~gzThreadPoolTicker();

    GZ_BASE_EXPORT virtual gzBool   useDeepCopy();

    GZ_BASE_EXPORT static gzVoid guiTick();

private:

    friend class gzThreadTicker;

    GZ_BASE_EXPORT gzThreadPoolTicker(gzULong pool,gzThreadPriority prio);
    
    gzVoid addSubscriber(gzThreadTicker *subscriber);

    gzVoid removeSubscriber(gzThreadTicker *subscriber);

    gzBool checkSubscriptions(gzULong &minSleepTicks);

    gzVoid checkMinTickDelay();
    
    virtual gzVoid  process();

    gzBool processWork();

    // --------------- vars ------------------

    gzULong                 m_poolID;

    gzList<gzThreadTicker>  m_subscribers;

    gzList<gzThreadTicker>  m_addSubscribers;

    gzList<gzThreadTicker>  m_removeSubscribers;

    gzList<gzThreadTicker>  m_deleteSubscribers;

    gzMutex                 m_addSubscriberLock;

    gzMutex                 m_removeSubscriberLock;

    gzMutex                 m_deleteSubscriberLock;

    gzDouble                m_minTickDelay;

    gzEvent                 m_event;

    static gzRefPointer<gzThreadPoolTicker> getThreadPoolTicker(gzULong pool,gzThreadPriority prio=GZ_THREAD_PRIO_NORMAL);

    static gzMemCheck<gzMutex>      s_threadPoolLock;

    static gzRefList<gzThreadPoolTicker> s_threadPool;
};

//******************************************************************************
// Class    : gzThreadData
//                                  
// Purpose  : To provide a thread local storage.- Each thread gets its own instance of data
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  020525  Created 
//                                  
//******************************************************************************
template <class T> class gzThreadData 
{
public:

    gzThreadData(gzUByte indexCount=1);

    virtual ~gzThreadData();

    operator T &();

    T & operator[](gzUByte index);
    
    T & get() { return operator T&(); }

    gzVoid set(const T & data);

private:

    template <class T2> class _localData : public gzReference
    {
    public:

        _localData(gzUByte indexCount):data(indexCount),index(0)
        {
        }

        virtual ~_localData()
        {
        }

        gzArray<T2> data;
        gzUByte     index;
    };

    gzULong                                             m_currentThreadID;

    gzRefPointer<_localData<T> >                        m_currentData;

    gzRefDict<gzValueCompareInterface,_localData<T> >   m_dict;

    gzMutex                                             m_locker;

    gzUByte                                             m_indexCount;
};

template <class T> inline gzThreadData<T>::gzThreadData(gzUByte indexCount):
                                                    m_currentThreadID(0),
                                                    m_locker(FALSE),
                                                    m_indexCount(indexCount)
{
}

template <class T> gzThreadData<T>::~gzThreadData()
{
    m_locker.waitLock();

    m_dict.clear();
    m_currentData=0;

    m_locker.unLock();
}


template <class T> inline gzVoid gzThreadData<T>::set(const T & data)
{
    operator T&()=data;
}

template <class T> inline gzThreadData<T>::operator T &()
{
    GZ_BODYGUARD(m_locker);

    gzULong threadID=gzThread::getThreadID();

    if(m_currentThreadID!=threadID)
    {
        _localData<T> *refData=m_dict.find(threadID);

        if(!refData)
        {
            refData=new _localData<T>(m_indexCount);
            m_dict.enter(threadID,refData);
        }

        m_currentThreadID=threadID;
        m_currentData=refData;
    }

    T & retval = m_currentData->data[m_currentData->index];

    m_currentData->index=(m_currentData->index+1)%m_indexCount;

    return retval;
}

template <class T> inline T & gzThreadData<T>::operator [](gzUByte index)
{
    GZ_BODYGUARD(m_locker);

    gzULong threadID=gzThread::getThreadID();

    if(m_currentThreadID!=threadID)
    {
        _localData<T> *refData=m_dict.find(threadID);

        if(!refData)
        {
            refData=new _localData<T>(m_indexCount);
            m_dict.enter(threadID,refData);
        }

        m_currentThreadID=threadID;
        m_currentData=refData;
    }

    if(index<m_indexCount)
        return m_currentData->data[index];

    throwFatalTemplateError("gzThreadData [] index out of bounds");
}

#endif //__GZ_THREAD_H__

---