Ausführungszeit des C-Programms

Ich habe ein C-Programm, das auf mehreren Prozessoren parallel ausgeführt werden soll. Ich muss in der Lage sein, die Ausführungszeit aufzuzeichnen (die zwischen 1 Sekunde und mehreren Minuten liegen kann). Ich habe nach Antworten gesucht, aber alle scheinen die Verwendung der clock()Funktion vorzuschlagen , bei der dann die Anzahl der Uhren berechnet wird, die das Programm geteilt hat, geteilt durch dieClocks_per_second Wert berechnet wird.

Ich bin mir nicht sicher wie Clocks_per_second Wert berechnet wird?

In Java nehme ich nur die aktuelle Zeit in Millisekunden vor und nach der Ausführung.

Gibt es eine ähnliche Sache in C? Ich habe es mir angesehen, aber ich kann anscheinend keinen Weg finden, etwas Besseres als eine zweite Auflösung zu erreichen.

Ich bin mir auch bewusst, dass ein Profiler eine Option wäre, möchte aber selbst einen Timer implementieren.

Vielen Dank

CLOCKS_PER_SECist eine Konstante, die in deklariert ist <time.h>. Verwenden Sie Folgendes, um die von einer Aufgabe in einer C-Anwendung verwendete CPU-Zeit abzurufen:

clock_t begin = clock();

/* here, do your time-consuming job */

clock_t end = clock();
double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;

Beachten Sie, dass dies die Zeit als Gleitkommatyp zurückgibt. Dies kann genauer als eine Sekunde sein (z. B. messen Sie 4,52 Sekunden). Die Präzision hängt von der Architektur ab. Auf modernen Systemen erreichen Sie leicht 10 ms oder weniger, auf älteren Windows-Computern (aus der Win98-Ära) waren es jedoch eher 60 ms.

clock()ist Standard C; es funktioniert "überall". Es gibt systemspezifische Funktionen wiegetrusage() auf Unix-ähnlichen Systemen.

Java System.currentTimeMillis()misst nicht dasselbe. Es ist eine "Wanduhr": Sie kann Ihnen helfen, zu messen, wie viel Zeit das Programm für die Ausführung benötigt hat, aber es sagt Ihnen nicht, wie viel CPU-Zeit verwendet wurde. Auf einem Multitasking-System (dh allen) können diese sehr unterschiedlich sein.

Wenn Sie die Unix-Shell zum Ausführen verwenden, können Sie den Befehl time verwenden.

tun

$ time ./a.out

Wenn Sie a.out als ausführbare Datei annehmen, erhalten Sie die Zeit, die zum Ausführen benötigt wird

In einfacher Vanille C:

#include <time.h>
#include <stdio.h>

int main()
{
    clock_t tic = clock();

    my_expensive_function_which_can_spawn_threads();

    clock_t toc = clock();

    printf("Elapsed: %f seconds\n", (double)(toc - tic) / CLOCKS_PER_SEC);

    return 0;
}

Sie möchten dies funktional:

#include <sys/time.h>

struct timeval  tv1, tv2;
gettimeofday(&tv1, NULL);
/* stuff to do! */
gettimeofday(&tv2, NULL);

printf ("Total time = %f seconds\n",
         (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
         (double) (tv2.tv_sec - tv1.tv_sec));

Beachten Sie, dass dies in Mikrosekunden und nicht nur in Sekunden gemessen wird.

Die meisten einfachen Programme haben eine Rechenzeit in Millisekunden. Ich nehme an, Sie werden dies nützlich finden.

#include <time.h>
#include <stdio.h>

int main(){
    clock_t start = clock();
    // Execuatable code
    clock_t stop = clock();
    double elapsed = (double)(stop - start) * 1000.0 / CLOCKS_PER_SEC;
    printf("Time elapsed in ms: %f", elapsed);
}

Wenn Sie die Laufzeit des gesamten Programms berechnen möchten und sich auf einem Unix-System befinden, führen Sie Ihr Programm mit dem folgenden Befehl time austime ./a.out

Viele Antworten wurden vorgeschlagen clock()und dann CLOCKS_PER_SECvon time.h. Dies ist wahrscheinlich eine schlechte Idee, da dies in meiner /bits/time.hDatei steht:

/* ISO/IEC 9899:1990 7.12.1: <time.h>
The macro `CLOCKS_PER_SEC' is the number per second of the value
returned by the `clock' function. */
/* CAE XSH, Issue 4, Version 2: <time.h>
The value of CLOCKS_PER_SEC is required to be 1 million on all
XSI-conformant systems. */
#  define CLOCKS_PER_SEC  1000000l

#  if !defined __STRICT_ANSI__ && !defined __USE_XOPEN2K
/* Even though CLOCKS_PER_SEC has such a strange value CLK_TCK
presents the real value for clock ticks per second for the system.  */
#   include <bits/types.h>
extern long int __sysconf (int);
#   define CLK_TCK ((__clock_t) __sysconf (2))  /* 2 is _SC_CLK_TCK */
#  endif

CLOCKS_PER_SECJe nachdem, welche Optionen Sie zum Kompilieren verwenden, kann dies als 1000000 definiert werden. Daher scheint dies keine gute Lösung zu sein.

Thomas Pornins Antwort als Makros:

#define TICK(X) clock_t X = clock()
#define TOCK(X) printf("time %s: %g sec.\n", (#X), (double)(clock() - (X)) / CLOCKS_PER_SEC)

Verwenden Sie es so:

TICK(TIME_A);
functionA();
TOCK(TIME_A);

TICK(TIME_B);
functionB();
TOCK(TIME_B);

Ausgabe:

time TIME_A: 0.001652 sec.
time TIME_B: 0.004028 sec.

Sie müssen die Zeitmessung berücksichtigen , die ein Programm nahm auszuführen viel von der Last abhängt , dass die Maschine in diesem bestimmten Moment hat.

In dem Wissen, dass der Weg, die aktuelle Zeit in C zu erhalten, auf verschiedene Arten erreicht werden kann, ist ein einfacher:

#include <time.h>

#define CPU_TIME (getrusage(RUSAGE_SELF,&ruse), ruse.ru_utime.tv_sec + \
  ruse.ru_stime.tv_sec + 1e-6 * \
  (ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec))

