performance_profiler.h

Go to the documentation of this file.

#ifndef YAZE_APP_GFX_PERFORMANCE_PERFORMANCE_PROFILER_H
#define YAZE_APP_GFX_PERFORMANCE_PERFORMANCE_PROFILER_H
 
#include "app/platform/sdl_compat.h"
 
#include <chrono>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace yaze {
namespace gfx {
 
class PerformanceProfiler {
 public:
  static PerformanceProfiler& Get();
 
  static void SetEnabled(bool enabled) { Get().enabled_ = enabled; }
 
  static bool IsEnabled() { return Get().enabled_; }
 
  static bool IsValid() { return !Get().is_shutting_down_; }
 
  void StartTimer(const std::string& operation_name);
 
  void EndTimer(const std::string& operation_name);
 
  struct TimingStats {
    double min_time_us = 0.0;
    double max_time_us = 0.0;
    double avg_time_us = 0.0;
    double median_time_us = 0.0;
    double total_time_ms = 0.0;
    size_t sample_count = 0;
  };
 
  TimingStats GetStats(const std::string& operation_name) const;
 
  std::string GenerateReport(bool log_to_sdl = true) const;
 
  void Clear();
 
  void ClearOperation(const std::string& operation_name);
 
  std::vector<std::string> GetOperationNames() const;
 
  bool IsTiming(const std::string& operation_name) const;
 
  double GetAverageTime(const std::string& operation_name) const;
 
  double GetTotalTime(const std::string& operation_name) const;
 
  int GetOperationCount(const std::string& operation_name) const;
 
  void PrintSummary() const;
 
 private:
  PerformanceProfiler();
 
  using TimePoint = std::chrono::high_resolution_clock::time_point;
  using Duration = std::chrono::microseconds;
 
  std::unordered_map<std::string, TimePoint> active_timers_;
  std::unordered_map<std::string, std::vector<double>> operation_times_;
  std::unordered_map<std::string, double>
      operation_totals_;  // Total time per operation
  std::unordered_map<std::string, int>
      operation_counts_;  // Count per operation
 
  bool enabled_ = true;  // Performance monitoring enabled by default
  bool is_shutting_down_ =
      false;  // Flag to prevent operations during destruction
 
  static double CalculateMedian(std::vector<double> values);
};
 
class ScopedTimer {
 public:
  explicit ScopedTimer(const std::string& operation_name);
  ~ScopedTimer();
 
  // Disable copy and move
  ScopedTimer(const ScopedTimer&) = delete;
  ScopedTimer& operator=(const ScopedTimer&) = delete;
  ScopedTimer(ScopedTimer&&) = delete;
  ScopedTimer& operator=(ScopedTimer&&) = delete;
 
 private:
  std::string operation_name_;
};
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_PERFORMANCE_PERFORMANCE_PROFILER_H