IProfiler.hpp

// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in duckcpp/duckcpp.hpp
// Written by Michael Zeilfelder
 
#ifndef DCPP_I_PROFILER_HPP_INCLUDED
#define DCPP_I_PROFILER_HPP_INCLUDED
 
#include <duckcpp/core/engine/DcppCompileConfig.hpp>
#include <duckcpp/core/engine/irrString.hpp>
#include <duckcpp/core/engine/irrArray.hpp>
#include <duckcpp/core/engine/ITimer.hpp>
#include <limits.h> // for INT_MAX (we should have a INT32_MAX...)
 
namespace dcpp
{
 
class ITimer;
 
class SProfileData
{
public:
    friend class IProfiler;
 
public:
    SProfileData()
    {
        GroupIndex = 0;
        reset();
    }
 
public:
    bool operator<(const SProfileData& pd) const
    {
        return Id < pd.Id;
    }
 
    bool operator==(const SProfileData& pd) const
    {
        return Id == pd.Id;
    }
 
    dcpp::uint32_kt getGroupIndex() const
    {
        return GroupIndex;
    }
 
    const dcpp::nub::wstring& getName() const
    {
        return Name;
    }
 
    dcpp::uint32_kt getCallsCounter() const
    {
        return CountCalls;
    }
 
    dcpp::uint32_kt getLongestTime() const
    {
        return LongestTime;
    }
 
    dcpp::uint32_kt getTimeSum() const
    {
        return TimeSum;
    }
 
private:
 
    // just to be used for searching as it does no initialization besides id
    SProfileData(dcpp::uint32_kt id) : Id(id) {}
 
    void reset()
    {
        CountCalls = 0;
        LongestTime = 0;
        TimeSum = 0;
        LastTimeStarted = 0;
        StartStopCounter = 0;
    }
 
    dcpp::int32_kt Id;
    dcpp::uint32_kt GroupIndex;
    dcpp::nub::wstring Name;
 
    dcpp::int32_kt StartStopCounter; // 0 means stopped > 0 means it runs.
    dcpp::uint32_kt CountCalls;
    dcpp::uint32_kt LongestTime;
    dcpp::uint32_kt TimeSum;
 
    dcpp::uint32_kt LastTimeStarted;
};
 
// Implementer notes:
// The design is all about allowing to use the central start/stop mechanism with minimal time overhead.
// This is why the class works without a virtual functions interface contrary to the usual Duckcpp design.
// And also why it works with id's instead of strings in the start/stop functions even if it makes using
// the class slightly harder.
// The class comes without reference-counting because the profiler instance is never released (TBD).
class IProfiler
{
public:
    IProfiler() : Timer(0), NextAutoId(INT_MAX)
    {}
 
    virtual ~IProfiler()
    {}
 
 
    inline void add(dcpp::int32_kt id, const dcpp::nub::wstring &name, const dcpp::nub::wstring &groupName);
 
 
    inline dcpp::int32_kt add(const dcpp::nub::wstring &name, const dcpp::nub::wstring &groupName);
 
    dcpp::uint32_kt getProfileDataCount() const
    {
        return ProfileDatas.size();
    }
 
 
    inline bool findDataIndex(dcpp::uint32_kt & result, const dcpp::nub::wstring &name) const;
 
 
    const SProfileData& getProfileDataByIndex(dcpp::uint32_kt index) const
    {
        return ProfileDatas[index];
    }
 
 
    inline const SProfileData* getProfileDataById(dcpp::uint32_kt id);
 
 
    inline dcpp::uint32_kt getGroupCount() const
    {
        return ProfileGroups.size();
    }
 
 
    inline const SProfileData& getGroupData(dcpp::uint32_kt index) const
    {
        return ProfileGroups[index];
    }
 
 
    inline bool findGroupIndex(dcpp::uint32_kt & result, const dcpp::nub::wstring &name) const;
 
 
 
    inline void start(dcpp::int32_kt id);
 
 
    inline void stop(dcpp::int32_kt id);
 
    inline void resetDataById(dcpp::int32_kt id);
 
