CWE-ou-minkata/Sources/Plasma/NucleusLib/inc/plProfileManager.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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 3 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 <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "plProfileManager.h"
#include "plProfile.h"
#include "hsTimer.h"

#include "hsUtils.h"

static UInt32 gCyclesPerMS = 0;

#ifdef HS_BUILD_FOR_WIN32
#define USE_FAST_TIMER
#endif

#ifdef USE_FAST_TIMER

#pragma warning (push)
#pragma warning (disable : 4035)    // disable no return value warning

__forceinline UInt32 GetPentiumCounter()
{
    __asm
    {
        xor   eax,eax       // VC won't realize that eax is modified w/out this
                            //   instruction to modify the val.
                            //   Problem shows up in release mode builds
        _emit 0x0F          // Pentium high-freq counter to edx;eax
        _emit 0x31          // only care about low 32 bits in eax
        
        xor   edx,edx       // so VC gets that edx is modified
    }
}

#pragma warning (pop)

#include "hsWindows.h"

static UInt32 GetProcSpeed()
{
    const char* keypath[] =
    {
        "HARDWARE",
        "DESCRIPTION",
        "System",
        "CentralProcessor",
        "0"
    };

    HKEY hKey = HKEY_LOCAL_MACHINE;

    int numKeys = sizeof(keypath) / sizeof(char*);
    for (int i = 0; i < numKeys; i++)
    {
        HKEY thisKey = NULL;    
        hsBool success = (RegOpenKeyEx(hKey, keypath[i], 0, KEY_READ, &thisKey) == ERROR_SUCCESS);

        RegCloseKey(hKey);
        hKey = thisKey;

        if (!success)
            return 0;
    }

    DWORD value=0, size=sizeof(DWORD);
    hsBool success = (RegQueryValueEx(hKey, "~MHz", 0, NULL, (BYTE*)&value, &size) == ERROR_SUCCESS);
    RegCloseKey(hKey);

    return value*1000000;
}

UInt32 GetProcSpeedAlt()
{
    const UInt32 kSamplePeriodMS = 250;

    // Raise priority to avoid interference from other threads.
    int priority = GetThreadPriority(GetCurrentThread());
    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

    UInt32 startTicks, endTicks;
    UInt64 pcStart, pcEnd;

    // Count number of processor cycles inside the specified interval
    QueryPerformanceCounter((LARGE_INTEGER*)&pcStart);
    startTicks = plProfileManager::GetTime();
    Sleep(kSamplePeriodMS);
    endTicks = plProfileManager::GetTime();
    QueryPerformanceCounter((LARGE_INTEGER*)&pcEnd);

    // Restore thread priority.
    SetThreadPriority(GetCurrentThread(), priority);

    // Calculate Rdtsc/PerformanceCounter ratio;
    UInt32 numTicks = endTicks - startTicks;
    UInt64 pcDiff = pcEnd - pcStart;

    double ratio = double(numTicks) / double(pcDiff);
    UInt64 pcFreq;
    QueryPerformanceFrequency((LARGE_INTEGER*)&pcFreq);

    // Calculate CPU frequency.
    UInt64 cpuFreq = UInt64(pcFreq * ratio);

    return (UInt32)cpuFreq;
}

#define GetProfileTicks() GetPentiumCounter()

#else

#define GetProfileTicks() hsTimer::GetPrecTickCount()

#endif // USE_FAST_TIMER

#define TicksToMSec(t) (float(t) / float(gCyclesPerMS))
#define MSecToTicks(t) (float(t) * float(gCyclesPerMS))

plProfileManager::plProfileManager() : fLastAvgTime(0), fProcessorSpeed(0)
{
#ifdef USE_FAST_TIMER
    fProcessorSpeed = GetProcSpeed();
    // Registry stuff only works on NT OS's, have to calc it otherwise
    if (fProcessorSpeed == 0)
        fProcessorSpeed = GetProcSpeedAlt();

    gCyclesPerMS = fProcessorSpeed / 1000;
#else
    gCyclesPerMS = hsTimer::GetPrecTicksPerSec() / 1000;
#endif
}

plProfileManager::~plProfileManager()
{
}

plProfileManager& plProfileManager::Instance()
{
    static plProfileManager theInstance;
    return theInstance;
}

void plProfileManager::AddTimer(plProfileVar* var)
{
    fVars.push_back(var);
}

static UInt32 kAvgMilliseconds = 1000;

void plProfileManager::SetAvgTime(UInt32 avgMS)
{
    kAvgMilliseconds = avgMS;
}

