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 <chrono>
#include <string>
#include <unordered_map>
#include <vector>
 
#include <SDL.h>
 
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