cTaskProfiler.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cTaskProfiler_H
#define _INC_cTaskProfiler_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/cTimeSys.h"
#include "GrayCore/include/cThreadLock.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
#define USE_PROFILER_TEST       // just use a test pattern for data.
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cTaskProfiler);
        class GRAYLIB_LINK cTaskProfilerRec
        {
        public:
                static const TIMEPERF_t k_NOTIME_BYTERATE = ((TIMEPERF_t)-1);   
                static const TIMEPERF_t k_NOTIME_COUNT = ((TIMEPERF_t)-2);              
                cTimePerf m_Time;               
                UINT m_nSamples;                
        };
 
        typedef int TASK_PROFILER_t;    
 
        class GRAYLIB_LINK cTaskProfilerThread
        {
 
        public:
                THREADID_t m_nThreadId; 
 
                // Store the last task start time.
                TASK_PROFILER_t m_idTaskCur;    
                cTimePerf m_TimeTaskSwitch;             
        };
 
        class GRAYLIB_LINK cTaskProfiler
        {
 
        public:
                UINT m_nSampleFrame;    
 
        protected:
                const TASK_PROFILER_t m_iTaskQty;
                TIMESECD_t m_iSampleWindowSec;          
                cTimePerf m_TimeWindowSize;             
                mutable cThreadLockCount m_LockProf;            
 
                // Sample Windows. (For All Tasks we are tracking)
                cArrayTyped<cTaskProfilerRec, cTaskProfilerRec&> m_PrvWindow;
                cArrayTyped<cTaskProfilerRec, cTaskProfilerRec&> m_CurWindow;
                cTimePerf m_TimeTotal;                          
 
                // The current action (per thread)
                cTaskProfilerThread m_Cur;
 
        protected:
                void InitTestCurrentWindow();
                void ClearCurrentWindow();
                cTaskProfilerRec& GetTaskCur(TASK_PROFILER_t idTask)
                {
                        return m_CurWindow.ElementAt(idTask);
                }
 
        public:
                cTaskProfiler(TASK_PROFILER_t iQtyTasks);
                virtual ~cTaskProfiler();
 
                bool isProfilingActive() const
                {
                        return(m_iSampleWindowSec ? true : false);
                }
                TIMESECD_t get_SampleWindowLen() const
                {
                        return m_iSampleWindowSec;
                }
                void put_SampleWindowLen(TIMESECD_t iSampleWindowSec);
 
                TASK_PROFILER_t get_TaskQty() const
                {
                        return m_iTaskQty;
                }
                TASK_PROFILER_t get_TaskCurrent() const
                {
                        return m_Cur.m_idTaskCur;
                }
 
                TASK_PROFILER_t SwitchTask(TASK_PROFILER_t idTask);
 
                void IncTaskCount(TASK_PROFILER_t idTask, UINT nSamples, TIMEPERF_t Type = cTaskProfilerRec::k_NOTIME_BYTERATE)
                {
                        cThreadGuard guard(m_LockProf);
                        cTaskProfilerRec& rec = m_CurWindow.ElementAt(idTask);
                        rec.m_Time = Type;      // ignore time for this task.
                        rec.m_nSamples += nSamples;
                }
                void SetTaskCount(TASK_PROFILER_t idTask, UINT nSamples, TIMEPERF_t Type = cTaskProfilerRec::k_NOTIME_COUNT)
                {
                        cThreadGuard guard(m_LockProf);
                        cTaskProfilerRec& rec = m_CurWindow.ElementAt(idTask);
                        rec.m_Time = Type;      // ignore time for this task.
                        rec.m_nSamples = nSamples;
                }
 
                cStringA GetTaskStatusDesc(TASK_PROFILER_t idTask) const;
 
                float GetTaskPercent(TASK_PROFILER_t idTask) const
                {
                        ASSERT(IS_INDEX_GOOD(idTask, get_TaskQty()));
                        return((float)((double)(m_PrvWindow[idTask].m_Time.m_nTime) / (double)(m_TimeWindowSize.m_nTime)));
                }
                TIMESECF_t GetTaskTimeSec(TASK_PROFILER_t idTask) const
                {
                        ASSERT(IS_INDEX_GOOD(idTask, get_TaskQty()));
                        return((TIMESECF_t)m_PrvWindow[idTask].m_Time.get_Seconds());
                }
 
                TIMEPERF_t get_TaskDiff() const
                {
                        return m_Cur.m_TimeTaskSwitch.get_AgePerf();
                }
                double get_TaskDiffSec() const
                {
                        return m_Cur.m_TimeTaskSwitch.get_AgeSeconds();
                }
 
#if 0
                UINT GetTaskSamples(TASK_PROFILER_t idTask) const
                {
                        return m_PrvWindow[idTask].m_nSamples;
                }
#endif
 
                virtual void OnSampleWindowComplete();
 
                UNITTEST_FRIEND(cTaskProfiler);
        };
};
#endif // _INC_cTaskProfiler_H