    inline void resetDataByIndex(dcpp::uint32_kt index);
 
    inline void resetGroup(dcpp::uint32_kt index);
 
 
    inline void resetAll();
 
 
    virtual void printAll(dcpp::nub::wstring &result, bool includeOverview=false,bool suppressUncalled=true) const = 0;
 
 
    virtual void printGroup(dcpp::nub::wstring &result, dcpp::uint32_kt groupIndex, bool suppressUncalled) const = 0;
 
protected:
 
    inline dcpp::uint32_kt addGroup(const dcpp::nub::wstring &name);
 
    // I would prefer using dcpp::os::Timer, but os.h is not in the public interface so far.
    // Timer must be initialized by the implementation.
    ITimer * Timer;
    dcpp::nub::array<SProfileData> ProfileDatas;
    dcpp::nub::array<SProfileData> ProfileGroups;
 
private:
    dcpp::int32_kt NextAutoId;  // for giving out id's automatically
};
 
 
DUCKCPP_API IProfiler& IRRCALLCONV getProfiler();
 
 
class PProfileScope
{
public:
 
    PProfileScope(dcpp::int32_kt id)
    : Id(id), Profiler(getProfiler())
    {
        Profiler.start(Id);
    }
 
 
    PProfileScope(dcpp::int32_kt id, const dcpp::nub::wstring &name, const dcpp::nub::wstring &groupName)
    : Id(id), Profiler(getProfiler())
    {
        Profiler.add(Id, name, groupName);
        Profiler.start(Id);
    }
 
 
    PProfileScope(const dcpp::nub::wstring &name, const dcpp::nub::wstring &groupName)
    : Profiler(getProfiler())
    {
        Id = Profiler.add(name, groupName);
        Profiler.start(Id);
    }
 
