ThreadManager.h

Go to the documentation of this file.

#if !defined(_THREADMANAGER_H_)
#define _THREADMANAGER_H_
 
#include "MemoryManager.h"
 
namespace cmlabs {

struct ThreadStats {
    uint32 id;              
    uint64 created;         
    uint32 status;          
    uint32 osID;            
    ThreadHandle hThread;   
    THREAD_FUNCTION func;   
    void* args;             
    uint64 time[10];        
    uint64 currentCPUTicks[10]; 
};

struct ThreadDataHeader {
    uint32 size;            
    uint32 count;           
    uint32 activeCount;     
    uint32 statColPolicy;   
    uint64 time[10];        
    uint64 currentCPUTicks[10]; 
    uint32 bitFieldSize;    
    // Bitfield
    // Stats1, Stats2, ...
};
 

class Runnable {
public:
    Runnable() {threadID = 0; shouldContinue = true; isRunning = false;}
    virtual ~Runnable() {
        stop();
    }

    virtual bool stop(uint32 timeout = 200) {
        shouldContinue = false;
        int32 timeleft = (int32)timeout;
        while (isRunning) {
            utils::Sleep(5);
            if ( (timeleft -= 5) <= 0) {
                LogPrint(0,LOG_SYSTEM,0,"Thread id %u didn't terminate...\n", threadID);
                return false;
            }
        }
        return true;
    }
 
protected:
    uint32 threadID;        
    bool shouldContinue;    
    bool isRunning;         
};

#define GETTHREADSTATS(data,id) (ThreadStats*)(data + sizeof(ThreadDataHeader) + ((ThreadDataHeader*)data)->bitFieldSize + id*sizeof(ThreadStats))

class ThreadManager : public Runnable {
public:
    static ThreadManager* Singleton;

    static bool CreateThreadManager();
    static bool CreateThread(THREAD_FUNCTION func, void* args, uint32& newID, uint32 reqID = 0);
    static bool PauseThread(uint32 id);
    static bool ContinueThread(uint32 id);
    static bool InterruptThread(uint32 id);
    static bool TerminateThread(uint32 id);
    static bool IsThreadRunning(uint32 id);

    static bool AddLocalThreadStats();
    static bool GetLocalThreadID(uint32& id);

    static ThreadStats GetLocalThreadStats();
    static ThreadStats GetThreadStats(uint32 id);
    static ThreadStats* GetAllThreadStats(uint32& count);

    static bool Shutdown();

    static bool UnitTest();

    ThreadManager();
    ~ThreadManager();
    bool init();
    bool shutdown();

    int32 threadMonitoring();
 
protected:
    bool createThread(THREAD_FUNCTION func, void* args, uint32& newID, uint32 reqID);
    bool pauseThread(uint32 id);
    bool continueThread(uint32 id);
    bool interruptThread(uint32 id);
    bool terminateThread(uint32 id);
    bool isThreadRunning(uint32 id);

    bool addLocalThreadStats();
    bool getLocalThreadID(uint32& id);

    ThreadStats getThreadStats(uint32 id);
    ThreadStats* getAllThreadStats(uint32& count);

    bool resizeThreadStorage(uint32 newCount);
 
    utils::Mutex mutex;     
    unsigned char* data;    
};

bool TestThreadManager();

static THREAD_RET THREAD_FUNCTION_CALL ThreadMonitoring(void* arg);
 
 
} // namespace cmlabs
 
#endif //_THREADMANAGER_H_