gcc time.h Laufzeit eines Programmteils ermitteln

[chris_ (Gast)]

Hallo Zusammen,

ich habe folgenden Programmcode:

 uint32_t updateSysCounter()
 {
   static uint8_t theFirstTime=true;
   clock_t start, end;
   double tmp;

   if(theFirstTime)
   {
     start=clock();
     theFirstTime=false;
     tmp=0;
   }else
   {
     end=clock();
     tmp=difftime(end,start)/ CLOCKS_PER_SEC;
   }

   return tmp;
 }

Irgendwie scheint sich meine Zeitmessung nicht zu bewegen. Hat jemand 
eine Ahnung, woran das liegen könnte?

Die

[Peter II (Gast)]

lass dir doch mal start und end anzeigen.

chris_ schrieb:
> difftime(end,start)

bin mir nicht sicher ob difftime hier das richtige ist. Ich würde 
einfach selber die Differenz berechnen. (ende-start)

[Klaus (Gast)]

Obwohl die Auflösung von clock() feiner ist, ist die Genauigkeit häufig 
nur die eines Systemticks. Versuch mal längere Zeiten zu messen.

MfG Klaus

[g457 (Gast)]

> tmp=difftime(end,start)/ CLOCKS_PER_SEC;

..liefert difftime() nicht schon (die Differenz in) Sekunden?

[Kaj (Gast)]

Hast du mal ein bisschen mehr Code? Wird die Funktion updateSysCounter 
in ner Schleife aufgerufen? die Funktion alleine reicht nicht um dir zu 
helfen.

Ohne mehr Code würde ich sagen es liegt an der Struktur:
Du startest die Messung im if-Zweig und beendest sie im else-Zweig.
Wenn die Funktion kein zweitesmal aufgerufen wird, gelangst du aber 
niemals in den else-zweig.

chris_ schrieb:
> static uint8_t theFirstTime=true;
Wenn du dem Ding schon einen boolschen wert zuweist, dann nimm verdammt 
nochmal auch bool als Datentyp!

[Läubi .. (laeubi)]

chris_ schrieb:
> clock_t start, end;

zumindest start solltest du als static deklarieren. Ansonsten ist deine 
Funktion unnötig komplex und wieso du einen double wert nutzt um in dann 
als uint32 (wieviele Millarden Jahre Laufzeit erwartest du eigentlich) 
zurückgibst solltest du auch nochmal überdenken.

uint32_t updateSysCounter() {
   static clock_t start;
   if(start){
       return difftime(clock(),start) / CLOCKS_PER_SEC;
   } else {
       start=clock();
   }
}

[chris_ (Gast)]

Leider bewegt sich die Uhr immer noch keinen Millimeter.
>Hast du mal ein bisschen mehr Code?
Klar hier:
http://www.hobby-roboter.de/forum/download/file.php?id=170
( Zeile 742 )

Einfach testen durch Eingabe von

tt

[Dirk B. (dirkb2)]

difftime() berechnet Zeiten vom Typ time_t. Also von der Funktion time() 
nicht clock()

Gibt es auf deinem System überhaupt etwas, was die Systemzeit 
weiterzählt?
(läuft es derzeit auf einem PC?)

Und die Werte die clock liefert, wird nicht unbedingt immer um 1 
weitergezählt.

CLOCKS_PER_SEC kann 200 sein und clock() inkrementiert um 1
Oder es kann auch 100000 sein und clock() inkrementiert um 1000.
Oder  ....

[Kaj (Gast)]

Hab mir mal den Code runtergeladen und reingeschaut:

 uint32_t updateSysCounter() {
    static clock_t start;
    if(start){
      // printf("difftime %d  ",difftime(clock(),start));
        return difftime(clock(),start) ;
    } else {
        start=clock();
        return 0;
    }
 }

//########################################################

case EXTERNAL_C_GETMSTIME:
  {
    push(cpu,updateSysCounter()&0xFFFF); // low counts
    push(cpu,updateSysCounter()>>16); // high counts
  }break;

abgesehen von
Dirk B. schrieb:
> difftime() berechnet Zeiten vom Typ time_t. Also von der Funktion time()
> nicht clock()

Wird bei deinem ersten aufruf IMMER 0 zurück gegeben. Dann wird die 0 
mit 0xFFFF verundet... naja, kannst auch direkt 0 hinschreiben ;)

[chris_ (Gast)]

>Gibt es auf deinem System überhaupt etwas, was die Systemzeit
>weiterzählt?
>(läuft es derzeit auf einem PC?)

Es läuft derzeit unter Ubuntu auf meinem Laptop.

>difftime() berechnet Zeiten vom Typ time_t. Also von der Funktion time()
>nicht clock()

Danke, ich werde time.h mal probieren. Allerdings brauche ich die 
Funktion um die Laufzeit der Befehle der VM abzuschätzen, deshalb sollte 
man schon eine Millisekunden Auflösung haben.

>Wird bei deinem ersten aufruf IMMER 0 zurück gegeben. Dann wird die 0
>mit 0xFFFF verundet... naja, kannst auch direkt 0 hinschreiben ;)

Es wird nur beim aller ersten mal auf 0 gesetzt. Danach nie mehr. 
Deshalb sollte auch die Verundung mit 0xFFFF einen Wert bringen. Aber Du 
hast recht, es gibt eine gewisse Unsauberkeit, die zu Ungenauigkeiten 
führen kann. Man darf die Zeitabfrage nur einmal aufrufen und dann in 
Low und Highwort zerteilen. Das muss ich ändern.

Vielleicht kann von euch das Programm mit gcc kompilieren:

gcc qrzForth.c -o qrzForth

und danach ein paar mal

tt

eingeben. Vielleicht geht ja die Clock auf anderen Rechnern.

[Klaus (Gast)]

chris_ schrieb:
> Allerdings brauche ich die
> Funktion um die Laufzeit der Befehle der VM abzuschätzen, deshalb sollte
> man schon eine Millisekunden Auflösung haben.

Auf meinem System habe ich mit clock() eine Auflösung von 10ms (Ubuntu)

MfG Klaus

[Dirk B. (dirkb2)]

time hat nur eine Auflösung von 1 Sekunde.

Peter II schrieb:
> Ich würde
> einfach selber die Differenz berechnen. (ende-start)

chris_ schrieb:
> Allerdings brauche ich die
> Funktion um die Laufzeit der Befehle der VM abzuschätzen, deshalb sollte
> man schon eine Millisekunden Auflösung haben.
Dann rufe die Befehle mehrmals auf und berechne den Mittelwert.
Mehrmals bedeutet aber mehrere 10000 mal.

[xvzf (Gast)]

Hi,
brauchst du umbedingt die time.h ? Oder kannst du auch den C++11 
Standart benutzen, dann hab ich da was :)
LG

[Kaj (Gast)]

chris_ schrieb:
> Es wird nur beim aller ersten mal auf 0 gesetzt.

Nein. Durch das

return 0;

gibt die Funktion beim ersten aufruf in dem case IMMER 0 zurück!
Dein else zweig sollte wohl

return (start = clock());

lauten.

grüße

[chris_ (Gast)]

>gibt die Funktion beim ersten aufruf in dem case IMMER 0 zurück!

Genau beim ersten Aufruf soll sie das auch tun, danach die Zeiten 
relativ zum ersten Aufruf.

[Kaj (Gast)]

chris_ schrieb:
> soll sie das auch tun,
Dann macht aber das &0xFFFF keinen Sinn an der Stelle...