Branch data     Line data    Source code

       1                 :             : #ifndef RATEMONITOR_H
       2                 :             : #define RATEMONITOR_H
       3                 :             : 
       4                 :             : #include <chrono>
       5                 :             : #include <atomic>
       6                 :             : #include "../utils/TimeUtils.h"
       7                 :             : 
       8                 :             : /**
       9                 :             :  * @brief Simple utility to monitor event frequency (Hz) over a 1-second sliding window.
      10                 :             :  */
      11                 :             : class RateMonitor {
      12                 :             : public:
      13                 :         301 :     RateMonitor() : m_count(0), m_lastRateScaled(0) {
      14                 :         301 :         m_startTime = TimeUtils::GetTime();
      15                 :         301 :     }
      16                 :             : 
      17                 :             :     /**
      18                 :             :      * @brief Record a single event occurrence.
      19                 :             :      */
      20                 :       12107 :     void RecordEvent() {
      21                 :       12107 :         RecordEventAt(TimeUtils::GetTime());
      22                 :       12107 :     }
      23                 :             : 
      24                 :             :     /**
      25                 :             :      * @brief Record an event at a specific time (useful for testing).
      26                 :             :      */
      27                 :       12615 :     void RecordEventAt(std::chrono::steady_clock::time_point now) {
      28                 :       12615 :         m_count++;
      29   [ +  -  +  - ]:       12615 :         auto duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_startTime).count();
      30                 :             : 
      31                 :             :         // Update rate every second
      32         [ +  + ]:       12615 :         if (duration_ms >= 1000) {
      33                 :          26 :             long count = m_count.exchange(0);
      34                 :          26 :             double rate = (double)count * 1000.0 / (double)duration_ms;
      35                 :          26 :             m_lastRateScaled.store((long)(rate * 100.0));
      36                 :          26 :             m_startTime = now;
      37                 :             :         }
      38                 :       12615 :     }
      39                 :             : 
      40                 :             :     /**
      41                 :             :      * @brief Get the last calculated rate in Hz.
      42                 :             :      */
      43                 :       60113 :     double GetRate() const {
      44                 :      120226 :         return (double)m_lastRateScaled.load() / 100.0;
      45                 :             :     }
      46                 :             : 
      47                 :             : private:
      48                 :             :     std::atomic<long> m_count;
      49                 :             :     std::chrono::steady_clock::time_point m_startTime;
      50                 :             :     std::atomic<long> m_lastRateScaled; // Rate multiplied by 100 for atomic storage
      51                 :             : };
      52                 :             : 
      53                 :             : #endif // RATEMONITOR_H