Tempo di esecuzione del programma C.

Ho un programma C che mira ad essere eseguito in parallelo su diversi processori. Devo essere in grado di registrare il tempo di esecuzione (che può variare da 1 secondo a diversi minuti). Ho cercato le risposte, ma sembrano suggerire l’uso della funzione clock() , che implica il calcolo del numero di clock che il programma ha preso diviso il valore Clocks_per_second .

Non sono sicuro di come viene calcolato il valore di Clocks_per_second ?

In Java, prendo solo l’ora corrente in millisecondi prima e dopo l’esecuzione.

C’è una cosa simile in C? Ho dato un’occhiata, ma non riesco a trovare un modo per ottenere qualcosa di meglio di una seconda risoluzione.

Sono anche consapevole che un profiler sarebbe un’opzione, ma sto cercando di implementare un timer me stesso.

    Grazie

    CLOCKS_PER_SEC è una costante che è dichiarata in . Per ottenere il tempo della CPU utilizzato da un’attività all’interno di un’applicazione C, utilizzare:

     clock_t begin = clock(); /* here, do your time-consuming job */ clock_t end = clock(); double time_spent = (double)(end - begin) / CLOCKS_PER_SEC; 

    Si noti che questo restituisce l’ora come un tipo a virgola mobile. Questo può essere più preciso di un secondo (es. Misura 4,52 secondi). La precisione dipende dall’architettura; su sistemi moderni si ottengono facilmente 10 ms o meno, ma su macchine Windows precedenti (dell’era Win98) era più vicino a 60 ms.

    clock() è standard C; funziona “ovunque”. Esistono funzioni specifiche del sistema, come getrusage() su sistemi di tipo Unix.

    Java’s System.currentTimeMillis() non misura la stessa cosa. È un “orologio da muro”: può aiutarti a misurare quanto tempo ci vuole per l’esecuzione del programma, ma non ti dice quanto tempo di CPU è stato utilizzato. Sui sistemi multitasking (cioè tutti), questi possono essere molto diversi.

    Se si sta utilizzando la shell Unix per l’esecuzione, è ansible utilizzare il comando time.

    fare

     $ time ./a.out 

    assumendo a.out come l’eseguibile ti darà il tempo necessario per eseguirlo

    Tu vuoi funzionalmente questo:

     #include  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)); 

    Nota che questo misura in microsecondi, non solo secondi.

    In plain vanilla C:

     #include  #include  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; } 

    La maggior parte dei programmi semplici hanno il tempo di calcolo in millisecondi. Quindi, suppongo, lo troverai utile.

     #include  #include  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); } 

    Se vuoi calcolare il runtime dell’intero programma e sei su un sistema Unix, esegui il tuo programma usando il comando time come questa time ./a.out

    Molte risposte hanno suggerito clock() e quindi CLOCKS_PER_SEC da time.h Questa è probabilmente una ctriggers idea, perché questo è ciò che dice il mio file /bits/time.h :

     /* ISO/IEC 9899:1990 7.12.1:  The macro `CLOCKS_PER_SEC' is the number per second of the value returned by the `clock' function. */ /* CAE XSH, Issue 4, Version 2:  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  extern long int __sysconf (int); # define CLK_TCK ((__clock_t) __sysconf (2)) /* 2 is _SC_CLK_TCK */ # endif 

    Quindi CLOCKS_PER_SEC può essere definito come 1000000, a seconda delle opzioni che si usano per compilare, e quindi non sembra una buona soluzione.

    Bisogna tenere in considerazione che misurare il tempo necessario per eseguire un programma dipende molto dal carico che la macchina ha in quel momento specifico.

    Sapendo che il modo di ottenere il tempo corrente in C può essere raggiunto in modi diversi, uno più semplice è:

     #include  #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)); } 

    Spero che sia d’aiuto.

    Saluti!

    ANSI C specifica solo le seconde funzioni temporali di precisione. Tuttavia, se si utilizza un ambiente POSIX, è ansible utilizzare la funzione gettimeofday () che fornisce la risoluzione dei microsecondi del tempo trascorso da UNIX Epoch.

    Come nota a margine, non raccomanderei l’uso di clock () poiché è implementato male su molti (se non tutti?) Sistemi e non è accurato, oltre al fatto che si riferisce solo a quanto tempo il tuo programma ha speso per la CPU e non la durata totale del programma, che in base alla tua domanda è ciò che presumo vorresti misurare.

    Ogni soluzione non funziona nel mio sistema.

    Posso usare

     #include  double difftime(time_t time1, time_t time0); 
      #include #include 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); } 

    Questo programma funzionerà come fascino.

    (Tutte le risposte qui mancano, se il tuo sysadmin cambia il tempo di sistema, o il tuo fuso orario ha diversi orari invernali ed estivi, quindi …)

    Su linux use: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); Non è influenzato se l’amministratore di sistema cambia l’ora o se vivi in ​​un paese con orario invernale diverso dall’ora legale, ecc.

     #include  #include  #include  /* 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 afferma:

     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 (eg, if the system administrator manually changes the clock), but is affected by the incremental adjustments performsd by adjtime(3) and NTP. 

    La risposta di Thomas Pornin come macro:

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

    Usalo in questo modo:

     TICK(TIME_A); functionA(); TOCK(TIME_A); TICK(TIME_B); functionB(); TOCK(TIME_B); 

    Produzione:

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

    Confronto dei tempi di esecuzione di bubble sort e sort sort Ho un programma che confronta il tempo di esecuzione di bubble sort e sort sort. Per scoprire il tempo di esecuzione di un blocco di codice calcolare il tempo prima e dopo il blocco di

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

    Codice di esempio:

     #include  #include  #include  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(extime1extime) 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"); }