Performance counters

2 files changed, 117 insertions, 0 deletions

diff --git a/src/app/app.cpp b/src/app/app.cpp
index 4af3870..823bc77 100644
--- a/src/app/app.cpp
+++ b/src/app/app.cpp
@@ -122,6 +122,12 @@ CApplication::CApplication()
     m_curTimeStamp = CreateTimeStamp();
     m_lastTimeStamp = CreateTimeStamp();
 
+    for (int i = 0; i < PCNT_MAX; ++i)
+    {
+        m_performanceCounters[i][0] = CreateTimeStamp();
+        m_performanceCounters[i][1] = CreateTimeStamp();
+    }
+
     m_joystickEnabled = false;
 
     m_mouseMode = MOUSE_SYSTEM;
@@ -171,6 +177,12 @@ CApplication::~CApplication()
     DestroyTimeStamp(m_baseTimeStamp);
     DestroyTimeStamp(m_curTimeStamp);
     DestroyTimeStamp(m_lastTimeStamp);
+
+    for (int i = 0; i < PCNT_MAX; ++i)
+    {
+        DestroyTimeStamp(m_performanceCounters[i][0]);
+        DestroyTimeStamp(m_performanceCounters[i][1]);
+    }
 }
 
 ParseArgsStatus CApplication::ParseArguments(int argc, char *argv[])
@@ -718,6 +730,14 @@ int CApplication::Run()
 
     while (true)
     {
+        ResetPerformanceCounters();
+
+        if (m_active)
+        {
+            StartPerformanceCounter(PCNT_ALL);
+            StartPerformanceCounter(PCNT_EVENT_PROCESSING);
+        }
+
         // To be sure no old event remains
         m_private->currentEvent.type = SDL_NOEVENT;
 
@@ -829,21 +849,38 @@ int CApplication::Run()
                     m_robotMain->EventProcess(event);
             }
 
+            StopPerformanceCounter(PCNT_EVENT_PROCESSING);
+
+            StartPerformanceCounter(PCNT_UPDATE_ALL);
+
             // Prepare and process step simulation event
             event = CreateUpdateEvent();
             if (event.type != EVENT_NULL && m_robotMain != nullptr)
             {
+                StartPerformanceCounter(PCNT_UPDATE_ENGINE);
                 m_engine->FrameUpdate();
+                StopPerformanceCounter(PCNT_UPDATE_ENGINE);
+
                 m_sound->FrameMove(m_relTime);
 
+                StartPerformanceCounter(PCNT_UPDATE_GAME);
                 m_robotMain->EventProcess(event);
+                StopPerformanceCounter(PCNT_UPDATE_GAME);
             }
 
+            StopPerformanceCounter(PCNT_UPDATE_ALL);
+
             /* Update mouse position explicitly right before rendering
              * because mouse events are usually way behind */
             UpdateMouse();
 
+            StartPerformanceCounter(PCNT_RENDER_ALL);
             Render();
+            StopPerformanceCounter(PCNT_RENDER_ALL);
+
+            StopPerformanceCounter(PCNT_ALL);
+
+            UpdatePerformanceCountersData();
 
             if (m_lowCPU)
             {
@@ -1451,3 +1488,43 @@ bool CApplication::GetLowCPU()
 {
     return m_lowCPU;
 }
+
+void CApplication::StartPerformanceCounter(PerformanceCounter counter)
+{
+    GetCurrentTimeStamp(m_performanceCounters[counter][0]);
+}
+
+void CApplication::StopPerformanceCounter(PerformanceCounter counter)
+{
+    GetCurrentTimeStamp(m_performanceCounters[counter][1]);
+}
+
+float CApplication::GetPerformanceCounterData(PerformanceCounter counter)
+{
+    return m_performanceCountersData[counter];
+}
+
+void CApplication::ResetPerformanceCounters()
+{
+    for (int i = 0; i < PCNT_MAX; ++i)
+    {
+        StartPerformanceCounter(static_cast<PerformanceCounter>(i));
+        StopPerformanceCounter(static_cast<PerformanceCounter>(i));
+    }
+}
+
+void CApplication::UpdatePerformanceCountersData()
+{
+    long long sum = TimeStampExactDiff(m_performanceCounters[PCNT_ALL][0],
+                                       m_performanceCounters[PCNT_ALL][1]);
+
+    for (int i = 0; i < PCNT_MAX; ++i)
+    {
+        long long diff = TimeStampExactDiff(m_performanceCounters[i][0],
+                                            m_performanceCounters[i][1]);
+
+        m_performanceCountersData[static_cast<PerformanceCounter>(i)] =
+            static_cast<float>(diff) / static_cast<float>(sum);
+    }
+}
+
diff --git a/src/app/app.h b/src/app/app.h
index 66b5848..84da0eb 100644
--- a/src/app/app.h
+++ b/src/app/app.h
@@ -113,6 +113,31 @@ enum MouseMode
     MOUSE_NONE,   //! < no cursor visible
 };
 
+/**
+ * \enum PerformanceCounter
+ * \brief Type of counter testing performance
+ */
+enum PerformanceCounter
+{
+    PCNT_EVENT_PROCESSING, //! < event processing (except update events)
+
+    PCNT_UPDATE_ALL,            //! < the whole frame update process
+    PCNT_UPDATE_ENGINE,         //! < frame update in CEngine
+    PCNT_UPDATE_PARTICLE,       //! < frame update in CParticle
+    PCNT_UPDATE_GAME,           //! < frame update in CRobotMain
+
+    PCNT_RENDER_ALL,            //! < the whole rendering process
+    PCNT_RENDER_PARTICLE,       //! < rendering the particles in 3D
+    PCNT_RENDER_WATER,          //! < rendering the water
+    PCNT_RENDER_TERRAIN,        //! < rendering the terrain
+    PCNT_RENDER_OBJECTS,        //! < rendering the 3D objects
+    PCNT_RENDER_INTERFACE,      //! < rendering 2D interface
+
+    PCNT_ALL,                   //! < all counters together
+
+    PCNT_MAX
+};
+
 struct ApplicationPrivate;
 
 /**
@@ -301,6 +326,13 @@ public:
     bool        GetLowCPU();
     //@}
 
+    //! Management of performance counters
+    //@{
+    void        StartPerformanceCounter(PerformanceCounter counter);
+    void        StopPerformanceCounter(PerformanceCounter counter);
+    float       GetPerformanceCounterData(PerformanceCounter counter);
+    //@}
+
 protected:
     //! Creates the window's SDL_Surface
     bool CreateVideoSurface();
@@ -321,6 +353,11 @@ protected:
     //! Closes the joystick device
     void CloseJoystick();
 
+    //! Resets all performance counters to zero
+    void ResetPerformanceCounters();
+    //! Updates performance counters from gathered timer data
+    void UpdatePerformanceCountersData();
+
 protected:
     //! Instance manager
     CInstanceManager*       m_iMan;
@@ -363,6 +400,9 @@ protected:
     SystemTimeStamp* m_lastTimeStamp;
     SystemTimeStamp* m_curTimeStamp;
 
+    SystemTimeStamp* m_performanceCounters[PCNT_MAX][2];
+    float            m_performanceCountersData[PCNT_MAX];
+
     long long       m_realAbsTimeBase;
     long long       m_realAbsTime;
     long long       m_realRelTime;