static plProfileVar gVarEFPS("EFPS", "General", plProfileVar::kDisplayTime | plProfileVar::kDisplayFPS);

void plProfileManager::BeginFrame()
{
    for (int i = 0; i < fVars.size(); i++)
    {
        fVars[i]->BeginFrame();
        if (fVars[i]->GetLaps())
            fVars[i]->GetLaps()->BeginFrame();
    }

    gVarEFPS.BeginTiming();
}

void plProfileManager::EndFrame()
{
    gVarEFPS.EndTiming();

    hsBool updateAvgs = false;

    // If enough time has passed, update the averages
    double curTime = hsTimer::GetMilliSeconds();
    if (curTime - fLastAvgTime > kAvgMilliseconds)
    {
        fLastAvgTime = curTime;
        updateAvgs = true;
    }

    int i;

    //
    // Update all the variables
    //
    for (i = 0; i < fVars.size(); i++)
    {
        plProfileVar* var = fVars[i];

        if (updateAvgs)
        {
            // Timers that reset at every BeginTiming() call don't want to average over frames
            if (!hsCheckBits(var->GetDisplayFlags(), plProfileBase::kDisplayResetEveryBegin))
            {
                var->UpdateAvg();
                if (var->GetLaps())
                    var->GetLaps()->UpdateAvgs();
            }
        }

        var->EndFrame();

        if (var->GetLaps())
            var->GetLaps()->EndFrame();
    }
}

UInt32 plProfileManager::GetTime()
{
    return GetProfileTicks();
}

///////////////////////////////////////////////////////////////////////////////

plProfileBase::plProfileBase() :
    fName(nil),
    fDisplayFlags(0),
    fValue(0),
    fTimerSamples(0),
    fAvgCount(0),
    fAvgTotal(0),
    fLastAvg(0),
    fMax(0),
    fActive(false),
    fRunning(true)
{
}

plProfileBase::~plProfileBase()
{
}

void plProfileBase::BeginFrame()
{
    if (!hsCheckBits(fDisplayFlags, kDisplayNoReset))
        fValue = 0;
    fTimerSamples = 0;
}

void plProfileBase::EndFrame()
{
    fAvgCount++;
    fAvgTotal += fValue;
    fMax = hsMaximum(fMax, fValue);
}

void plProfileBase::UpdateAvg()
{
    if (fAvgCount > 0)
    {
        fLastAvg = (UInt32)(fAvgTotal / fAvgCount);
        fAvgCount = 0;
        fAvgTotal = 0;
    }
}

UInt32 plProfileBase::GetValue()
{
    if (hsCheckBits(fDisplayFlags, kDisplayTime))
        return (UInt32)TicksToMSec(fValue);
    else
        return fValue;
}

// Stolen from plMemTracker.cpp
static  const char  *insertCommas(unsigned int value)
{
    static char str[30];
    memset(str, 0, sizeof(str));

    sprintf(str, "%u", value);
    if (strlen(str) > 3)
    {
        memmove(&str[strlen(str)-3], &str[strlen(str)-4], 4);
        str[strlen(str) - 4] = ',';
    }
    if (strlen(str) > 7)
    {
        memmove(&str[strlen(str)-7], &str[strlen(str)-8], 8);
        str[strlen(str) - 8] = ',';
    }
    if (strlen(str) > 11)
    {
        memmove(&str[strlen(str)-11], &str[strlen(str)-12], 12);
        str[strlen(str) - 12] = ',';
    }

    return str;
}

void plProfileBase::IPrintValue(UInt32 value, char* buf, hsBool printType)
{
    if (hsCheckBits(fDisplayFlags, kDisplayCount))
    {
        if (printType)
        {
            const char* valueStr = insertCommas(value);
            strcpy(buf, valueStr);
        }
        else
            sprintf(buf, "%u", value);
    }
    else if (hsCheckBits(fDisplayFlags, kDisplayFPS))
    {
        sprintf(buf, "%.1f", 1000.0f / TicksToMSec(value));
    }
    else if (hsCheckBits(fDisplayFlags, kDisplayTime))
    {
        sprintf(buf, "%.1f", TicksToMSec(value));
        if (printType)
            strcat(buf, " ms");
    }
    else if (hsCheckBits(fDisplayFlags, kDisplayMem))
    {
        if (printType)
        {
            if (value > (1024*1000))
                sprintf(buf, "%.1f MB", float(value) / (1024.f * 1024.f));
            else if (value > 1024)
                sprintf(buf, "%d KB", value / 1024);
            else
                sprintf(buf, "%d b", value);
        }
        else
            sprintf(buf, "%u", value);
    }
}