    ~PProfileScope()
    {
        Profiler.stop(Id);
    }
 
protected:
    dcpp::int32_kt Id;
    IProfiler& Profiler;
};
 
 
// IMPLEMENTATION for in-line stuff
 
void IProfiler::start(dcpp::int32_kt id)
{
    dcpp::int32_kt idx = ProfileDatas.binary_search(SProfileData(id));
    if ( idx >= 0 && Timer )
    {
        ++ProfileDatas[idx].StartStopCounter;
        if (ProfileDatas[idx].StartStopCounter == 1 )
            ProfileDatas[idx].LastTimeStarted = Timer->getRealTime();
    }
}
 
void IProfiler::stop(dcpp::int32_kt id)
{
    if ( Timer )
    {
        const dcpp::uint32_kt timeNow = Timer->getRealTime();
        const dcpp::int32_kt idx = ProfileDatas.binary_search(SProfileData(id));
        if ( idx >= 0 )
        {
            SProfileData &data = ProfileDatas[idx];
            --ProfileDatas[idx].StartStopCounter;
            if ( data.LastTimeStarted != 0 && ProfileDatas[idx].StartStopCounter == 0)
            {
                // update data for this id
                ++data.CountCalls;
                const dcpp::uint32_kt diffTime = timeNow - data.LastTimeStarted;
                data.TimeSum += diffTime;
                if ( diffTime > data.LongestTime )
                    data.LongestTime = diffTime;
                data.LastTimeStarted = 0;
 
                // update data of it's group
                SProfileData & group = ProfileGroups[data.GroupIndex];
                ++group.CountCalls;
                group.TimeSum += diffTime;
                if ( diffTime > group.LongestTime )
                    group.LongestTime = diffTime;
                group.LastTimeStarted = 0;
            }
            else if ( ProfileDatas[idx].StartStopCounter < 0 )
            {
                // ignore additional stop calls
                ProfileDatas[idx].StartStopCounter = 0;
            }
        }
    }
}
 
dcpp::int32_kt IProfiler::add(const dcpp::nub::wstring &name, const dcpp::nub::wstring &groupName)
{
    dcpp::uint32_kt index;
    if ( findDataIndex(index, name) )
    {
        add( ProfileDatas[index].Id, name, groupName );
        return ProfileDatas[index].Id;
    }
    else
    {
        const dcpp::int32_kt id = NextAutoId;
        --NextAutoId;
        add( id, name, groupName );
        return id;
    }
}
 
void IProfiler::add(dcpp::int32_kt id, const dcpp::nub::wstring &name, const dcpp::nub::wstring &groupName)
{
    dcpp::uint32_kt groupIdx;
    if ( !findGroupIndex(groupIdx, groupName) )
    {
        groupIdx = addGroup(groupName);
    }
 
    SProfileData data(id);
    dcpp::int32_kt idx = ProfileDatas.binary_search(data);
    if ( idx < 0 )
    {
        data.reset();
        data.GroupIndex = groupIdx;
        data.Name = name;
 
        ProfileDatas.push_back(data);
        ProfileDatas.sort();
    }
    else
    {
        // only reset on group changes, otherwise we want to keep the data or coding PProfileScope would become tricky.
        if ( groupIdx != ProfileDatas[idx].GroupIndex )
        {
            resetDataByIndex((dcpp::uint32_kt)idx);
            ProfileDatas[idx].GroupIndex = groupIdx;
        }
        ProfileDatas[idx].Name = name;
    }
}
 
dcpp::uint32_kt IProfiler::addGroup(const dcpp::nub::wstring &name)
{
    SProfileData group;
    group.Id = -1;  // Id for groups doesn't matter so far
    group.Name = name;
    ProfileGroups.push_back(group);
    return ProfileGroups.size()-1;
}
 
bool IProfiler::findDataIndex(dcpp::uint32_kt & result, const dcpp::nub::wstring &name) const
{
    for ( dcpp::uint32_kt i=0; i < ProfileDatas.size(); ++i )
    {
        if ( ProfileDatas[i].Name == name )
        {
            result = i;
            return true;
        }
    }
 
    return false;
}
 
const SProfileData* IProfiler::getProfileDataById(dcpp::uint32_kt id)
{
    SProfileData data(id);
    const dcpp::int32_kt idx = ProfileDatas.binary_search(data);
    if ( idx >= 0 )
        return &ProfileDatas[idx];
    return NULL;
}
 
bool IProfiler::findGroupIndex(dcpp::uint32_kt & result, const dcpp::nub::wstring &name) const
{
    for ( dcpp::uint32_kt i=0; i < ProfileGroups.size(); ++i )
    {
        if ( ProfileGroups[i].Name == name )
        {
            result = i;
            return true;
        }
    }
 
    return false;
}
 
void IProfiler::resetDataById(dcpp::int32_kt id)
{
    dcpp::int32_kt idx = ProfileDatas.binary_search(SProfileData(id));
    if ( idx >= 0 )
    {
        resetDataByIndex((dcpp::uint32_kt)idx);
    }
}
 
void IProfiler::resetDataByIndex(dcpp::uint32_kt index)
{
    SProfileData &data = ProfileDatas[index];
 
    SProfileData & group = ProfileGroups[data.GroupIndex];
    group.CountCalls -= data.CountCalls;
    group.TimeSum -= data.TimeSum;
 
    data.reset();
}
 
void IProfiler::resetGroup(dcpp::uint32_kt index)
{
    for ( dcpp::uint32_kt i=0; i<ProfileDatas.size(); ++i )
    {
        if ( ProfileDatas[i].GroupIndex == index )
            ProfileDatas[i].reset();
    }
    if ( index < ProfileGroups.size() )
        ProfileGroups[index].reset();
}
 
void IProfiler::resetAll()
{
    for ( dcpp::uint32_kt i=0; i<ProfileDatas.size(); ++i )
    {
        ProfileDatas[i].reset();
    }
 
    for ( dcpp::uint32_kt i=0; i<ProfileGroups.size(); ++i )
    {
        ProfileGroups[i].reset();
    }
}
 
#ifdef _DCPP_COMPILE_WITH_PROFILING_
    #define DCPP_PROFILE(X) X
#else
    #define DCPP_PROFILE(X)
#endif // DCPP_PROFILE
 
} // namespace dcpp
 
#endif // DCPP_I_PROFILER_HPP_INCLUDED