GUIProfiler.h

/*
* Copyright (C) TES Electronic Solutions GmbH,
* All Rights Reserved.
* Contact: info@guiliani.de
*
* This file is part of the Guiliani HMI framework
* for the development of graphical user interfaces on embedded systems.
*/
 
#ifndef __GUIMEMPROFILE_H__
#define __GUIMEMPROFILE_H__
 
#include "GUIAnimatable.h"
#include "GUICompositeObject.h"
 
#include "GUIFontResource.h"
#include "GUIRect.h"
#include "eC_String.h"
#include "eC_TList_doubleLinked.h"
 
#include "GUIComponentManager.h"
 
#define GETPROFILER CGUIComponentManager::GetInstance().GetProfiler()
 
class CGUIProfiler : public CGUIAnimatable
{
public:
    friend class CGUI; 
    friend class CGfxWrap; 
    friend class CGUIComponentManager; 
 
public:
    enum FPSCounterID
    {
        INVALID_COUNTER_ID = -1,
        DEFAULT_FPS,
        DEFAULT_ABS_FPS
    };
 
public:
    static void CreateInstance();
 
    static void DeleteInstance();
 
    // output methods
 
    void SetActive(const eC_Bool& bActive);
 
    eC_Bool IsActive() const
    {
        return m_bActive;
    }
 
    void SetDisplayActive(const eC_Bool& bActive);
 
    eC_Bool IsDisplayActive() const
    {
        return m_bDisplayActive;
    }
 
    void SetConsoleActive(const eC_Bool& bActive);
 
    eC_Bool IsConsoleActive() const
    {
        return m_bConsoleActive;
    }
 
    // profiling
 
    void SetCPUProfilingActive(const eC_Bool& bActive);
 
    eC_Bool IsCPUProfilingActive() const
    {
        return m_bCPUProfilingActive;
    }
 
    void SetMemoryProfilingActive(const eC_Bool& bActive);
 
    eC_Bool IsMemoryProfilingActive() const
    {
        return m_bMemoryProfilingActive;
    }
 
    void SetMemoryUsageBarActive(const eC_Bool& bActive);
 
    eC_Bool IsMemoryUsageBarActive() const
    {
        return m_bMemoryUsageBarActive;
    }
 
    void SetGraphicsProfilingActive(const eC_Bool& bActive);
 
    eC_Bool IsGraphicsProfilingActive() const
    {
        return m_bGraphicsProfilingActive;
    }
 
    void SetInvalidationActive(const eC_Bool& bActive);
 
    eC_Bool IsInvalidationActive() const
    {
        return m_bInvalidationActive;
    }
 
    void SetFPSActive(const eC_Bool& bActive);
 
    eC_Bool IsFPSActive() const
    {
        return m_bFPSActive;
    }
 
    void SetRuntimeActive(const eC_Bool& bActive);
 
    eC_Bool GetRuntimeActive() const
    {
        return m_bRuntimeActive;
    }
 
    void SetObjectCountActive(const eC_Bool& bActive);
 
    eC_Bool GetObjectCountActive() const
    {
        return m_bObjectCountActive;
    }
 
    // memory-settings
 
    void SetMemoryAvailable(const size_t& tMemoryAvailable);
 
    size_t GetMemoryAvailable() const;
 
    void SetMemoryThresholds(const size_t& uiMemoryUsageWarning, const size_t& uiMemoryUsageAlert);
 
    void GetMemoryThresholds(size_t& uiMemoryUsageWarning, size_t& uiMemoryUsageAlert);
 
    // general settings
 
    void SetUpdateInterval(const eC_UInt& uiUpdateInterval);
 
    void SetBackColor(const eC_UInt& uiBackColor);
 
    void SetTextColor(const eC_UInt& uiTextColor);
 
    void SetFont(const FontResource_t& eFontID);
 
    void SetPosition(const eC_Value& vX, const eC_Value& vY);
 
    void SetMemoryUsageBarPosition(const eC_Value& vX, const eC_Value& vY);
 
    void SetMemoryUsageBarSize(const eC_Value& vWidth, const eC_Value& vHeight);
 
    // getter for values
 
    eC_UInt GetCPUUsage() const;
 
    size_t GetMemoryUsed() const;
 
    size_t GetMemoryMax() const;
 
    void ClearMemoryMax();
 
    size_t GetMemoryLargestBlock() const;
 
    void ClearMemoryLargestBlock();
 
    eC_UInt GetRedrawDuration() const;
 
    eC_UInt GetRefreshDuration() const;
 
    eC_UInt GetObjectCount();
 
    virtual void DoAnimate(const eC_Value& vTimes = eC_FromInt(1));
 
private:
    void BeginLoop();
 
    void BeginProcess();
 
    void EndLoop();
 
    void StartMeasurementFPS();
 
    void EndMeasurementFPS();
 
    void StartRedraw();
 
    void EndRedraw();
 
