gcc: clock() liefert immer 0

[Robert (Gast)]

Hallo an alle,

Um die Zeit zu messen die ein Algorithmus (geschrieben in C) unter gcc 
benötigt wollte ich die Funktion clock() nutzen.

Jeder Aufruf von clock() liefert jedoch 0 zurück. Woran kann das liegen?

Folgendes Minimalbeispiel liefert 0.00 als Laufzeit:

#include <stdio.h>
#include <time.h>
 
int count;
 
int main(void)
{
  clock_t start, stop; 
  start = clock(); 
 
  for(count = 0; count < 1000000; count++);

  stop = clock();
  printf("Runtime %.2f sec\n", (float)(stop - start) / CLOCKS_PER_SEC);
  getchar();
  return 0;
}

Ich hoffe ihr könnt mir helfen.

Danke im Voraus
Robert

[Peter (Gast)]

das wird schon alles stimmen.

Denn das
>  for(count = 0; count < 1000000; count++);
wird er compiler komplett weglassen, weil es nichts sinnvolles macht.

[g457 (Gast)]

..mach mal noch irgendwas(tm) sinnvolles(tm) in der Schleife - bis 1e6 
zählen (so es nicht sowieso wegoptimiert wird) ist für einen heutigen 
Prozessor nun wirklich keine Herausforderung.

[Robert (Gast)]

Gut, gebe ich in jedem Iterationschritt etwas mit printf() aus geht es.

Meine Frage: Warum liefert clock() immer 0 zurück? Auch wenn die 
Schleife wegoptimiert wird, müssten doch Ticks zwischen den beiden 
Funktionsaufrufen vergehen, oder?

[Peter (Gast)]

Robert schrieb:
> Warum liefert clock() immer 0 zurück? Auch wenn die
> Schleife wegoptimiert wird, müssten doch Ticks zwischen den beiden
> Funktionsaufrufen vergehen, oder?
dafür müsste man erstmal wissen auf welchen wert CLOCKS_PER_SEC steht, 
wenn es z.b. nur auf 10 steht, dann kannst du nur bis 10ms auflösen und 
in der Zeit kein eine CPU verdammt viel machen. Selbst wenn es ms sind 
wird es nicht reichen. Die CPU wird nur ein paar µs dafür brauchen.

[Klaus W. (mfgkw)]

Robert schrieb:
> Meine Frage: Warum liefert clock() immer 0 zurück? Auch wenn die
> Schleife wegoptimiert wird, müssten doch Ticks zwischen den beiden
> Funktionsaufrufen vergehen, oder?

nein.
Die Auflösung ist ja nicht beliebig fein.
Wenn weniger Zeit vergeht als 1 sec/CLOCKS_PER_SEC, steht
der Zeitzähler noch auf dem alten Wert 0.

[Klaus W. (mfgkw)]

Peter schrieb:
> wenn es z.b. nur auf 10 steht, dann kannst du nur bis 10ms...

100 ms in diesem Beispiel.

[Peter (Gast)]

Klaus Wachtler schrieb:
> 100 ms in diesem Beispiel.Beitrag melden | Bearbeiten | Löschen |
genau das meinte ich.

Robert schrieb:
> Warum liefert clock() immer 0 zurück?
du weist doch gar nicht was clock zurückliefert, du gibst es überhaupt 
nicht aus. Deine berechnung liefert 0 aber clock kann was anderes 
liefern.

[D. I. (Gast)]

nimm nicht clock() sondern gettimeofday() und timersub()

[Klaus W. (mfgkw)]

Das kommt darauf an, was man eigentlich messen will.
Kalender-/Uhrzeit: gettimeofday
verbrauchte Rechenzeit: clock

Je nach Anzahl Kerne, CPU-Auslastung etc. können da ganz 
unterschiedliche Werte rauskommen.

PS:
Bzw. bei einem Thread ist die Anzahl Kerne natürlich nicht direkt
relevant, außer daß eine Auslastung durch andere Prozesse nicht gleich 
auf die Messung durchschlägt.

[Robert (Gast)]

Klaus Wachtler schrieb:
> Die Auflösung ist ja nicht beliebig fein.
> Wenn weniger Zeit vergeht als 1 sec/CLOCKS_PER_SEC, steht
> der Zeitzähler noch auf dem alten Wert 0.

Danke für die Erklärung.

Gibt es eine Möglichkeit um auch kleine Zeiten zu messen?

[Klaus W. (mfgkw)]

Nicht im Standard.

PS:
Ein portabler Weg ist, das zu messende Programmstück
entsprechend oft laufen zu lassen, bis man etwas vernünftiges
misst, und dann die gemessenen Zeit durch die Anzahl zu teilen.

[Rolf M. (rmagnus)]

Robert schrieb:
> Klaus Wachtler schrieb:
>> Die Auflösung ist ja nicht beliebig fein.
>> Wenn weniger Zeit vergeht als 1 sec/CLOCKS_PER_SEC, steht
>> der Zeitzähler noch auf dem alten Wert 0.
>
> Danke für die Erklärung.
>
> Gibt es eine Möglichkeit um auch kleine Zeiten zu messen?

Je nach Zielprozessor gibt es möglicherweise einen Zähler, der mit 
Prozessortakt läuft.
Für x86 siehe http://en.wikipedia.org/wiki/Time_Stamp_Counter

[(prx) A. K. (prx)]

http://msdn.microsoft.com/en-us/library/aa964692(v=vs.80).aspx
http://lwn.net/Articles/167897/

[Klaus W. (mfgkw)]

Falls gcc: da habe ich mal folgende Funktion gebastelt (wird
als eigener Quelltext assembliert und dann zu einem C-Programm
dazu gelinkt):

#  Time-stamp:  "19.03.04 19:05 getCPUClockCount.s [e-mail]"
#
# Assemblerfunktion für gcc auf i386
#   unsigned long long getCPUClockCount();
# 
# 
# 

        .file  "getCPUClockCount.s"
        .text

.globl getCPUClockCount
  .type  getCPUClockCount, @function

# rdtsc liefert in edx:eax einen 64-Bit-Zähler
# der bisherigen CPU-Takte zurück.
# Das paßt gerade, weil eine long long-Funktion
# ihr Ergebnis in edx (höherwertige 4 Byte) und eax
# (untere 4 Byte) liefern muß.

getCPUClockCount:

# kein Sichern des SP bzw. Anlegen eines Stackframe nötig, weil
# von hier aus nichts mehr aufgerufen wird:
#  pushl  %ebp
#  movl  %esp, %ebp

        rdtsc

# Kein Zurückladen eines Framepointers nötig:
#  popl  %ebp
  ret

  .size  getCPUClockCount, .-getCPUClockCount