IProfiler.h

Go to the documentation of this file.

// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
// Written by Michael Zeilfelder

#ifndef __I_PROFILER_H_INCLUDED__
#define __I_PROFILER_H_INCLUDED__

#include "IrrCompileConfig.h"
#include "irrString.h"
#include "irrArray.h"
#include "ITimer.h"
#include <limits.h>     // for INT_MAX (we should have a S32_MAX...)

namespace irr
{

class ITimer;

struct SProfileData
{
        friend class IProfiler;

    SProfileData()
        {
                GroupIndex = 0;
                reset();
        }

        bool operator<(const SProfileData& pd) const
        {
                return Id < pd.Id;
        }

        bool operator==(const SProfileData& pd) const
        {
                return Id == pd.Id;
        }

        u32 getGroupIndex() const
        {
                return GroupIndex;
        }

        const core::stringw& getName() const
        {
                return Name;
        }

        u32 getCallsCounter() const
        {
                return CountCalls;
        }

        u32 getLongestTime() const
        {
                return LongestTime;
        }

        u32 getTimeSum() const
        {
                return TimeSum;
        }

private:

        // just to be used for searching as it does no initialization besides id
        SProfileData(u32 id) : Id(id) {}

        void reset()
        {
                CountCalls = 0;
                LongestTime = 0;
                TimeSum = 0;
                LastTimeStarted = 0;
                StartStopCounter = 0;
        }

        s32 Id;
    u32 GroupIndex;
        core::stringw Name;

        s32 StartStopCounter; // 0 means stopped > 0 means it runs.
    u32 CountCalls;
    u32 LongestTime;
    u32 TimeSum;

    u32 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 Irrlicht 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(s32 id, const core::stringw &name, const core::stringw &groupName);


    inline s32 add(const core::stringw &name, const core::stringw &groupName);

    u32 getProfileDataCount() const
    {
                return ProfileDatas.size();
    }


        inline bool findDataIndex(u32 & result, const core::stringw &name) const;


    const SProfileData& getProfileDataByIndex(u32 index) const
    {
                return ProfileDatas[index];
    }


    inline const SProfileData* getProfileDataById(u32 id);


    inline u32 getGroupCount() const
    {
                return ProfileGroups.size();
    }


    inline const SProfileData& getGroupData(u32 index) const
    {
                return ProfileGroups[index];
    }


        inline bool findGroupIndex(u32 & result, const core::stringw &name) const;



        inline void start(s32 id);


    inline void stop(s32 id);

    inline void resetDataById(s32 id);

    inline void resetDataByIndex(u32 index);

    inline void resetGroup(u32 index);


    inline void resetAll();


    virtual void printAll(core::stringw &result, bool includeOverview=false,bool suppressUncalled=true) const = 0;


    virtual void printGroup(core::stringw &result, u32 groupIndex, bool suppressUncalled) const = 0;

protected:

    inline u32 addGroup(const core::stringw &name);

        // I would prefer using os::Timer, but os.h is not in the public interface so far.
        // Timer must be initialized by the implementation.
    ITimer * Timer;
        core::array<SProfileData> ProfileDatas;
    core::array<SProfileData> ProfileGroups;

private:
    s32 NextAutoId;     // for giving out id's automatically
};


IRRLICHT_API IProfiler& IRRCALLCONV getProfiler();


class CProfileScope
{
public:

        CProfileScope(s32 id)
        : Id(id), Profiler(getProfiler())
        {
                Profiler.start(Id);
        }


        CProfileScope(s32 id, const core::stringw &name, const core::stringw &groupName)
        : Id(id), Profiler(getProfiler())
        {
                Profiler.add(Id, name, groupName);
                Profiler.start(Id);
        }


        CProfileScope(const core::stringw &name, const core::stringw &groupName)
        : Profiler(getProfiler())
        {
                Id = Profiler.add(name, groupName);
                Profiler.start(Id);
        }

        ~CProfileScope()
        {
                Profiler.stop(Id);
        }

protected:
        s32 Id;
        IProfiler& Profiler;
};


// IMPLEMENTATION for in-line stuff

void IProfiler::start(s32 id)
{
        s32 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(s32 id)
{
        if ( Timer )
        {
                u32 timeNow = Timer->getRealTime();
                s32 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;
                                u32 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;
                        }
                }
        }
}

s32 IProfiler::add(const core::stringw &name, const core::stringw &groupName)
{
        u32 index;
        if ( findDataIndex(index, name) )
        {
                add( ProfileDatas[index].Id, name, groupName );
                return ProfileDatas[index].Id;
        }
        else
        {
                s32 id = NextAutoId;
                --NextAutoId;
                add( id, name, groupName );
                return id;
        }
}

void IProfiler::add(s32 id, const core::stringw &name, const core::stringw &groupName)
{
        u32 groupIdx;
        if ( !findGroupIndex(groupIdx, groupName) )
        {
                groupIdx = addGroup(groupName);
        }

        SProfileData data(id);
        s32 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 CProfileScope would become tricky.
                if ( groupIdx != ProfileDatas[idx].GroupIndex )
                {
                        resetDataByIndex((u32)idx);
                        ProfileDatas[idx].GroupIndex = groupIdx;
                }
                ProfileDatas[idx].Name = name;
        }
}

u32 IProfiler::addGroup(const core::stringw &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(u32 & result, const core::stringw &name) const
{
        for ( u32 i=0; i < ProfileDatas.size(); ++i )
        {
                if ( ProfileDatas[i].Name == name )
                {
                        result = i;
                        return true;
                }
        }

        return false;
}

const SProfileData* IProfiler::getProfileDataById(u32 id)
{
        SProfileData data(id);
    s32 idx = ProfileDatas.binary_search(data);
        if ( idx >= 0 )
                return &ProfileDatas[idx];
        return NULL;
}

bool IProfiler::findGroupIndex(u32 & result, const core::stringw &name) const
{
        for ( u32 i=0; i < ProfileGroups.size(); ++i )
        {
                if ( ProfileGroups[i].Name == name )
                {
                        result = i;
                        return true;
                }
        }

        return false;
}

void IProfiler::resetDataById(s32 id)
{
        s32 idx = ProfileDatas.binary_search(SProfileData(id));
    if ( idx >= 0 )
    {
                resetDataByIndex((u32)idx);
    }
}

void IProfiler::resetDataByIndex(u32 index)
{
        SProfileData &data = ProfileDatas[index];

        SProfileData & group = ProfileGroups[data.GroupIndex];
        group.CountCalls -= data.CountCalls;
        group.TimeSum -= data.TimeSum;

        data.reset();
}

void IProfiler::resetGroup(u32 index)
{
        for ( u32 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 ( u32 i=0; i<ProfileDatas.size(); ++i )
    {
                ProfileDatas[i].reset();
    }

        for ( u32 i=0; i<ProfileGroups.size(); ++i )
    {
                ProfileGroups[i].reset();
    }
}

#ifdef _IRR_COMPILE_WITH_PROFILING_
        #define IRR_PROFILE(X) X
#else
        #define IRR_PROFILE(X)
#endif // IRR_PROFILE

} // namespace irr

#endif // __I_PROFILER_H_INCLUDED__