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);
}

#ifdef WIN32
	#include <Windows.h>
	class windowsHWTiming
	{
		protected:
			windowsHWTiming(void);
		
		public:
			typedef struct 
			{
			  signed __int64 nTicksCnt;
			} timeType;
		
			inline double diff_ms(timeType& p_start, timeType& p_end)
			{
				return (double(p_end.nTicksCnt-p_start.nTicksCnt)/double(m_TickPerSecond)*1000.);
			};
			
			inline timeType getTime(void)
			{
				timeType res;
				QueryPerformanceCounter((LARGE_INTEGER*)&res.nTicksCnt);
				return res;
			};
	
		private:
			signed __int64 m_TickPerSecond;
	};

	typedef windowsHWTiming HWTiming;

#else
	#include <time.h>
	class LinuxHWTiming {
		protected:
			LinuxHWTiming() {};
			
		public:
			typedef timespec timeType;
			
			// prend le temps exact
			static inline timeType getTime()
			{
				timeType t;
				clock_gettime(CLOCK_REALTIME, &t);
				return t;
			}
			
			// renvoie la difference en ms (milli-secondes)
			static inline double diff_ms(timeType& t1, timeType& t2)
			{
				return ((t2.tv_sec-t1.tv_sec)*1000.0 + (t2.tv_nsec-t1.tv_nsec)/1000000.0); 
			}
	};

	typedef LinuxHWTiming HWTiming;
#endif

#include "HWTiming.h"

#ifdef WIN32

		windowsHWTiming::windowsHWTiming(void)
		{
			 QueryPerformanceFrequency((LARGE_INTEGER*)&m_TickPerSeco nd);
		};
#endif

#ifndef __TIMESTOP_HPP__
#define __TIMESTOP_HPP__

#include <Core/Core.h>

using namespace Upp;

#ifdef PLATFORM_WIN32

class StopWatch : Moveable<StopWatch> {
	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() {
		double time = Elapsed();
		return Format("%d.%03d", int(time / 1000), int(time) % 1000);
	}
	
	void Reset() {
		QueryPerformanceFrequency(&freq);
		QueryPerformanceCounter(&start);
	}

	StopWatch() {
		Reset();
	}
};

#endif

#ifdef PLATFORM_POSIX

#include <time.h>

class StopWatch : Moveable<StopWatch> {
	timespec start;

public:
	double  Elapsed() {
		timespec end;
		clock_gettime(CLOCK_REALTIME, &end);
		
		return (end.tv_sec - start.tv_sec) * 1000.0 + (end.tv_nsec - start.tv_nsec) / 1000000.0;
	}

	double Seconds() {
		return (double)Elapsed() / 1000;
	}
	
	String ToString() {
		double time = Elapsed();
		return Format("%d.%03d", int(time / 1000), int(time) % 1000);
	}
	
	void Reset() {
		clock_gettime(CLOCK_REALTIME, &start);
	}

	StopWatch() {
		Reset();
	}
};

#endif

#endif