class TimeStopHR : Moveable<TimeStopHR> {
	LARGE_INTEGER start;
 	LARGE_INTEGER stop;
 	LARGE_INTEGER freq;

public:
	double  Elapsed() { 
		QueryPerformanceCounter(&stop);
		return (stop.QuadPart - start.QuadPart) * 1000.0 / freq.QuadPart;
	}
	
	double Seconds()                  { return (double)Elapsed() / 1000; }
	String ToString();
	void   Reset();

	TimeStopHR();
	
	static void SetProcessorAffinity();
};

void TimeStopHR::Reset()
{
	QueryPerformanceFrequency(&freq);
	QueryPerformanceCounter(&start);
}

TimeStopHR::TimeStopHR()
{
	Reset();
}

String TimeStopHR::ToString()
{
	double time = Elapsed();
	return Format("%d.%03d", int(time / 1000), int(time) % 1000);
}

void TimeStopHR::SetProcessorAffinity()
{
    // Assign the current thread to one processor. This ensures that timing
    // code runs on only one processor, and will not suffer any ill effects
    // from power management.
    //
    // Based on the DXUTSetProcessorAffinity() function in the DXUT framework.

    DWORD_PTR dwProcessAffinityMask = 0;
    DWORD_PTR dwSystemAffinityMask = 0;
    HANDLE hCurrentProcess = GetCurrentProcess();

    if (!GetProcessAffinityMask(hCurrentProcess, &dwProcessAffinityMask, &dwSystemAffinityMask))
        return;

    if (dwProcessAffinityMask)
    {
        // Find the lowest processor that our process is allowed to run against.

        DWORD_PTR dwAffinityMask = (dwProcessAffinityMask & ((~dwProcessAffinityMask) + 1));

        // Set this as the processor that our thread must always run against.
        // This must be a subset of the process affinity mask.

        HANDLE hCurrentThread = GetCurrentThread();

        if (hCurrentThread != INVALID_HANDLE_VALUE)
        {
            SetThreadAffinityMask(hCurrentThread, dwAffinityMask);
            CloseHandle(hCurrentThread);
        }
    }

    CloseHandle(hCurrentProcess);
}