Tidstagning i C++

time_t t1 = time(NULL);
...
time_t t2 = time(NULL);

og så brug difftime(t2, t1)

#include <time.h>

eller

#include <ctime>

Man kan måske opnå større nøjagtighed med clock:

#include <time.h>
#include <iostream>

int main()
{
  clock_t Start = clock();
  std::cout << "Hit Enter at any time" << std::endl;
  std::cin.get();
  clock_t End = clock();

  std::cout << "You waited: " << (End - Start)/CLOCKS_PER_SEC << " Seconds" << std::endl;
}

Er det ikke godt nok, og bruger du windows kan du bruge QueryPerformanceCounter sammen med QueryPerformanceFrequency

clock og time maaler noget forskelligt

clock maaler CPU time

time maaler wall time

for en CPU intensiv operation er de typisk ret ens

men for at laese fra en COM port vil jeg forvente at de er meget forskellige

Havde glemt den "feature" ved clock :-(

En løsning med QueryPerformanceCounter:

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

int main(void)
{
  LARGE_INTEGER Freq;
  LARGE_INTEGER Start;
  QueryPerformanceFrequency(&Freq);
  QueryPerformanceCounter(&Start);
  std::cout << "Hit Enter at any time" << std::endl;
  std::cin.get();
  LARGE_INTEGER End;
  QueryPerformanceCounter(&End);

  std::cout << "You waited: " << double(End.QuadPart - Start.QuadPart)/Freq.QuadPart << " Seconds" << std::endl;
}

Problemet er lidt, at den skal tælle mere nøjagtigt en sekunder.. Den skal faktisk ned og tælle i millisekunder! Vi har et input af der, der bliver gemt i et array. Timeren skal starte, når det første tal skrives til arrayet og stoppe, når det sidste tal er lagret. Håber, det er til at forstå :)

så skal du over i noget platform/compiler specifikt

Unix/Linux : gettimeofday

Windows : GetLocalTime (eller Bertels QueryPerformance functions)

QueryPerformanceCounter kan let måle i milisekunder, på min PC er frekvensen 3579545, dvs ca 280 nano sekunder/tick.

Du kan bruge:

  std::cout << "You waited: " << double(End.QuadPart - Start.QuadPart)*1000/Freq.QuadPart << " Millisekunder" << std::endl;

bertelbrander >> Det bliver jo ikke mere præcist af, at du ganger tllet med 1000.. Så vil du bare få værdierne 1000, 2000, 3000, 4000 osv. Du vil aldrig kunne få den til at vise 2384 for eksempel.

Nej, den bliver ikke mere nøjagtig af at man ganger med 1000, resultatet bliver blot vist i ms i stedet for sekunder.

Men den har en opløsning der er meget bedre end millisekunder, så den kan godt måle 2384 ms.

Den skriver ikke bare 1000, 2000, 3000, 4000 osv. Det ville den gøre hvis Freq.QuadPart var 1, men den er mange gange større, som jeg skrev er den 3579545 på min PC.

Den skriver resultatet som en double.

Prøv en gang at køre koden og se hvad den skriver.

Undskyld ventetiden! Kigger på det 1st thing i morgen :D

Hvis jeg var dig så ville jeg bruge CPUens Time Stamp Counter (TSC). Du får ikke tiden i sekunder, men i clock cycler. Om du kan bruge det i stedet ved jeg ikke, men hvis ikke kan du altid omregne det til tid senere.

For at læse TSC skal du ned i assembly code:

unsigned __int64 tsc;
__asm {
rdtsc        ; Read Time Stamp Counter (value stored in EDX:EAX)
mov DWORD PTR[tsc], eax
mov DWORD PTR[tsc+4], edx
}

Denne metode er uafhængig af styresystemet og du kan ikke komme i nærheden af samme præcision med nogle af de andre forslag.

Note: Du skal være sikker på at CPUen understøtter 'rdtsc' instructionen (det gør alle AMD CPUer i Athlon familien og alle Intel CPUer fra Pentium af) samt at fx. styresystemet ikke har lavet restriktioner på brugen af instructionen (som default gør windows ikke).

Forresten, jeg glemte lige at sige noget.

rdtsc instructionen bliver ikke automatisk serialized. Dvs. at hvis du skal være sikker på at rdtsc ikke "overhaler" andre instructioner i CPUens pipeline, så skal du først eksekvere en serialiserende instruction som fx 'cpuid':
__asm {
cpuid
rdtsc        ; Read Time Stamp Counter (value stored in EDX:EAX)
mov DWORD PTR[tsc], eax
mov DWORD PTR[tsc+4], edx
}

Jeg tvivler på at du har brug for at regne så præcist, men man ved jo aldrig...

hvordan reagerer TSC naar en Pentium M skruer ned for frekvensen for at spare stroem ?

Den giver det samme resultat. Det er jo clock >frekvensen< der justeres. Antallet af clocks ændres ikke.

Men hvis man selv finder frekvensen og skal omregne clocks til tid, så skal man selvfølgelig tage højde for ændringer i frekvensen - hvis det sker, det kommer jo an på systemet.

Tid at få afsluttet her ?

problemet blev løst lidt alternativt, men smid nogle svar, så kan i dele point

ok

og hvordan løste du så problemet?

Jeg skal faktisk ikke kunne sige, hvad det endte med.. Det var til et skole-projekt, og det var ikke lige mig, der stod for C++-delen.. Jeg forsøgte bare at hjælpe dem :)