    void StartRefresh();
 
    void EndRefresh();
 
    void DisplayInvalidation(const CGUIRect& kRect);
 
    void GetObjectCount(CGUICompositeObject* pkContainer, eC_UInt& ruiCount);
 
private:
    CGUIProfiler();
 
    virtual ~CGUIProfiler();
 
    void Update();
 
    void Draw() const;
 
    void DrawMemoryBar() const;
 
    void ConsoleOutput() const;
 
    void CalcBackRectangle();
 
    FPSCounterID AddCounter(const eC_String& kFPSTextPrefix);
 
    eC_UInt GetFPS(const FPSCounterID& eCounterID = DEFAULT_FPS) const;
 
    void StartMeasurement(const FPSCounterID& eCounterID) const;
 
    void StopMeasurement(const FPSCounterID& eCounterID) const;
 
private:
    class CGUIFramerateCounter
    {
    public:
        CGUIFramerateCounter();
 
        CGUIFramerateCounter(eC_String kFPSTextPrefix);
 
        virtual ~CGUIFramerateCounter();
 
        eC_UInt GetFPS() const;
 
        eC_String GetText() const;
 
        void CountFrame();
 
        void StartMeasurement();
 
        void StopMeasurement();
 
        void Recalculate();
 
    public:
        eC_UInt m_uiFrames; 
        eC_Time64 m_kStartTime; 
        eC_Time64 m_kDeltaTime; 
        eC_UInt m_uiFPS; 
        eC_String m_kFPSTextPrefix; 
        eC_String m_kFPSText; 
    };
 
private:
    void CountFrame(const FPSCounterID& eCounterID) const;
 
    void Calculate();
 
    CGUIFramerateCounter* GetCounter(const FPSCounterID& eCounterID) const;
 
    void CheckUpdateTimer();
 
    void UpdateMemoryValues();
 
    void UpdateObjectCount();
 
private:
    eC_Bool m_bActive;
    eC_Bool m_bDisplayActive;
    eC_Bool m_bConsoleActive;
    eC_Bool m_bCPUProfilingActive;
    eC_Bool m_bMemoryProfilingActive;
    eC_Bool m_bMemoryUsageBarActive;
    eC_Bool m_bGraphicsProfilingActive;
    eC_Bool m_bInvalidationActive;
    eC_Bool m_bFPSActive;
    eC_Bool m_bRuntimeActive;
    eC_Bool m_bObjectCountActive;
 
    eC_UInt m_uiUpdateInterval;
 
    eC_UInt m_uiBackColor;
    eC_UInt m_uiTextColor;
    FontResource_t m_eFontID;
 
    eC_Value m_vPosX;
    eC_Value m_vPosY;
    eC_UInt m_uiLineCount;
    eC_Value m_vLineHeight;
 
    eC_Value m_vMemoryBarPosX;
    eC_Value m_vMemoryBarPosY;
    eC_Value m_vMemoryBarWidth;
    eC_Value m_vMemoryBarHeight;
 
    CGUIRect m_kBackRect;
 
    eC_Time64 m_tLoopBegin;
    eC_Time64 m_tProcessBegin;
 
    eC_UInt m_uiCPUUsage;
    eC_UInt m_uiLastCPUUsage;
    size_t m_tMemoryUsed;
    size_t m_tMemoryUsageWarning;
    size_t m_tMemoryUsageAlert;
    size_t m_tMemoryUsedMax;
    size_t m_tMemoryUsedLargestBlock;
    size_t m_tMemoryNumAllocs;
    eC_UInt m_uiStartRedraw;
    eC_UInt m_uiLastRedraw;
    eC_UInt m_uiDurationRedraw;
    eC_UInt m_uiStartRefresh;
    eC_UInt m_uiLastRefresh;
    eC_UInt m_uiDurationRefresh;
 
    eC_String m_kCPUUsage;
    eC_String m_kMemoryUsed;
    eC_String m_kMemoryMax;
    eC_String m_kMemoryLargestBlock;
    eC_String m_kMemoryNumAllocs;
    eC_String m_kTimeRedraw;
    eC_String m_kTimeRefresh;
    eC_String m_kTimeRuntime;
    eC_String m_kObjectCount;
 
    eC_Value m_vScreenWidth;
    eC_Value m_vScreenHeight;
    eC_Value m_vMemoryUsageCurrent;
    eC_Value m_vMemoryUsageWarning;
    eC_Value m_vMemoryUsageAlert;
    eC_Value m_vMemoryUsageMax;
 
    eC_UInt m_uiObjectCount;
 
    eC_Bool m_bNeedsRedraw;
    eC_Bool m_bRectChanged;
 
    eC_Time64 m_tStartTime;
 
    // FPS
    eC_Time64 m_kInternalTimer;
 
    eC_TListDoubleLinked<CGUIFramerateCounter*> m_kCounterList;
 
    FPSCounterID m_eLastCounterID;
};
 
#endif