int main(void) {
    time_t start, end;
    double first, second;

    // Save user and CPU start time
    time(&start);
    first = CPU_TIME;

    // Perform operations
    ...

    // Save end time
    time(&end);
    second = CPU_TIME;

    printf("cpu  : %.2f secs\n", second - first); 
    printf("user : %d secs\n", (int)(end - start));
}

Ich hoffe es hilft.

Grüße!

(Alle Antworten hier fehlen, wenn Ihr Systemadministrator die Systemzeit ändert oder Ihre Zeitzone unterschiedliche Winter- und Sommerzeiten hat. Daher ...)

Bei Verwendung unter Linux: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); Es ist nicht betroffen, wenn der Systemadministrator die Zeit ändert oder Sie in einem Land leben, in dem die Winterzeit anders ist als die Sommerzeit usw.

#include <stdio.h>
#include <time.h>

#include <unistd.h> /* for sleep() */

int main() {
    struct timespec begin, end;
    clock_gettime(CLOCK_MONOTONIC_RAW, &begin);

    sleep(1);      // waste some time

    clock_gettime(CLOCK_MONOTONIC_RAW, &end);

    printf ("Total time = %f seconds\n",
            (end.tv_nsec - begin.tv_nsec) / 1000000000.0 +
            (end.tv_sec  - begin.tv_sec));

}

man clock_gettime Zustände:

CLOCK_MONOTONIC
              Clock  that  cannot  be set and represents monotonic time since some unspecified starting point.  This clock is not affected by discontinuous jumps in the system time
              (e.g., if the system administrator manually changes the clock), but is affected by the incremental adjustments performed by adjtime(3) and NTP.

ANSI C gibt nur Zeitfunktionen mit zweiter Genauigkeit an. Wenn Sie jedoch in einer POSIX-Umgebung ausgeführt werden, können Sie die Funktion gettimeofday () verwenden, die eine Auflösung von Mikrosekunden für die seit der UNIX-Epoche verstrichene Zeit bietet.

Als Randnotiz würde ich die Verwendung von clock () nicht empfehlen, da es auf vielen (wenn nicht allen?) Systemen schlecht implementiert und nicht genau ist, abgesehen von der Tatsache, dass es sich nur darauf bezieht, wie lange Ihr Programm auf der CPU und verbracht hat nicht die Gesamtlebensdauer des Programms, die Sie Ihrer Frage zufolge gerne messen würden.

In meinem System funktionieren nicht alle Lösungen.

Ich kann es gebrauchen

#include <time.h>

double difftime(time_t time1, time_t time0);

    #include<time.h>
    #include<stdio.h>
    int main(){
clock_t begin=clock();

    int i;
for(i=0;i<100000;i++){
printf("%d",i);

}
clock_t end=clock();
printf("Time taken:%lf",(double)(end-begin)/CLOCKS_PER_SEC);
}

Dieses Programm wird wie Charme funktionieren.

Ich habe festgestellt, dass die übliche Uhr (), die jeder hier empfiehlt, aus irgendeinem Grund stark von Lauf zu Lauf abweicht, selbst für statischen Code ohne Nebenwirkungen, wie Zeichnen auf dem Bildschirm oder Lesen von Dateien. Dies kann daran liegen, dass die CPU den Stromverbrauch ändert, das Betriebssystem unterschiedliche Prioritäten setzt usw.

