source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Timer/RDTSCTimer.cpp @ 2777

// ===========================================================================
//  (C) 1999 Vienna University of Technology
// ===========================================================================
//  NAME:       RDTSCTimer
//  TYPE:       c++ code
//  PROJECT:    Urban Viz/yare (yet another rendering engine)
//  CONTENT:    Very accurate timer for Win32 systems
//                              (uses QueryPerformanceCounter, usually microseconds)
//  VERSION:    0.1
// ===========================================================================
//  AUTHORS:    mw      Michael Wimmer
// ===========================================================================
//  HISTORY:
//
//  15-jul-99 14:00:00  mw      created
// ===========================================================================
//  $Header: /usr/local/cvsyare/cvsyare/src/yareutils/RDTSCTimer.cpp,v 1.2 2005/03/07 17:32:09 wimmer Exp $ 
// ===========================================================================

#ifdef WIN32

#include "RDTSCTimer.h"

#include "merror.h"


// ---------------------------------------------------------------------------
//  class RDTSCTimer implementation
// ---------------------------------------------------------------------------

LARGE_INTEGER RDTSCTimer::frequency = {0,1};
bool RDTSCTimer::isinitialized = false;
bool RDTSCTimer::available = false;

// this retrieves the timer frequency - will be called by constructor
void RDTSCTimer::InitClass(bool verbose)
{
        isinitialized = true;
        available = true;

    if (verbose)
                OUT1(("Calibrating RDTSC-Timer at real-time priority...."));

        // Increase process class
        HANDLE  hProcess = GetCurrentProcess();
        DWORD   iPriorityClass = GetPriorityClass(hProcess);
        ASM_ELSE(iPriorityClass, "couldnt change priority class")
                SetPriorityClass(hProcess, REALTIME_PRIORITY_CLASS);
        
        // Increase thread priority 
        HANDLE  hThread = GetCurrentThread();
        DWORD   iPriority = GetThreadPriority(hThread);
        ASM_ELSE(iPriority != THREAD_PRIORITY_ERROR_RETURN, "couldnt change thread priority")
                SetThreadPriority(hThread, THREAD_PRIORITY_TIME_CRITICAL);
        

        // Measure CPU frequency
        LARGE_INTEGER PerfFreq;
    LARGE_INTEGER  calStart, calEnd;
    LARGE_INTEGER  perfStart, perfEnd;
        
        // warmup
        RDTSC(calStart);
        RDTSC(calStart);
        RDTSC(calStart);

        ASM_RET( QueryPerformanceFrequency( &PerfFreq ), "QueryPerformanceCounter not available for calibrating!");
        QueryPerformanceCounter( &perfStart );
    RDTSC(calStart);
                LARGE_INTEGER endmark; endmark.QuadPart = perfStart.QuadPart + PerfFreq.QuadPart;
                do { 
                        QueryPerformanceCounter( &perfEnd ); 
                } while (perfEnd.QuadPart < endmark.QuadPart);
    RDTSC(calEnd);
    

        // number of Bench cycles counted
        LARGE_INTEGER perfcounts; perfcounts.QuadPart = perfEnd.QuadPart - perfStart.QuadPart;
        // number of RDTSC cycles counted
        LARGE_INTEGER calcounts; calcounts.QuadPart = calEnd.QuadPart - calStart.QuadPart;
        // note: this might overflow if processor is over 6GHz:
        unsigned __int64 temp = calcounts.QuadPart * PerfFreq.QuadPart;
        frequency.QuadPart = temp / perfcounts.QuadPart;

        //if (verbose)
        //      OUT1( SV(perfcounts.LowPart)<<SV(calcounts.LowPart)<<SV(calcounts.HighPart)<<SV(PerfFreq.LowPart));

    //
    // Number of calibration loops
    //
        #define CALIBRATION_LOOPS 50000

        ///--- measure overhead of different calling conventions
        
        ULONG  i;
        
        //-- Start/Elapsed overhead

        RDTSCTimer mytimer2;
    RDTSC(calStart);
        for( i = 0; i < CALIBRATION_LOOPS; i++ ) {
        PERF_ENTRY(mytimer2);
        PERF_EXIT(mytimer2);
    }
    RDTSC(calEnd);

        LARGE_INTEGER   CalEntryExitCycles, CalCountedCycles;
    CalEntryExitCycles.QuadPart = (calEnd.QuadPart - calStart.QuadPart)/CALIBRATION_LOOPS;
        CalCountedCycles.QuadPart = mytimer2.total_count.QuadPart / CALIBRATION_LOOPS;


/*      RDTSCTimer mytimer;
    RDTSC(calStart);
        for( i = 0; i < CALIBRATION_LOOPS; i++ ) {
        mytimer.Start();
        mytimer.Elapsed();
    }
    RDTSC(calEnd);

        LARGE_INTEGER   CalStartElapsedCycles;
    CalStartElapsedCycles.QuadPart = (calEnd.QuadPart - calStart.QuadPart)/CALIBRATION_LOOPS;
    

        RDTSCTimer mytimer3;
    RDTSC(calStart);
        for( i = 0; i < CALIBRATION_LOOPS; i++ ) {
        mytimer3.Entry();
                mytimer3.Exit();
    }
    RDTSC(calEnd);

        LARGE_INTEGER   CalEntryExitCycles2, CalCountedCycles2;
    CalEntryExitCycles2.QuadPart = (calEnd.QuadPart - calStart.QuadPart)/CALIBRATION_LOOPS;
        CalCountedCycles2.QuadPart = mytimer3.total_count.QuadPart / CALIBRATION_LOOPS;
*/

    RDTSC(calStart);
        for( i = 0; i < CALIBRATION_LOOPS; i++ ) {
                QueryPerformanceCounter( &perfStart );
                QueryPerformanceCounter( &perfStart );
    }
    RDTSC(calEnd);

        LARGE_INTEGER   PerfEntryExitCycles;
        PerfEntryExitCycles.QuadPart = (calEnd.QuadPart - calStart.QuadPart)/CALIBRATION_LOOPS;
        
        // Restore thread and process priority 
        if (iPriority != THREAD_PRIORITY_ERROR_RETURN)
                SetThreadPriority(hThread, iPriority);

        if (iPriorityClass)
                SetPriorityClass(hProcess, iPriorityClass);
        

        if (verbose)
        {
                OUT2("RDTSC frequency: " << frequency.LowPart << ", QueryPerformanceCounter frequency: " << PerfFreq.LowPart);
                OUT2("Overhead for timer calls in clock cycles:");
                //OUT2(CalStartElapsedCycles.LowPart << " for timer.start;timer.elapsed;");
                OUT2(CalEntryExitCycles.LowPart << " for PERF_ENTRY/PERF_EXIT, cycles counted per call: " << CalCountedCycles.LowPart);
                //OUT2(CalEntryExitCycles2.LowPart << " for Entry()/Exit(), cycles counted per call: " << CalCountedCycles2.LowPart);
                OUT2(PerfEntryExitCycles.LowPart << " for QueryPerformanceCounter twice");
        }
}

/// returns the frequency
double RDTSCTimer::GetFrequency(bool verbose)
{
        if (!isinitialized)
                InitClass(verbose);
        
        return (double)frequency.QuadPart;
}

#endif // WIN32