Added static class PerformanceTimer. Changed CMakeLists for engine to include boost timer. Added F2,F3 functions in editor. Added some timing, more to be added

include/Engine/Core/PerformanceTimer.h

@@ -0,0 +1,36 @@
+#ifndef PerformanceTimer_h__
+#define PerformanceTimer_h__
+
+#include <array>
+#include <GLFW/glfw3.h>
+#include "../Common.h"
+
+#include <boost/timer/timer.hpp>
+using boost::timer::cpu_timer;
+
+class PerformanceTimer
+{
+public:
+    static void StartTimer(std::string nameOfTimer);
+    static void StartTimerAndStopPrevious(std::string nameOfTimer);
+    static void StopTimer(std::string nameOfTimer);
+    static void SetFrameNumber(int frameNumber);
+
+    static void ResetAllTimers();
+    static void CreateExcelData();
+
+    //set timer/start
+    //get performance excel nånting
+
+private:
+    static std::map<std::string, cpu_timer> timers;
+    static double m_TimeElapsed;
+    static cpu_timer m_Timer;
+    static std::string currentTimerRunning;
+    static bool active;
+    //static map
+
+
+};
+
+#endif

include/Engine/Core/SystemPipeline.h

@@ -6,6 +6,7 @@
 #include "System.h"
 #include "World.h"
 #include "EPause.h"
+#include "PerformanceTimer.h"
 
 class SystemPipeline
 {
@@ -72,7 +73,10 @@ public:
 
             // Update
             for (auto& system : group.ImpureSystems) {
+                auto className = (std::string)typeid(*system).name();
+                PerformanceTimer::StartTimer(className);
                 system->Update(dt);
+                PerformanceTimer::StopTimer(className);
             }
             for (auto& pair : group.PureSystems) {
                 const std::string& componentName = pair.first;
@@ -83,7 +87,10 @@ public:
                 }
                 for (auto& component : *pool) {
                     for (auto& system : systems) {
+                        auto className = (std::string)typeid(*system).name();
+                        PerformanceTimer::StartTimer(className);
                         system->UpdateComponent(EntityWrapper(m_World, component.EntityID), component, dt);
+                        PerformanceTimer::StopTimer(className);
                     }
                 }
             }
@@ -106,9 +113,9 @@ private:
     std::vector<UnorderedSystems> m_OrderedSystemGroups;
 
     EventRelay<SystemPipeline, Events::Pause> m_EPause;
