// ===========================================================================
//  (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