Dauer einer Schleife messen?

feigling

Unter Linux kannst du mit struct timeval und gettimeofday(); arbeiten

mcr

Hallo,

ich verwende

#include <sys/times.h>
#include <unistd.h>
   struct tms t;
   times(&t);
   usr = (double) (t.tms_utime) / sysconf(_SC_CLK_TCK);
   sys = (double) (t.tms_stime) / sysconf(_SC_CLK_TCK);

um die CPU Zeit zu messen.

times liefert dir die Anzahl der Clock-Ticks von einem
festdefinierten Zeitpunkt in der Vergangenheit zurück.

sysconf(_SC_CLK_TCK) liefert dir die Anzahl der Clock-Ticks
pro Sekunde zurück. Anhand dieses Wertes kannst du die
Genauigkeit ablesen.

Ich bin mir zwar nicht sicher, und bevor ich noch Schelte
von anderen Usern bekomme, diese Möglichkeit ist schon
ein wenig veraltet. Ich habe aber bisher nichts besseres
gefunden.

Gruß mcr

lord_fritte

Danke, versuche ich mal.

CStoll

Wenn du etwas OS-unabhängiges bevorzugst, nimm lieber man: clock() - das liefert die Zeit seit Programmstart in Clock-Ticks (Umrechnungsfaktor CLOCKS_PER_SEC).

lord_fritte

ist CLOCKS_PER_SEC systemabhängig? Weil laut cout ist CLOCKS_PER_SEC = 1000;
also könnte man sich das ja sparen und direkt 1000 hinschreiben?

Th

Ja, CLOCK_PER_SECS ist systemabhängig (nämlich von der Implementation von clock()).
Und sog. Magic-Numbers sollte man nicht im Programm haben (denn wenn du den Ausdruck einfach durch 1000 ersetzt, weißt du vllt. in ein paar Monaten bzw. wenn jemand anders den Source liest, nicht mehr, was diese Zahl bedeuten soll).

lord_fritte

Unter Visual C++ funktioniert es nicht.
bsp:

clock_t = timer;
...
clock_t timer = clock();
schleife{
..
}
printf("Dauer: %d\n", clock() - timer);

Da kommt 0 raus.
Weil in timer und clock() immer das selbe steckt.

lord_fritte schrieb:

Da kommt 0 raus.
Weil in timer und clock() immer das selbe steckt.

entweder deine clock läuft nicht (gibt immer -1 zurück), oder deine schleife ist zu schnell (ruf den code ca. 10000 mal auf).

lord_fritte

Stimmt die Schleife ist zu schnell, kann man eigentlich auch irgendwie in nano sekunden zählen?

lord_fritte schrieb:

Stimmt die Schleife ist zu schnell, kann man eigentlich auch irgendwie in nano sekunden zählen?

au 'ne X86 gurke?
--> http://pasta.east.isi.edu/algorithms/IntegerMath/Timers/rdtscpm1.pdf

lord_fritte

hmm verstehe ich nicht.

lord_fritte

Das ist echt zu unzuverlässig,
ich habe jetzt das:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    unsigned int time;
    __asm rdtsc // Read time stamp to EAX
    __asm mov time, eax

    _sleep (3000); // Sleep for n/1000 seconds

    __asm rdtsc
    __asm sub eax, time // Find the difference
    __asm mov time, eax

	time = time / 2700000000;
    printf("Seconds: %u\n", time);
	system("pause");
	return 0;
}

bei 3000 in Sleep ist die Ausgabe: 1
bei 1000, 2000 und 5000: 0

Also es kommt nie was richtiges raus.

lord_fritte schrieb:

Das ist echt zu unzuverlässig,

kann nicht sein. du machst irgendwas falsch.
was ist mit EDX?
--> http://en.wikipedia.org/wiki/RDTSC

lord_fritte

Hm ne geht irgendwie auch nicht.

lord_fritte schrieb:

Hm ne geht irgendwie auch nicht.

geht schon, steht doch alles in dem pdf.
du bist einfach nur zu blöd dazu

Badestrand

Ist rdtsc nicht falsch, wenn zwischendurch der Thread wechselt?

desgamfelix

Diese Variante geht nur mit Intel CPUs und nur wenn der Thread nicht wechselt.
Es gibt jedoch eine einfachere und zuverlässigere Methode, den Performance Counter. Dieser zählt die CPU-Tackte seit systemstart, jedoch AUßERHALB der CPU. Dadurch ist er Threadunabhängig. Mit den Funktionen QueryPerformanceCounter und QueryPerformanceFrequency kannst du die Zahl der CPU Tackte seit Systemstart und die Zahl der CPU-Tackte pro Sekunde berechnen.
Dieser Code lässt sich jedoch nur unter Windows benutzen.

#include <windows.h>

int main()
{
LONGLONG llFrequency = 0;
double   dFrequency = 0.0;
LONGLONG llStartTime = 0;
LONGLONG llEndTime = 0;
double   dTime = 0.0;

// Frequenz abfragen (letztendlich die Hz deiner CPU)
QueryPerformanceFrequency((LARGE_INTEGER*)(&llFrequency));
dFrequency = (double)llFrequency;

// Startzeit messen
QueryPerformanceCounter((LARGE_INTEGER*)(&llStartTime));

// Hier führst du deine Schleife aus

// Endzeit messen
QueryPerformanceCounter((LARGE_INTEGER*)(&llEndTime));

// Millisekunden berechnen
dTime = ((double)(llEndTime - llStartTime) / (dFrequency * 0.001));

// Ausgabe
printf("Vergangene Zeit: %.8f ms", dTime);

return 0;
}

Kolumbus

Hallo,

ich bin mir nicht sicher, ob es wirklich angebracht ist; vielleicht ja auch zu altertümlich:
Ich arbeite mit "einfachen" Prozessoren (µController). Wenn ich genauer wissen muss, wie lange ein Programmteil läuft mache ich Folgendes:

1. Den Prozessortaktfrequenz herausfinden und Taktdauer berechen. Dabei reicht oft der theoretische Wert.
1b. Wieviele Takte beinhaltet ein Taktzyklus des jeweiligen Geräts. (zZ. arbeite ich zB mit µControllern, die 6 oder 12 Takte je Zyklus unterstützen)

2. Herausfinden, wieviele Taktzyklen die einzelnen Befehle des Programmteils zur Abarbeitung benötigen.
2b. Optional einbeziehen, wie oft eine Schleife durchlaufen wird.

3. Taktdauer * Takte pro Zyklus * Anzahl der Taktzyklen (* Durchläufe) = Laufzeit des Programm(teil)s

Ist natürlich mit Aufwand verbunden Nur so als Anregung

Kolumbus schrieb:

ich bin mir nicht sicher, ob es wirklich angebracht ist; vielleicht ja auch zu altertümlich:
Ich arbeite mit "einfachen" Prozessoren (µController). Wenn ich genauer wissen muss, wie lange ein Programmteil läuft mache ich Folgendes:
...

eigentlich macht der µC-bastler das so:
1. GPIO togglen
2. oszi dranhalten
3. fertich.
wenn's ganz genau sein soll kann man ja noch die laufzeiten der asm-befehle abziehen, die den portpin schalten

Kolumbus

gibt's ja gar nicht schrieb:

eigentlich macht der µC-bastler das so:
1. GPIO togglen
2. oszi dranhalten
...

Schlaumeier! Was hälst du jetzt ran, wenn Du kein Oszi hast?

Oder wolltest Du mir ein Oszi stiften?