IPS.hpp

Go to the documentation of this file.

 
#ifndef IPS_HPP
#define IPS_HPP
 
#include <algorithm>
#include <chrono>
#include <deque>
 
 
 
class IPS
{
    private:
        // Declare private methods and member variables.
        double m_dCurrentIPS;
        double m_dHighestIPS;
        double m_dLowestIPS;
        double m_d1PercentLow;
        std::deque<double> m_dqIPSHistory;
        std::chrono::high_resolution_clock::time_point m_tLastUpdateTime;
 
        // Define class constants.
        const long unsigned int m_nMaxMetricsHistorySize = 100;
 
 
        void UpdateMetrics()
        {
            // Check highest IPS.
            if (m_dCurrentIPS > m_dHighestIPS)
            {
                // Update new highest.
                m_dHighestIPS = m_dCurrentIPS;
            }
            // Check lowest IPS.
            if (m_dCurrentIPS < m_dLowestIPS)
            {
                // Update new lowest.
                m_dLowestIPS = m_dCurrentIPS;
            }
 
            // Add current IPS to history.
            m_dqIPSHistory.emplace_back(m_dCurrentIPS);
            // Sort the IPS history vector, this allows us to find the 1% low more easily.
            // Throw out oldest element in deque if size is over given number.
            if (m_dqIPSHistory.size() > m_nMaxMetricsHistorySize)
            {
                m_dqIPSHistory.pop_front();
            }
            // Get the index correlating to the IPS number that was lower than 99% of the rest of the IPS history.
            m_d1PercentLow = *std::min_element(m_dqIPSHistory.begin(), m_dqIPSHistory.end());
        }
 
    public:
        // Declare public methods and member variables.
 
        IPS()
        {
            // Initialize member variables and objects.
            m_dCurrentIPS  = 0.0;
            m_dHighestIPS  = 0.0;
            m_dLowestIPS   = 9999999;
            m_d1PercentLow = 0.0;
        }
 
 
        ~IPS()
        {
            // Nothing to destroy.
        }
 
 
        IPS& operator=(const IPS& OtherIPS)
        {
            // Copy values from other IPS object.
            m_dCurrentIPS  = OtherIPS.m_dCurrentIPS;
            m_dHighestIPS  = OtherIPS.m_dHighestIPS;
            m_dLowestIPS   = OtherIPS.m_dLowestIPS;
            m_d1PercentLow = OtherIPS.m_d1PercentLow;
            m_dqIPSHistory = OtherIPS.m_dqIPSHistory;
 
            // Return this object.
            return *this;
        }
 
 
        void Tick()
        {
            // Get the current and elapsed time.
            std::chrono::time_point tCurrentTime = std::chrono::high_resolution_clock::now();
            long int nElapsedTimeSinceLastTick   = std::chrono::duration_cast<std::chrono::microseconds>(tCurrentTime - m_tLastUpdateTime).count();
 
            // Calculate current IPS. 1 second == 1000000 microseconds.
            m_dCurrentIPS = 1e6 / static_cast<double>(nElapsedTimeSinceLastTick);
 
            // Calculate IPS overall stats.
            this->UpdateMetrics();
 
            // Set current time to old.
            m_tLastUpdateTime = tCurrentTime;
        }
 
 
        double GetExactIPS() const
        {
            // Return current iterations per second.
            return m_dCurrentIPS;
        }
 
 
        double GetAverageIPS() const
        {
            // Check if there is any history.
            if (m_dqIPSHistory.empty())
            {
                // Return zero IPS average.
                return 0.0;
            }
 
            // Loop through IPS history and calculate average.
            double dSum = 0.0;
            for (const double dVal : m_dqIPSHistory)
            {
                // Add FPS to total sum.
                dSum += dVal;
            }
 
            // Return calculated average.
            return dSum / static_cast<double>(m_dqIPSHistory.size());
        }
 
 
        double GetHighestIPS() const
        {
            // Return the highest iterations per second.
            return m_dHighestIPS;
        }
 
 
        double GetLowestIPS() const
        {
            // Return the lowest iterations per second.
            return m_dLowestIPS;
        }
 
 
        double Get1PercentLow() const
        {
            // Return the 1% low for IPS.
            return m_d1PercentLow;
        }
 
 
        void Reset()
        {
            // Reset member variable.
            m_dCurrentIPS  = 0.0;
            m_dHighestIPS  = 0.0;
            m_dLowestIPS   = 9999999;
            m_d1PercentLow = 0.0;
            // Reset deque.
            m_dqIPSHistory.clear();
        }
};
#endif