profile.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2013 CERN
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 * @author Tomasz Wlostowski <[email protected]>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

 
#ifndef TPROFILE_H
#define TPROFILE_H
 
#include <atomic>
#include <chrono>
#include <sstream>
#include <string>
#include <iostream>
#include <iomanip>
#include <cstdint>
#include <vector>

class PROF_TIMER
{
public:
    PROF_TIMER( const std::string& aName, bool aAutostart = true ) :
        m_name( aName ), m_running( false )
    {
        if( aAutostart )
            Start();
    }

    PROF_TIMER()
    {
        Start();
    }

    void Start()
    {
        m_started = true;
        m_running = true;
        m_starttime = CLOCK::now();
        m_lasttime = m_starttime;
    }
 

    void Stop()
    {
        if( !m_running )
            return;
 
        m_stoptime = CLOCK::now();
        m_running = false;
    }

    void Show( std::ostream& aStream = std::cerr )
    {
        using DURATION = std::chrono::duration<double, std::nano>;
 
        const auto   duration = SinceStart<DURATION>();
        const double cnt = duration.count();
 
        if( m_name.size() )
        {
            aStream << m_name << " took ";
        }
 
        if( cnt < 1e3 )
            aStream << cnt << "ns";
        else if( cnt < 1e6 )
            aStream << ( cnt / 1e3 ) << "µs";
        else if( cnt < 1e9 )
            aStream << ( cnt / 1e6 ) << "ms";
        else
            aStream << ( cnt / 1e9 ) << "s";
 
        aStream << std::endl;
    }

    template <typename DURATION>
    DURATION SinceStart( bool aSinceLast = false )
    {
        const TIME_POINT stoptime = m_running ? CLOCK::now() : m_stoptime;
        const TIME_POINT starttime = aSinceLast ? m_lasttime : m_starttime;
 
        m_lasttime = stoptime;
 
        return std::chrono::duration_cast<DURATION>( stoptime - starttime );
    }

    double msecs( bool aSinceLast = false )
    {
        using DUR_MS = std::chrono::duration<double, std::milli>;
        return SinceStart<DUR_MS>( aSinceLast ).count();
    }
 
    std::string to_string()
    {
        using DURATION = std::chrono::duration<double, std::nano>;
 
        const auto   duration = SinceStart<DURATION>();
        const double cnt = duration.count();
        std::string retv;
 
        if( !m_name.empty() )
            retv = m_name + ": ";
 
        if( !m_started )
        {
            retv += "none";
            return retv;
        }
 
        std::stringstream time;
 
        if( cnt < 1e3 )
            time << cnt << "ns";
        else if( cnt < 1e6 )
            time << ( cnt / 1e3 ) << "µs";
        else if( cnt < 1e9 )
            time << ( cnt / 1e6 ) << "ms";
        else
            time << ( cnt / 1e9 ) << "s";
 
        retv += time.str();
 
        return retv;
    }
 
    const std::string& GetName() const { return m_name; }
 
private:
    std::string m_name;     // a string printed in message
    bool m_running;
    bool m_started;
 
    using CLOCK = std::chrono::high_resolution_clock;
    using TIME_POINT = std::chrono::time_point<CLOCK>;
 
    TIME_POINT m_starttime, m_lasttime, m_stoptime;
};
 

template <typename DURATION>
class SCOPED_PROF_TIMER : public PROF_TIMER
{
public:
    SCOPED_PROF_TIMER( DURATION& aDuration ) : PROF_TIMER(), m_duration( aDuration )
    {
    }
 
    ~SCOPED_PROF_TIMER()
    {
        // update the output
        m_duration = m_counter.SinceStart<DURATION>();
    }
 
private:
    PROF_TIMER m_counter;

    DURATION& m_duration;
};
 

int64_t GetRunningMicroSecs();
 

class PROF_COUNTER
{
public:
    PROF_COUNTER() :
            m_name( "Anonymous" ),
            m_count( 0 )
    {
    }
 
    PROF_COUNTER( const std::string& aName ) :
            m_name( aName ),
            m_count( 0 )
    {
    }
 
    unsigned long long Count() const
    {
        return m_count.load();
    }
 
    void Reset()
    {
        m_count.store( 0 );
    }
 
    unsigned long long operator++( int )
    {
        return m_count++;
    }
 
    void Show( std::ostream& aStream = std::cerr )
    {
        if( m_name.size() )
            aStream << m_name << ": ";
 
        aStream << m_count.load();
        aStream << std::endl;
    }
 
private:
    std::string        m_name;
    std::atomic_ullong m_count;
};
 
class LATENCY_PROBE
{
    public:
        using CLOCK = std::chrono::high_resolution_clock;
        using TIME_POINT = std::chrono::time_point<CLOCK>;
 
        struct CHECKPOINT
        {
            std::string name;
            TIME_POINT timestamp;
            bool isTimer = false;
            double timerDelta = 0;
        };
 
        LATENCY_PROBE( const std::string& aName, int aStages = 8 ) : 
            m_name( aName )
        {
            m_checkpoints.reserve( aStages );
        }
 
        void Reset()
        {
            m_start = CLOCK::now();
            m_checkpoints.clear();
        }
 
        void Checkpoint( const std::string& aName )
        {
            CHECKPOINT chk;
            chk.name = aName;
            chk.timestamp = CLOCK::now();
            m_checkpoints.push_back( chk );
        }
 
        void AddTimer( PROF_TIMER& aTimer )
        {
            CHECKPOINT chk;
            chk.name = aTimer.GetName();
            chk.isTimer = true;
            chk.timerDelta = aTimer.msecs();
            m_checkpoints.push_back( chk );
        }
 
        std::string to_string();
 
        double delta_ms( TIME_POINT a, TIME_POINT b )
        {
            using DUR_MS = std::chrono::duration<double, std::milli>;
            return static_cast<DUR_MS>( a - b ).count();
        }
    
    private:
        
        TIME_POINT m_start;
        std::string m_name;
        std::vector<CHECKPOINT> m_checkpoints;
};
 
#endif  // TPROFILE_H