|| || || || || || || ||

---

TimeStats.h

Go to the documentation of this file.

#ifndef Impala_Util_TimeStats_h
#define Impala_Util_TimeStats_h

#include <vector>
#include "Basis/Timer.h"


namespace Impala
{
namespace Util
{


class TimeStats
{
public:
    class Group
    {
    public:
        Group(const std::string& name) 
            :mName(name) 
        {
            Clear();
        }

        void AddMeasurement(double time)
        {
            mMeasurements.push_back(time);
            mTotal += time;
        }

        void Clear()
        {
            mTotal = 0;
            mMeasurements.clear();
        }

        std::string mName;
        std::vector<double> mMeasurements;
        double mTotal;
        double mPercentage; // warning: only computed when ComputePercentages of the TimeStats object is called
    };

    TimeStats(bool relative=false)
        :mClock(1)
    {
        mIsTiming = false;
        mCurrentGroup = 0;
        mRelative = relative;
    }

    void AddGroup(const std::string& name)
    {
        mGroups.push_back(new Group(name));
    }

    void MeasureFirst()
    {
        StopTime();
        SelectGroup(0);
        StartTime();
    }

    void MeasureNext()
    {
        StopTime();
        SelectGroup(mCurrentGroup + 1);
        StartTime();
    }

    void Print(std::ostream& os)
    {
        StopTime();
        ComputePercentages();
        os << "timestats - " << mGroups.size() << " groups\n";
        for(int i=0 ; i<mGroups.size() ; i++)
        {
            Group* g = mGroups[i];
            os << "  " << g->mName << ": " << g->mPercentage << "% = " << g->mTotal << " (avrg. " << g->mTotal/g->mMeasurements.size() << ")\n";
        }
        os << std::endl;
    }

    Group* GetCurrentGroup()
    {
        return mGroups[mCurrentGroup];
    }
    
    const Group* SelectGroup(const std::string& name)
    {
        if(mIsTiming)
            StopTime();
        for(int i=0 ; i<mGroups.size() ; i++)
            if(mGroups[i]->mName == name)
                return SelectGroup(i);
    }

    const Group* SelectGroup(int number)
    {
        if(mIsTiming)
            StopTime();
        if(number < mGroups.size())
            mCurrentGroup = number;
        return GetCurrentGroup();
    }

    void StartTime()
    {
        mIsTiming = true;
        mClock.Start();
    }

    void StopTime()
    {
        if(mIsTiming)
            GetCurrentGroup()->AddMeasurement(mClock.Stop());
        mIsTiming = false;
    }

    void Reset()
    {
        if(mIsTiming)
            StopTime();
        for(int i=0 ; i<mGroups.size() ; i++)
            mGroups[i]->Clear();
    }

    void ComputePercentages()
    {
        double total = 0;
        int i;
        if(mRelative)
            total = mGroups[0]->mTotal;
        else
            for(i=0 ; i<mGroups.size() ; i++)
                total += mGroups[i]->mTotal;
        for(i=0 ; i<mGroups.size() ; i++)
            mGroups[i]->mPercentage = 100. * mGroups[i]->mTotal / total;
    }

protected:
    Timer mClock;
    std::vector<Group*> mGroups;
    int mCurrentGroup;
    bool mIsTiming;
    bool mRelative;

    friend std::ostream& operator<< (std::ostream& os, TimeStats& stats);
};

std::ostream& operator<< (std::ostream& os, TimeStats& stats)
{
    stats.Print(os);
    return os;
}

}//namespace Util
}//namespace Impala

#endif

---