-    bool OnPause(const Events::Pause& e) { 
-        if (e.World == m_World) { 
-            m_Paused = true; 
+    bool OnPause(const Events::Pause& e) {
+        if (e.World == m_World) {
+            m_Paused = true;
         }
         return true;
     }

include/Game/Game.h

@@ -35,6 +35,9 @@
 #include "Sound/SoundManager.h"
 #include "Systems/SoundSystem.h"
 
+//Performance 
+#include "Core/PerformanceTimer.h"
+
 class Game
 {
 public:

resources/DefaultInput.ini

@@ -25,4 +25,6 @@ C=ConnectToServer
 N=SwitchToServer
 M=SwitchToClient
 P=SwitchToPlayer
-K=TakeDamage,1500
+K=TakeDamage,1500
+F2=PerformanceTimingResetAllTimers
+F3=PerformanceTimingCreateExcelData

src/Engine/CMakeLists.txt

@@ -3,7 +3,7 @@ project(TacticalZ-Engine)
 find_package(OpenGL REQUIRED)
 find_package(GLEW REQUIRED)
 find_package(GLFW REQUIRED)
-find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono program_options)
+find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono timer program_options)
 find_package(assimp REQUIRED)
 find_package(ZLIB REQUIRED)
 find_package(PNG REQUIRED)

src/Engine/Core/PerformanceTimer.cpp

@@ -0,0 +1,87 @@
+#include "Core/PerformanceTimer.h"
+#include <iostream>
+#include <ctime>
+#include <fstream>
+#include <Windows.h>
+
+cpu_timer PerformanceTimer::m_Timer;
+double PerformanceTimer::m_TimeElapsed;
+std::map<std::string, cpu_timer> PerformanceTimer::timers;
+std::string PerformanceTimer::currentTimerRunning = "";
+
+void PerformanceTimer::StartTimer(std::string nameOfTimer)
+{
+    timers[nameOfTimer].stop();
+    timers[nameOfTimer].start();
+    currentTimerRunning = nameOfTimer;
+}
+
+void PerformanceTimer::StartTimerAndStopPrevious(std::string nameOfTimer)
+{
+    //stop the current timer and start some other - useful to not have to stop timers all the time
+    if (currentTimerRunning != "") {
+        timers[currentTimerRunning].stop();
+    }
+    timers[nameOfTimer].stop();
+    timers[nameOfTimer].start();
+    currentTimerRunning = nameOfTimer;
+}
+
+
+
+void PerformanceTimer::StopTimer(std::string nameOfTimer)
+{
+    timers[nameOfTimer].stop();
+    currentTimerRunning = nameOfTimer;
+}
+
+
+
+void PerformanceTimer::SetFrameNumber(int frameNumber)
+{
+}
+
+void PerformanceTimer::ResetAllTimers()
+{
+    //stop all timers
+    for (auto aTimer : timers)
+    {
+        aTimer.second.stop();
+    }
+    currentTimerRunning = "";
+    timers.clear();
+}
+
+void PerformanceTimer::CreateExcelData()
+{
+    //wall = http://theboostcpplibraries.com/boost.timer
+    //http://www.boost.org/doc/libs/1_48_0/libs/timer/doc/cpu_timers.html
+
+    //get path,time
+    char	Dump_Path[MAX_PATH];
+    GetModuleFileName(NULL, Dump_Path, sizeof(Dump_Path));	//path of current process
+    std::time_t t = std::time(NULL);
+    char tStr[16];
+    std::strftime(tStr, 32, " %a %H-%M-%S", std::localtime(&t));
+    std::string time(tStr);
+    std::string path(Dump_Path);
+    path = path.substr(0, path.length() - 4);
+    path += time + ".xls";
+    std::ofstream someFileStream;
+    someFileStream.open(path, std::ofstream::out);
+    someFileStream << "classname" << ',' << "walltime" << ',' << "userTime" << ',' << "systemTime" << '\n';
+    for (auto aTimer : timers)
+    {
+        //remove the "class" name in front of the string
+        auto className = aTimer.first;
+        if (className.find("class ") != std::string::npos) {
+            className.replace(0, 6, "");
+        }
+        auto wallTime = (double)aTimer.second.elapsed().wall*1e-3;
+        auto userTime = (double)aTimer.second.elapsed().user*1e-3;
+        auto systemTime = (double)aTimer.second.elapsed().system*1e-3;
+
+        someFileStream << className << "," << wallTime << ',' << userTime << ',' << systemTime << '\n';
+    }
+    someFileStream.close();
+}

src/Engine/Editor/EditorSystem.cpp

@@ -223,6 +223,12 @@ bool EditorSystem::OnInputCommand(const Events::InputCommand& e)
             Enable();
         }
     }
+    if (e.Command == "PerformanceTimingResetAllTimers" && e.Value > 0) {
+        PerformanceTimer::ResetAllTimers();
+    }
+    if (e.Command == "PerformanceTimingCreateExcelData" && e.Value > 0) {
+        PerformanceTimer::CreateExcelData();
+    }
     return true;
 }
 

src/Game/Game.cpp

@@ -187,16 +187,20 @@ void Game::Tick()
     // Handle input in a weird looking but responsive way
     m_EventBroker->Process<InputManager>();
     m_EventBroker->Swap();
+    PerformanceTimer::StartTimer("InputManager");
     m_InputManager->Update(dt);
     m_EventBroker->Swap();
+    PerformanceTimer::StartTimerAndStopPrevious("InputProxy");
     m_InputProxy->Update(dt);
     m_EventBroker->Swap();
     m_InputProxy->Process();
     m_EventBroker->Swap();
 
+    PerformanceTimer::StartTimerAndStopPrevious("SoundManager");
     m_SoundManager->Update(dt);
 
     // Update network
+    PerformanceTimer::StartTimerAndStopPrevious("Network");
     m_EventBroker->Process<MultiplayerSnapshotFilter>();
     if (m_NetworkClient != nullptr) {
         m_NetworkClient->Update();
@@ -207,10 +211,14 @@ void Game::Tick()
     //m_SoundManager->Update(dt);
 
     // Iterate through systems and update world!
+    PerformanceTimer::StartTimerAndStopPrevious("SystemPipeline");
     m_EventBroker->Process<SystemPipeline>();
     m_SystemPipeline->Update(dt);
+    PerformanceTimer::StartTimerAndStopPrevious("RendererUpdate");
     m_Renderer->Update(dt);
+    PerformanceTimer::StartTimerAndStopPrevious("RendererDraw");
     m_Renderer->Draw(*m_RenderFrame);
+    PerformanceTimer::StopTimer("RendererDraw");
     m_RenderFrame->Clear();
     m_EventBroker->Swap();
     m_EventBroker->Clear();