PerformanceMonitor.h

Go to the documentation of this file.

#pragma once
 
#include "Interfaces/ITab.h"
#include "Types/Types.h"
#include <chrono>
#include <deque>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <wx/wx.h>
 
namespace EmberForge {

struct MetricData {
    wxString name;
    std::deque<float> values;
    wxColour color;
    float min_value;
    float max_value;
    float current_value;
    wxString unit;
    size_t max_samples;
 
    MetricData(const wxString &n, const wxColour &c, const wxString &u = "", size_t max_s = 120);
    void AddValue(float value);
    float GetAverage() const;
    void Clear();
};

class PerformanceMonitor {
  public:
    PerformanceMonitor();
    ~PerformanceMonitor();
 
    // Frame timing
    void BeginFrame();
    void EndFrame();
 
    // Custom metrics
    void RecordMetric(const std::string &name, float value, const std::string &unit = "");
    void RecordTime(const std::string &name, double milliseconds);
 
    // System metrics
    void UpdateSystemMetrics();
    float GetCPUUsage() const { return m_cpuUsage; }
    float GetMemoryUsage() const { return m_memoryUsageMB; }
    float GetCurrentFPS() const { return m_currentFPS; }
 
    // Metric access
    std::shared_ptr<MetricData> GetMetric(const std::string &name) const;
    std::vector<std::shared_ptr<MetricData>> GetAllMetrics() const;
 
    // Control
    void SetEnabled(bool enabled) { m_enabled = enabled; }
    bool IsEnabled() const { return m_enabled; }
    void Clear();
 
    // Singleton access
    static PerformanceMonitor &GetInstance();
 
  private:
    void InitializeBuiltInMetrics();
    void UpdateFPS();
    float ReadCPUUsage();
    float ReadMemoryUsage();
 
    // Built-in metrics
    std::shared_ptr<MetricData> m_frameTimeMetric;
    std::shared_ptr<MetricData> m_fpsMetric;
    std::shared_ptr<MetricData> m_cpuMetric;
    std::shared_ptr<MetricData> m_memoryMetric;
 
    // Custom metrics
    std::map<std::string, std::shared_ptr<MetricData>> m_customMetrics;
 
    // Frame timing
    std::chrono::high_resolution_clock::time_point m_frameStart;
    std::chrono::high_resolution_clock::time_point m_lastFrameTime;
    std::deque<float> m_frameTimes;
 
    // System metrics
    float m_cpuUsage;
    float m_memoryUsageMB;
    float m_currentFPS;
 
    // State
    bool m_enabled;
    bool m_frameActive;
 
// Platform-specific data for CPU monitoring
#ifdef __linux__
    unsigned long long m_lastCpuTotal;
    unsigned long long m_lastCpuIdle;
#endif
};

class PerformancePanel : public wxPanel, public ITab {
  public:
    explicit PerformancePanel(wxWindow *parent, PerformanceMonitor *monitor = nullptr);
    virtual ~PerformancePanel();
 
    // ITab interface implementation
    wxWindow *GetWidget() override { return this; }
    wxString GetTitle() const override { return "Performance"; }
    wxString GetTabType() const override { return "Performance"; }
 
    // Monitor management
    void SetMonitor(PerformanceMonitor *monitor);
    PerformanceMonitor *GetMonitor() const { return m_monitor; }
 
    // Display control
    void RefreshDisplay();
    void SetUpdateInterval(int milliseconds);
 
    // Chart toggle control
    void SetChartEnabled(const std::string &chartName, bool enabled);
    bool IsChartEnabled(const std::string &chartName) const;
    void SetAllChartsEnabled(bool enabled);
    std::vector<std::string> GetAvailableCharts() const;
 
  private:
    // UI Creation
    void CreateLayout();
    void CreateToolbar();
    void CreateMetricsDisplay();
    void CreateCharts();
 
    // Event handlers
    void OnUpdateTimer(wxTimerEvent &event);
    void OnPaint(wxPaintEvent &event);
    void OnSize(wxSizeEvent &event);
    void OnToggleMonitoring(wxCommandEvent &event);
    void OnClearMetrics(wxCommandEvent &event);
    void OnExportMetrics(wxCommandEvent &event);
    void OnToggleChart(wxCommandEvent &event);
    void OnHistoryMinus(wxCommandEvent &event);
    void OnHistoryPlus(wxCommandEvent &event);
 
    // Drawing methods
    void DrawChart(wxDC &dc, const wxRect &rect, std::shared_ptr<MetricData> metric);
    void DrawMetricInfo(wxDC &dc, const wxRect &rect, std::shared_ptr<MetricData> metric);
    void DrawGrid(wxDC &dc, const wxRect &rect, float minVal, float maxVal);
 
    // Helper methods
    void UpdateMetricDisplays();
    wxRect GetChartRect(int index, int totalCharts) const;
    wxString FormatValue(float value, const wxString &unit) const;
 
    // UI Components
    wxButton *m_toggleButton;
    wxButton *m_clearButton;
    wxButton *m_exportButton;
    wxStaticText *m_statusText;
    wxPanel *m_chartsPanel;
    wxPanel *m_togglePanel;
 
    // Chart toggle checkboxes
    wxCheckBox *m_frameTimeCheckbox;
    wxCheckBox *m_fpsCheckbox;
    wxCheckBox *m_cpuCheckbox;
    wxCheckBox *m_memoryCheckbox;
 
    // History control
    wxButton *m_historyMinusButton;
    wxStaticText *m_historyText;
    wxButton *m_historyPlusButton;
 
    // State
    PerformanceMonitor *m_monitor;
    wxTimer *m_updateTimer;
    bool m_monitoring;
    int m_chartHistory;
    std::map<std::string, bool> m_chartEnabled;
 
    // Display settings
    int m_chartHeight;
    int m_chartMargin;
    wxFont m_labelFont;
    wxFont m_valueFont;
 
    // Event IDs
    enum {
        ID_UPDATE_TIMER = wxID_HIGHEST + 100,
        ID_TOGGLE_MONITORING,
        ID_CLEAR_METRICS,
        ID_EXPORT_METRICS,
        ID_TOGGLE_FRAME_TIME,
        ID_TOGGLE_FPS,
        ID_TOGGLE_CPU,
        ID_TOGGLE_MEMORY,
        ID_HISTORY_MINUS,
        ID_HISTORY_PLUS
    };
 
    wxDECLARE_EVENT_TABLE();
};
 
// Convenience macros for performance tracking
#define PERF_BEGIN_FRAME() EmberForge::PerformanceMonitor::GetInstance().BeginFrame()
#define PERF_END_FRAME() EmberForge::PerformanceMonitor::GetInstance().EndFrame()
#define PERF_RECORD(name, value, unit) EmberForge::PerformanceMonitor::GetInstance().RecordMetric(name, value, unit)
#define PERF_TIME_BEGIN(name) auto _perf_start_##name = std::chrono::high_resolution_clock::now()
#define PERF_TIME_END(name)                                                                                            \
    EmberForge::PerformanceMonitor::GetInstance().RecordTime(                                                          \
        #name,                                                                                                         \
        std::chrono::duration<double, std::milli>(std::chrono::high_resolution_clock::now() - _perf_start_##name)      \
            .count())
 
} // namespace EmberForge