imstkTimer.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#pragma once
#include <chrono>
#include <ctime>
#include <memory>
#include <string>
#include <vector>

namespace imstk
{
class StopWatch
{
public:
    static const double wcTimerConstants[4];

    enum class TimerState
    {
        started,
        stopped
    };

    enum class TimeUnitType
    {
        milliSeconds,
        seconds,
        minutes,
        hours
    };

    StopWatch() : state(TimerState::stopped) {};
    ~StopWatch() = default;

public:
    virtual void start();

    virtual void stop();

    void storeLap(std::string const& lapName);
    void storeLap();

    void printLapTimes();

    virtual void reset();

    double getTotalLapTimes();

    virtual double getTimeElapsed(const TimeUnitType unitType = TimeUnitType::milliSeconds);

    static std::string getTimeAndDate();

    void printTimeElapsed(std::string const& name = std::string("noName"), const TimeUnitType unitType = TimeUnitType::milliSeconds);
private:
    TimerState state;
    std::vector<double>      lapTimes;
    std::vector<std::string> lapNames;
    std::chrono::high_resolution_clock::time_point wallClockTimeKeeper; 
};

class CpuTimer : public StopWatch
{
public:
    static const double cpuTimerConstants[4];

    CpuTimer() : StopWatch(), cpuTimeKeeper(std::clock_t()) {};

    ~CpuTimer() = default;

    virtual void start() override { cpuTimeKeeper = std::clock(); };

    double getTimeElapsed(const TimeUnitType unitType = TimeUnitType::milliSeconds) override;

private:
    std::clock_t cpuTimeKeeper; 
};

class UPSCounter
{
public:
    UPSCounter() :  m_timer(std::make_shared<StopWatch>()),
        m_accumulatedTimer(0.),
        m_ups(0),
        m_updateCount(0) {};

    ~UPSCounter() = default;

    void reset();

    void setStartPointOfUpdate() { m_timer->start(); }

    void setEndPointOfUpdate();

    unsigned int getUPS() const { return m_ups; }

protected:

    std::shared_ptr<StopWatch> m_timer; 

    double       m_accumulatedTimer;    
    unsigned int m_ups;                 
    unsigned int m_updateCount;         
};
} // namespace imstk