Pomiar dokładnego czasu działania algorytmu

Cześć, widziałem na forum i w sieci różne metody pomiaru czasu działania algorytmu, ja jednak znalazłem coś takiego:

#include <iostream>
#include <windows.h>

LARGE_INTEGER startTimer()
{
	LARGE_INTEGER start;
	DWORD_PTR oldmask = SetThreadAffinityMask(GetCurrentThread(), 0);
	QueryPerformanceCounter(&start);
	SetThreadAffinityMask(GetCurrentThread(), oldmask);
	return start;
}

LARGE_INTEGER endTimer()
{
	LARGE_INTEGER stop;
	DWORD_PTR oldmask = SetThreadAffinityMask(GetCurrentThread(), 0);
	QueryPerformanceCounter(&stop);
	SetThreadAffinityMask(GetCurrentThread(), oldmask);
	return stop;
}

int main()
{

	LARGE_INTEGER performanceCountStart, performanceCountEnd;
	performanceCountStart = startTimer(); //zapamiętujemy czas początkowy
	int a; std::cin >> a;
    performanceCountEnd =endTimer(); //zapamiętujemy koniec czasu
	double tm = performanceCountEnd.QuadPart -performanceCountStart.QuadPart;
	std::cout << "\n" << "Time:" << tm << "\n";

	system("PAUSE");
}

Mierzymy czasy wykonania w sumie tylko linijki

int a; std::cin >> a;

(tak dla testu). Jednak wyświetlane wyniki pomiaru ze zmiennej tm są w jakby notacji naukowej, nie potrafię tego rozszyfrować. Czy ktoś wie, co to za czas jest w ogóle zwracany? W jakich to jednostkach, czy w jakichś taktach zegara, czy jakichś jednostkach czasowych? Algorytm wydaje się być fajny, jednak natknąłem się na niego w sieci i nie mogę rozszyfrować do końca jak on działa. Swoje pomiary czasu chciałbym mieć w ms, jeśli będzie to sensowna jednostka.
Dzięki za pomoc :).

std::cout.setf(ios::fixed);
std::cout << "\n" << "Time:" << setprecision(6) << tm << "\n";

Tak zrobiłem, dostaję teraz przykładowo czas 1333141098.000000 i w jakich to jest jednostkach?

Podziel przez to to będzie w sekundach:
http://msdn.microsoft.com/en-us/library/windows/desktop/ms644905%28v=vs.85%29.aspx

Więcej info:
http://msdn.microsoft.com/en-us/library/windows/desktop/dn553408%28v=vs.85%29.aspx

Dzięki. Dopisałem to tak:

LARGE_INTEGER performanceCountStart, performanceCountEnd;
	performanceCountStart = startTimer(); //zapamiętujemy czas początkowy
	int a; cin >> a;
    performanceCountEnd =endTimer(); //zapamiętujemy koniec czasu
	LARGE_INTEGER freq;
	QueryPerformanceFrequency(&freq);


	double tm = (performanceCountEnd.QuadPart - performanceCountStart.QuadPart) / freq.QuadPart * 1000;
	cout.setf(ios::fixed);
	cout << "\n" << "Time:" << setprecision(6) << tm << "\n";

No i faktycznie mierzy poprawnie w ms, jednak zwraca tylko wartości np. 2000, 6000, 10000... Nie zwraca jakby tych części ułamkowych. Coś źle rzutuję, niepoprawna konwersja gdzieś zachodzi?

EDIT:
Udało się to uzyskać. Dzielenie przez częstotliwość*1000 zamieściłem dopiero w momencie wyświetlania wyniku:

	LARGE_INTEGER performanceCountStart, performanceCountEnd;
	performanceCountStart = startTimer(); //zapamiętujemy czas początkowy
	int a, b;
	a = 5; b = 3;
	a = a / b;
    performanceCountEnd =endTimer(); //zapamiętujemy koniec czasu

	LARGE_INTEGER freq;
	QueryPerformanceFrequency(&freq); // pobieramy częstotliwość pracy zegara procesora


	double tm = (performanceCountEnd.QuadPart - performanceCountStart.QuadPart);
	cout.setf(ios::fixed); // ustawiamy wyświetlanie z notacji zwykłej (nie naukowej)
	cout << "\n" << "Time:" << setprecision(6) << tm / freq.QuadPart * 1000 << "\n"; //czas wyświetlamy dzieląc wartość tm przez częstotliwość taktowania *1000,
																					 //aby otrzymać wynik w milisekundach