llfasttimer.cpp

Go to the documentation of this file.

#include "linden_common.h"

#include "llfasttimer.h"

#include "llprocessor.h"


#if LL_WINDOWS
#elif LL_LINUX || LL_SOLARIS
#include <sys/time.h>
#include <sched.h>
#elif LL_DARWIN
#include <sys/time.h>
#else 
#error "architecture not supported"
#endif

// statics

int LLFastTimer::sCurDepth = 0;
U64 LLFastTimer::sStart[LLFastTimer::FTM_MAX_DEPTH];
U64 LLFastTimer::sCounter[LLFastTimer::FTM_NUM_TYPES];
U64 LLFastTimer::sCountHistory[LLFastTimer::FTM_HISTORY_NUM][LLFastTimer::FTM_NUM_TYPES];
U64 LLFastTimer::sCountAverage[LLFastTimer::FTM_NUM_TYPES];
U64 LLFastTimer::sCalls[LLFastTimer::FTM_NUM_TYPES];
U64 LLFastTimer::sCallHistory[LLFastTimer::FTM_HISTORY_NUM][LLFastTimer::FTM_NUM_TYPES];
U64 LLFastTimer::sCallAverage[LLFastTimer::FTM_NUM_TYPES];
S32 LLFastTimer::sCurFrameIndex = -1;
S32 LLFastTimer::sLastFrameIndex = -1;
int LLFastTimer::sPauseHistory = 0;
int LLFastTimer::sResetHistory = 0;

F64 LLFastTimer::sCPUClockFrequency = 0.0;


//
// CPU clock/other clock frequency and count functions
//

#if LL_WINDOWS

U64 get_cpu_clock_count()
{   U32  hi,lo;

    __asm   
    {
        _emit   0x0f
        _emit   0x31
        mov     lo,eax
        mov     hi,edx
    }

        U64 ret = hi;
        ret *= 4294967296L;
        ret |= lo;
    return ret;
};

#endif // LL_WINDOWS


#if (LL_LINUX || LL_SOLARIS) && (defined(__i386__) || defined(__amd64__))
U64 get_cpu_clock_count()
{
        U64 x;
        __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
        return x;
}
#endif

#if LL_DARWIN || (LL_SOLARIS && defined(__sparc__))
//
// Mac implementation of CPU clock
//
// Just use gettimeofday implementation for now

U64 get_cpu_clock_count()
{
        return get_clock_count();
}
#endif


//static
#if LL_LINUX || LL_DARWIN || LL_SOLARIS
// Both Linux and Mac use gettimeofday for accurate time
U64 LLFastTimer::countsPerSecond()
{
        return 1000000; // microseconds, so 1 Mhz.
}
#else
U64 LLFastTimer::countsPerSecond()
{
        if (!sCPUClockFrequency)
        {
                CProcessor proc;
                sCPUClockFrequency = proc.GetCPUFrequency(50);
        }
        return U64(sCPUClockFrequency);
}
#endif

void LLFastTimer::reset()
{
        countsPerSecond(); // good place to calculate clock frequency
        
        if (sCurDepth != 0)
        {
                llerrs << "LLFastTimer::Reset() when sCurDepth != 0" << llendl;
        }
        if (sPauseHistory)
        {
                sResetHistory = 1;
        }
        else if (sResetHistory)
        {
                sCurFrameIndex = -1;
                sResetHistory = 0;
        }
        else if (sCurFrameIndex >= 0)
        {
                int hidx = sCurFrameIndex % FTM_HISTORY_NUM;
                for (S32 i=0; i<FTM_NUM_TYPES; i++)
                {
                        sCountHistory[hidx][i] = sCounter[i];
                        sCountAverage[i] = (sCountAverage[i]*sCurFrameIndex + sCounter[i]) / (sCurFrameIndex+1);
                        sCallHistory[hidx][i] = sCalls[i];
                        sCallAverage[i] = (sCallAverage[i]*sCurFrameIndex + sCalls[i]) / (sCurFrameIndex+1);
                }
                sLastFrameIndex = sCurFrameIndex;
        }
        else
        {
                for (S32 i=0; i<FTM_NUM_TYPES; i++)
                {
                        sCountAverage[i] = 0;
                        sCallAverage[i] = 0;
                }
        }
        
        sCurFrameIndex++;
        
        for (S32 i=0; i<FTM_NUM_TYPES; i++)
        {
                sCounter[i] = 0;
                sCalls[i] = 0;
        }
        sCurDepth = 0;
}

---