Die einzige Möglichkeit, mit clock () jedes Mal zuverlässig das gleiche Ergebnis zu erzielen, besteht darin, den gemessenen Code mehrmals (mehrere Minuten lang) in einer Schleife auszuführen und dabei Vorsichtsmaßnahmen zu treffen, um zu verhindern, dass der Compiler ihn optimiert: Moderne Compiler können den Code vorberechnen ohne Nebenwirkungen, die in einer Schleife ausgeführt werden, und verschieben Sie sie aus der Schleife heraus, z. B. indem Sie für jede Iteration eine zufällige Eingabe verwenden.

Nachdem genügend Samples in einem Array gesammelt wurden, sortiert man dieses Array und nimmt das mittlere Element, den Median. Der Median ist besser als der Durchschnitt, da er extreme Abweichungen beseitigt, z. B. wenn Antivirenprogramme die gesamte CPU belegen oder das Betriebssystem Aktualisierungen vornimmt.

Hier ist ein einfaches Dienstprogramm zum Messen der Ausführungsleistung von C / C ++ - Code, bei dem die Werte nahe dem Median gemittelt werden: https://github.com/saniv/gauge

Ich selbst bin immer noch auf der Suche nach einer robusteren und schnelleren Methode zum Messen von Code. Man könnte wahrscheinlich versuchen, den Code unter kontrollierten Bedingungen auf Bare-Metal ohne Betriebssystem auszuführen, aber das führt zu einem unrealistischen Ergebnis, da in Wirklichkeit das Betriebssystem involviert ist.

x86 verfügt über diese Hardwareleistungsindikatoren, die die tatsächliche Anzahl der ausgeführten Anweisungen enthalten. Sie sind jedoch ohne Hilfe des Betriebssystems schwierig zuzugreifen, schwer zu interpretieren und haben ihre eigenen Probleme ( http://archive.gamedev.net/archive/reference/articles) /article213.html ). Dennoch könnten sie hilfreich sein, um die Art des Flaschenhalses zu untersuchen (Datenzugriff oder tatsächliche Berechnungen dieser Daten).

Man könnte eine andere Art von Eingabe nützlich finden: Ich habe diese Methode gegebener Zeit im Rahmen eines Hochschulstudium auf GPGPU-Programmierung mit CUDA (Messkursbeschreibung ). Es kombiniert Methoden, die in früheren Beiträgen verwendet wurden, und ich poste sie einfach, weil die Anforderungen ihr Glaubwürdigkeit verleihen:

unsigned long int elapsed;
struct timeval t_start, t_end, t_diff;
gettimeofday(&t_start, NULL);

// perform computations ...

gettimeofday(&t_end, NULL);
timeval_subtract(&t_diff, &t_end, &t_start);
elapsed = (t_diff.tv_sec*1e6 + t_diff.tv_usec);
printf("GPU version runs in: %lu microsecs\n", elapsed);

Ich nehme an, Sie könnten mit zB multiplizieren 1.0 / 1000.0, um die Maßeinheit zu erhalten, die Ihren Anforderungen entspricht.

Vergleich der Ausführungszeit von Blasensortierung und Auswahlsortierung Ich habe ein Programm, das die Ausführungszeit von Blasensortierung und Auswahlsortierung vergleicht. Um den Zeitpunkt der Ausführung eines Codeblocks herauszufinden, berechnen Sie die Zeit vor und nach dem Block durch

 clock_t start=clock();
 …
 clock_t end=clock();
 CLOCKS_PER_SEC is constant in time.h library

Beispielcode:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
   int a[10000],i,j,min,temp;
   for(i=0;i<10000;i++)
   {
      a[i]=rand()%10000;
   }
   //The bubble Sort
   clock_t start,end;
   start=clock();
   for(i=0;i<10000;i++)
   {
     for(j=i+1;j<10000;j++)
     {
       if(a[i]>a[j])
       {
         int temp=a[i];
         a[i]=a[j];
         a[j]=temp;
       }
     }
   }
   end=clock();
   double extime=(double) (end-start)/CLOCKS_PER_SEC;
   printf("\n\tExecution time for the bubble sort is %f seconds\n ",extime);

   for(i=0;i<10000;i++)
   {
     a[i]=rand()%10000;
   }
   clock_t start1,end1;
   start1=clock();
   // The Selection Sort
   for(i=0;i<10000;i++)
   {
     min=i;
     for(j=i+1;j<10000;j++)
     {
       if(a[min]>a[j])
       {
         min=j;
       }
     }
     temp=a[min];
     a[min]=a[i];
     a[i]=temp;
   }
   end1=clock();
   double extime1=(double) (end1-start1)/CLOCKS_PER_SEC;
   printf("\n");
   printf("\tExecution time for the selection sort is %f seconds\n\n", extime1);
   if(extime1<extime)
     printf("\tSelection sort is faster than Bubble sort by %f seconds\n\n", extime - extime1);
   else if(extime1>extime)
     printf("\tBubble sort is faster than Selection sort by %f seconds\n\n", extime1 - extime);
   else
     printf("\tBoth algorithms have the same execution time\n\n");
}