void plProfileBase::PrintValue(char* buf, hsBool printType)
{
    IPrintValue(fValue, buf, printType);
}

void plProfileBase::PrintAvg(char* buf, hsBool printType)
{
    IPrintValue(fLastAvg, buf, printType);
}

void plProfileBase::PrintMax(char* buf, hsBool printType)
{
    IPrintValue(fMax, buf, printType);
}

////////////////////////////////////////////////////////////////////////////////


plProfileLaps::LapInfo* plProfileLaps::IFindLap(const char* lapName)
{
    static int lastSearch = 0;

    int i;
    for (i = lastSearch; i < fLapTimes.size(); i++)
    {
        if(fLapTimes[i].GetName() == lapName)
        {
            lastSearch = i;
            return &fLapTimes[i];
        }
    }

    if(lastSearch > fLapTimes.size()) lastSearch = fLapTimes.size();
    for (i = 0; i < lastSearch; i++)
    {
        if(fLapTimes[i].GetName() == lapName)
        {
            lastSearch = i;
            return &fLapTimes[i];
        }
    }
    return nil;
}

void plProfileLaps::BeginLap(UInt32 curValue, const char* name)
{
    LapInfo* lap = IFindLap(name);
    if (!lap)
    {
        // Technically we shouldn't hold on to this pointer.  However, I think
        // it will be ok in all cases, so I'll wait until this blows up
        LapInfo info(name);
        fLapTimes.push_back(info);
        lap = &(*(fLapTimes.end()-1));
    }

    lap->fUsedThisFrame = true;
    lap->BeginTiming(curValue);
}

void plProfileLaps::EndLap(UInt32 curValue, const char* name)
{
    LapInfo* lap = IFindLap(name);

    // There's a lap timer around the input code. You display it with "Stats.ShowLaps Update Input"
    // Since the command activates the timer INSIDE the lap, the first call to this function fails to
    // find it. (the timer wasn't active when BeginLap was called)
    if (lap)
        lap->EndTiming(curValue);
}

void plProfileLaps::BeginFrame()
{
    for (int i = 0; i < fLapTimes.size(); i++)
    {
        fLapTimes[i].BeginFrame();
        fLapTimes[i].fUsedThisFrame = false;
    }
}

void plProfileLaps::EndFrame()
{
    for (int i = 0; i < fLapTimes.size(); i++)
    {
        fLapTimes[i].EndFrame();
        if (!fLapTimes[i].fUsedThisFrame)
        {
            char buf[200];
            sprintf(buf, "Dropping unused lap %s", fLapTimes[i].GetName());
            hsStatusMessage(buf);
            fLapTimes.erase(fLapTimes.begin()+i);
            i--;
        }
    }
}

void plProfileLaps::UpdateAvgs()
{
    for (int i = 0; i < fLapTimes.size(); i++)
        fLapTimes[i].UpdateAvg();
}

int plProfileLaps::GetNumLaps()
{
//  std::sort(fLapTimes.begin(), fLapTimes.end());
    return fLapTimes.size();
}

plProfileBase* plProfileLaps::GetLap(int i)
{
    return &fLapTimes[i];
}


///////////////////////////////////////////////////////////////////////////////


plProfileVar::plProfileVar(const char *name, const char* group, UInt8 flags) :
    fGroup(group),
    fLaps(nil)
{
    fName = name;
    fDisplayFlags = flags;
    plProfileManager::Instance().AddTimer(this);
    fLapsActive = 0;
}

plProfileVar::~plProfileVar()
{
    delete fLaps;
}

void plProfileVar::IBeginLap(const char* lapName)
{
    if (!fLaps)
        fLaps = TRACKED_NEW plProfileLaps;
    fDisplayFlags |= kDisplayLaps;
    if(fLapsActive)
        fLaps->BeginLap(fValue, lapName);
    BeginTiming();
}

void plProfileVar::IEndLap(const char* lapName)
{
    EndTiming();
    if(fLapsActive)
        fLaps->EndLap(fValue, lapName);
}

void plProfileVar::IBeginTiming()
{
    if( hsCheckBits( fDisplayFlags, kDisplayResetEveryBegin ) )
        fValue = 0;

    fValue -= GetProfileTicks();
}

void plProfileVar::IEndTiming()
{
    fValue += GetProfileTicks();

    fTimerSamples++;

    // If we reset every BeginTiming(), then we want to average all the timing calls
    // independent of framerate
    if (hsCheckBits(fDisplayFlags, plProfileBase::kDisplayResetEveryBegin))
        UpdateAvg();
}