Czas wykonania programu C.

Mam program C, który ma być uruchamiany równolegle na kilku procesorach. Muszę być w stanie zarejestrować czas wykonania (który może wynosić od 1 sekundy do kilku minut). Szukałem odpowiedzi, ale wszystkie wydają się sugerować użycie clock()funkcji, która następnie polega na obliczeniu liczby zegarów, które program wziął podzielonej przez Clocks_per_secondwartość.

Nie jestem pewien, jak Clocks_per_secondobliczana jest wartość?

W Javie po prostu bierzę czas w milisekundach przed i po wykonaniu.

Czy w C jest coś podobnego? Spojrzałem, ale nie mogę znaleźć sposobu na uzyskanie czegoś lepszego niż drugie rozwiązanie.

Wiem też, że profiler byłby opcją, ale sam zamierzam zaimplementować licznik czasu.

Dzięki

CLOCKS_PER_SECjest stałą, która jest zadeklarowana w <time.h>. Aby uzyskać czas procesora wykorzystywany przez zadanie w aplikacji C, użyj:

clock_t begin = clock();

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

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

Zauważ, że to zwraca czas jako typ zmiennoprzecinkowy. Może to być dokładniejsze niż sekunda (np. Mierzysz 4,52 sekundy). Precyzja zależy od architektury; na nowoczesnych systemach można łatwo uzyskać 10 ms lub mniej, ale na starszych komputerach z systemem Windows (z okresu Win98) było to bliżej 60 ms.

clock()jest standardem C; działa „wszędzie”. Istnieją funkcje specyficzne dla systemu, na przykład getrusage()w systemach uniksowych.

Java System.currentTimeMillis()nie mierzy tego samego. Jest to „zegar ścienny”: może pomóc ci zmierzyć, ile czasu zajęło wykonanie programu, ale nie mówi ci, ile czasu procesora zostało wykorzystane. W systemach wielozadaniowych (tj. Wszystkich) mogą się one znacznie różnić.

Jeśli używasz powłoki Unix do uruchamiania, możesz użyć polecenia time.

robić

$ time ./a.out

przyjęcie a.out jako pliku wykonywalnego da ci czas potrzebny na uruchomienie tego

W zwykłej wanilii 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;
}

Funkcjonalnie chcesz to:

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

Zauważ, że mierzy to w mikrosekundach, a nie tylko sekundach.

Większość prostych programów ma czas obliczeń w milisekundach. Przypuszczam, że przyda ci się to.

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

Jeśli chcesz obliczyć środowisko wykonawcze całego programu i korzystasz z systemu uniksowego, uruchom swój program za pomocą polecenia time, takiego jak tentime ./a.out

Wiele odpowiedzi sugerowało, clock()a następnie CLOCKS_PER_SECpochodziło od time.h. To prawdopodobnie zły pomysł, ponieważ tak /bits/time.hmówi mój plik:

/* 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_SECMożna go więc zdefiniować jako 1000000, w zależności od opcji używanych do kompilacji, a zatem nie wydaje się to dobrym rozwiązaniem.

Odpowiedź Thomasa Pornina jako makra:

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

Użyj tego w ten sposób:

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

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

Wynik:

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

Musisz wziąć pod uwagę ten pomiar czasu potrzebnego do uruchomienia programu zależy w dużej mierze od obciążenia, jakie maszyna ma w danym momencie.

Wiedząc, że sposób uzyskania aktualnego czasu w C można osiągnąć na różne sposoby, łatwiejszym jest:

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

Mam nadzieję, że to pomoże.

Pozdrowienia!

(Brak tutaj wszystkich odpowiedzi, jeśli administrator systemu zmieni czas systemowy lub strefa czasowa różni się czasem zimowym i zimowym. Dlatego ...)

W przypadku korzystania z Linuksa: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); Nie ma to wpływu, jeśli administrator systemu zmieni czas lub mieszkasz w kraju o czasie zimowym innym niż czas letni itp.

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

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 określa tylko funkcje czasu drugiej precyzji. Jednak jeśli pracujesz w środowisku POSIX, możesz użyć gettimeofday () która zapewnia rozdzielczość mikrosekund czasu od czasu epoki UNIX.

Na marginesie, nie zalecałbym używania clock (), ponieważ jest on źle zaimplementowany w wielu (jeśli nie wszystkich?) Systemach i nie jest dokładny, poza tym, że odnosi się to tylko do tego, ile czasu twój program spędził na procesorze i nie całkowity czas trwania programu, który według twojego pytania jest tym, co zakładam, że chciałbyś zmierzyć.

Każde rozwiązanie nie działa w moim systemie.

Mogę się użyć

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

Ten program będzie działał jak urok.

Odkryłem, że zwykły clock (), wszyscy tutaj polecają, z jakiegoś powodu bardzo różni się od uruchomienia do uruchomienia, nawet w przypadku kodu statycznego bez żadnych skutków ubocznych, takich jak rysowanie na ekranie lub czytanie plików. Może tak być, ponieważ procesor zmienia tryby zużycia energii, system operacyjny daje różne priorytety itp.

Tak więc jedynym sposobem, aby niezawodnie uzyskać ten sam wynik za każdym razem przy użyciu clock (), jest uruchomienie mierzonego kodu w pętli wiele razy (przez kilka minut), przy zachowaniu środków ostrożności, aby uniemożliwić kompilatorowi jego optymalizację: nowoczesne kompilatory mogą wstępnie obliczyć kod bez efektów ubocznych działających w pętli i wyjmij ją z pętli, np. używając losowego wejścia dla każdej iteracji.

Po zebraniu wystarczającej liczby próbek do tablicy, sortuje się tę tablicę i przyjmuje środkowy element, zwany medianą. Mediana jest lepsza niż średnia, ponieważ odrzuca ekstremalne odchylenia, jak na przykład antywirus zajmujący cały procesor lub system operacyjny przeprowadzający jakąś aktualizację.

Oto proste narzędzie do pomiaru wydajności wykonania kodu C / C ++, uśredniające wartości zbliżone do mediany: https://github.com/saniv/gauge

Nadal szukam bardziej niezawodnego i szybszego sposobu pomiaru kodu. Prawdopodobnie można by spróbować uruchomić kod w kontrolowanych warunkach na czystym metalu bez żadnego systemu operacyjnego, ale to da nierealistyczny wynik, ponieważ w rzeczywistości system operacyjny się angażuje.

x86 ma te liczniki wydajności sprzętu, w tym rzeczywistą liczbę wykonanych instrukcji, ale dostęp do nich jest trudny bez pomocy systemu operacyjnego, trudny do interpretacji i ma swoje własne problemy ( http://archive.gamedev.net/archive/reference/articles /article213.html ). Mimo to mogą być pomocne w badaniu charakteru szyjki butelki (dostęp do danych lub faktyczne obliczenia tych danych).

Niektórym może się przydać inny rodzaj danych wejściowych: dano mi tę metodę pomiaru czasu w ramach uniwersyteckiego kursu programowania GPGPU z NVidia CUDA ( opis kursu ). Łączy metody widoczne we wcześniejszych postach i po prostu publikuję, ponieważ wymagania nadają mu wiarygodność:

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

Przypuszczam, że możesz pomnożyć przez np., 1.0 / 1000.0Aby uzyskać jednostkę miary, która odpowiada twoim potrzebom.

Porównanie czasu wykonania sortowania bąbelkowego i sortowania selekcyjnego Mam program, który porównuje czas wykonania sortowania bąbelkowego i sortowania selekcyjnego. Aby ustalić czas wykonania bloku kodu, oblicz czas przed i za blokiem według

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

Przykładowy kod:

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