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 tutti suggerire di utilizzare la clock()funzione, che prevede quindi il calcolo del numero di orologi che il programma ha preso diviso per il Clocks_per_secondvalore.

Non sono sicuro di come Clocks_per_secondviene calcolato il valore?

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

C'è qualcosa di 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 da solo.

Grazie

CLOCKS_PER_SECè una costante dichiarata in <time.h>. Per ottenere il tempo 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 ciò restituisce l'ora come tipo a virgola mobile. Questo può essere più preciso di un secondo (ad es. Si misura 4,52 secondi). La precisione dipende dall'architettura; sui sistemi moderni si ottengono facilmente 10ms o meno, ma sui vecchi computer Windows (dell'era Win98) era più vicino ai 60ms.

clock()è standard C; funziona "ovunque". Esistono funzioni specifiche del sistema, come getrusage()su sistemi simili a Unix.

Java System.currentTimeMillis()non misura la stessa cosa. È un "orologio da parete": può aiutarti a misurare quanto tempo ci vuole per l'esecuzione del programma, ma non ti dice quanto tempo CPU è stato usato. Su un sistema multitasking (cioè tutti), questi possono essere molto diversi.

Se si utilizza la shell Unix per l'esecuzione, è possibile utilizzare il comando time.

fare

$ time ./a.out

supponendo a.out come eseguibile ti darà il tempo impiegato per eseguirlo

In semplice vaniglia 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;
}

Funzionalmente vuoi questo:

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

Si noti che questo misura in microsecondi, non solo in pochi secondi.

La maggior parte dei programmi semplici ha un tempo di calcolo in milli-secondi. Quindi, suppongo, lo troverai utile.

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

Se vuoi calcolare il runtime dell'intero programma e sei su un sistema Unix, esegui il tuo programma usando il comando time in questo modotime ./a.out

Molte risposte hanno suggerito clock()e poi CLOCKS_PER_SECda time.h. Questa è probabilmente una cattiva idea, perché è ciò /bits/time.hche dice il mio file:

/* 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

Quindi CLOCKS_PER_SECpotrebbe essere definito come 1000000, a seconda delle opzioni utilizzate per la compilazione, e quindi non sembra una buona soluzione.

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.

Devi tenere conto del fatto che misurare il tempo impiegato da un programma per eseguire dipende molto dal carico che la macchina ha in quel momento specifico.

Sapendo che, il modo per ottenere l'ora corrente in C può essere raggiunto in diversi modi, uno più semplice è:

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

Spero che sia d'aiuto.

Saluti!

(Tutte le risposte qui mancano, se l'amministratore di sistema cambia l'ora di sistema o il fuso orario ha orari invernali e estivi diversi. Pertanto ...)

Sull'uso di Linux: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); non è interessato se l'amministratore di sistema cambia l'ora o vivi in ​​un paese con orario invernale diverso da quello estivo, ecc.

#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 stati:

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 specifica solo le funzioni temporali di seconda precisione. Tuttavia, se si esegue in un ambiente POSIX, è possibile utilizzare la funzione gettimeofday () che fornisce la risoluzione in microsecondi del tempo trascorso dall'epoca UNIX.

Come nota a margine, non consiglierei di usare clock () poiché è mal implementato su molti sistemi (se non tutti?) E non è preciso, oltre al fatto che si riferisce solo al tempo trascorso dal programma sulla CPU e non la durata totale del programma, che secondo la tua domanda è ciò che presumo tu voglia misurare.

Ogni soluzione non funziona nel mio sistema.

Posso usare

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

Questo programma funzionerà come un fascino.

Ho scoperto che il solito clock (), tutti raccomandano qui, per qualche ragione si discosta selvaggiamente da una corsa all'altra, anche per codice statico senza effetti collaterali, come disegnare sullo schermo o leggere file. Potrebbe essere perché la CPU modifica le modalità di consumo energetico, il sistema operativo dà priorità diverse, ecc ...

Quindi l'unico modo per ottenere lo stesso risultato in modo affidabile ogni volta con clock () è eseguire il codice misurato in un ciclo più volte (per diversi minuti), prendendo precauzioni per impedire al compilatore di ottimizzarlo: i moderni compilatori possono precompilare il codice senza effetti collaterali in esecuzione in un ciclo e spostarlo fuori dal ciclo., come ad esempio l'uso di input casuali per ogni iterazione.

Dopo aver raccolto un numero sufficiente di campioni in un array, si ordina quell'array e si prende l'elemento centrale, chiamato mediana. La mediana è migliore della media, perché elimina deviazioni estreme, come ad esempio l'antivirus che occupa tutta la CPU o il sistema operativo che esegue un aggiornamento.

Ecco una semplice utility per misurare le prestazioni di esecuzione del codice C / C ++, calcolando la media dei valori vicino alla mediana: https://github.com/saniv/gauge

Sono ancora alla ricerca di un modo più robusto e veloce per misurare il codice. Probabilmente si potrebbe provare a eseguire il codice in condizioni controllate su bare metal senza alcun sistema operativo, ma ciò darà risultati non realistici, perché in realtà il sistema operativo viene coinvolto.

x86 ha questi contatori delle prestazioni hardware, che includono il numero effettivo di istruzioni eseguite, ma sono difficili da accedere senza l'aiuto del sistema operativo, difficili da interpretare e hanno i loro problemi ( http://archive.gamedev.net/archive/reference/articles /article213.html ). Potrebbero comunque essere utili indagare la natura del collo della bottiglia (accesso ai dati o calcoli effettivi su tali dati).

Alcuni potrebbero trovare utile un diverso tipo di input: mi è stato dato questo metodo di misurazione del tempo come parte di un corso universitario sulla programmazione GPGPU con NVidia CUDA ( descrizione del corso ). Combina i metodi visti nei post precedenti e lo pubblico semplicemente perché i requisiti gli conferiscono credibilità:

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

Suppongo che potresti moltiplicare, ad esempio, 1.0 / 1000.0per ottenere l'unità di misura adatta alle tue esigenze.

Confronto dei tempi di esecuzione dell'ordinamento delle bolle e dell'ordinamento della selezione Ho un programma che confronta i tempi di esecuzione dell'ordinamento delle bolle e dell'ordinamento della selezione. 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 <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");
}