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

---

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(CString name) : mName(name)
        {
            Clear();
        }

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

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

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

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

    void
    AddGroup(CString name)
    {
        mGroups.push_back(new Group(name));
    }

    void
    AddGroupsFromSub(TimeStats* sub)
    {
        for (int i=0 ; i<sub->NrGroups() ; i++)
            AddGroup(sub->GetGroup(i)->mName);
    }

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

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

    void
    MeasureFromSub(TimeStats* sub)
    {
        mIsTiming = false;
        for (int i=0 ; i<sub->NrGroups() ; i++)
        {
            Group* g = sub->GetGroup(i);
            GetCurrentGroup()->AddMeasurement(g->mTotal);
            SelectGroup(mCurrentGroup + 1);
        }
        sub->Reset();
        StartTime();
    }

    void
    MeasureLast()
    {
        StopTime();
        if (mCurrentGroup != NrGroups() - 1)
            ILOG_ERROR("[MeasureLast] Not at last group");
    }

    void
    Print(std::ostream& os)
    {
        StopTime();
        ComputePercentages();
        os << "timestats: total = " << mGrandTotal << " ("
           << Timer::Format(mGrandTotal) << ") - " << NrGroups() << " groups"
           << std::endl;
        for (int i=0 ; i<NrGroups() ; i++)
        {
            Group* g = mGroups[i];
            int nr = g->mMeasurements.size();
            os << "  " << g->mName << ": " << g->mPercentage << " % = "
               << g->mTotal << " (" << Timer::Format(g->mTotal)
               << ") (avg of " << nr << " is " << g->mTotal/nr << ")"
               << std::endl;
        }
    }

    String
    AsString()
    {
        std::ostringstream oss;
        Print(oss);
        return oss.str();
    }

    int
    NrGroups() const
    {
        return mGroups.size();
    }

    Group*
    GetCurrentGroup()
    {
        return mGroups[mCurrentGroup];
    }

    Group*
    GetGroup(int number)
    {
        return mGroups[number];
    }

    const Group*
    SelectGroup(CString name)
    {
        if (mIsTiming)
            StopTime();
        for (int i=0 ; i<NrGroups() ; i++)
            if (mGroups[i]->mName == name)
                return SelectGroup(i);
        ILOG_ERROR("[SelectGroup} group not found: " << name);
        return 0;
    }

    const Group*
    SelectGroup(int number)
    {
        if (mIsTiming)
            StopTime();
        if (number < NrGroups())
            mCurrentGroup = number;
        else
            ILOG_ERROR("[SelectGroup] no group " << 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<NrGroups() ; i++)
            mGroups[i]->Clear();
    }

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

protected:

    Timer               mClock;
    std::vector<Group*> mGroups;
    int                 mCurrentGroup;
    bool                mIsTiming;
    bool                mRelative;
    double              mGrandTotal; // only valid after ComputePercentages

    ILOG_VAR_DEC;

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

ILOG_VAR_INIT(TimeStats, Impala.Util);

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

}//namespace Util
}//namespace Impala

#endif

---