gcc time.h Laufzeit eines Programmteils ermitteln

Gast #3396790
Hallo Zusammen,

ich habe folgenden Programmcode:
1
 uint32_t updateSysCounter()
2
 {
3
   static uint8_t theFirstTime=true;
4
   clock_t start, end;
5
   double tmp;
6

7
   if(theFirstTime)
8
   {
9
     start=clock();
10
     theFirstTime=false;
11
     tmp=0;
12
   }else
13
   {
14
     end=clock();
15
     tmp=difftime(end,start)/ CLOCKS_PER_SEC;
16
   }
17

18
   return tmp;
19
 }

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

Die
Gast #3396997
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!
Persönliche Seite #3397104
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.
1
uint32_t updateSysCounter() {
2
   static clock_t start;
3
   if(start){
4
       return difftime(clock(),start) / CLOCKS_PER_SEC;
5
   } else {
6
       start=clock();
7
   }
8
}
#3397156
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  ....
Gast #3397165
Hab mir mal den Code runtergeladen und reingeschaut:
1
 uint32_t updateSysCounter() {
2
    static clock_t start;
3
    if(start){
4
      // printf("difftime %d  ",difftime(clock(),start));
5
        return difftime(clock(),start) ;
6
    } else {
7
        start=clock();
8
        return 0;
9
    }
10
 }
11

12
//########################################################
13

14
case EXTERNAL_C_GETMSTIME:
15
  {
16
    push(cpu,updateSysCounter()&0xFFFF); // low counts
17
    push(cpu,updateSysCounter()>>16); // high counts
18
  }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 ;)
Gast #3397239
>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.
Gast #3397258
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
#3397273
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.
Gast #3397421
chris_ schrieb:
> Es wird nur beim aller ersten mal auf 0 gesetzt.

Nein. Durch das
1
return 0;
gibt die Funktion beim ersten aufruf in dem case IMMER 0 zurück!
Dein else zweig sollte wohl
1
return (start = clock());
lauten.

grüße
Gast #3397741
>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.

Antwort schreiben

Eine eigene Frage? Dieser Thread ist über 13 Jahre alt. Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.