HzClock.h

Go to the documentation of this file.

/***********************************************************************************************************************
*                                                                                                                      *
* HzClock (for glscopeclient, et. al.)                                                                                 *
*                                                                                                                      *
* Copyright (c) 2022 Louis A. Goessling                                                                                *
* All rights reserved.                                                                                                 *
*                                                                                                                      *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the     *
* following conditions are met:                                                                                        *
*                                                                                                                      *
*    * Redistributions of source code must retain the above copyright notice, this list of conditions, and the         *
*      following disclaimer.                                                                                           *
*                                                                                                                      *
*    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the       *
*      following disclaimer in the documentation and/or other materials provided with the distribution.                *
*                                                                                                                      *
*    * Neither the name of the author nor the names of any contributors may be used to endorse or promote products     *
*      derived from this software without specific prior written permission.                                           *
*                                                                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL *
* THE AUTHORS BE HELD LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES        *
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR       *
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE       *
* POSSIBILITY OF SUCH DAMAGE.                                                                                          *
*                                                                                                                      *
***********************************************************************************************************************/
 
#ifndef HzClock_h
#define HzClock_h
 
#ifdef _WIN32
#include <windows.h>
#else
#include <time.h>
#endif
 
#include <math.h>
#include <deque>
 
class HzClock
{
public:
    HzClock(int depth = 32)
        : m_depth(depth)
    {
        Reset();
    }
 
    void Reset()
    {
        std::lock_guard<std::mutex> lock(m_mutex);
 
        m_lastMs = GetTime();
 
        m_deltas.clear();
        for (int i = 0; i < m_depth; i++)
        {
            m_deltas.push_back(0);
        }
 
        m_runningAverage = 0;
    }
 
    void Tick()
    {
        std::lock_guard<std::mutex> lock(m_mutex);
 
        uint64_t now = GetTime() * 1000;
        uint64_t delta = now - m_lastMs;
 
        m_lastMs = now;
 
        m_runningAverage -= (double)m_deltas.front() / (double)m_depth;
        m_runningAverage += (double)delta / (double)m_depth;
 
        m_deltas.pop_front();
        m_deltas.push_back(delta);
    }
 
    double GetAverageMs()
    {
        return m_runningAverage;
    }
 
    double GetAverageHz()
    {
        return m_runningAverage==0 ? 0 : 1000./m_runningAverage;
    }
 
    double GetStdDev()
    {
        std::lock_guard<std::mutex> lock(m_mutex);
 
        double dev = 0;
 
        for (auto i : m_deltas)
        {
            dev += pow(i - m_runningAverage, 2);
        }
 
        return sqrt(dev / m_depth);
    }
 
    static double GetTime()
    {
#ifdef _WIN32
        uint64_t tm;
        static uint64_t freq = 0;
        QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(&tm));
        double ret = tm;
        if(freq == 0)
            QueryPerformanceFrequency(reinterpret_cast<LARGE_INTEGER*>(&freq));
        return ret / freq;
#else
        timespec t;
        clock_gettime(CLOCK_REALTIME,&t);
        double d = static_cast<double>(t.tv_nsec) / 1E9f;
        d += t.tv_sec;
        return d;
#endif
    }
 
protected:
    std::mutex m_mutex;
 
    int m_depth;
    uint64_t m_lastMs;
    std::deque<uint64_t> m_deltas;
    double m_runningAverage;
};
 
#endif