Час виконання програми С

У мене є програма C, яка має на меті працювати паралельно на декількох процесорах. Мені потрібно мати можливість записувати час виконання (який може бути від 1 секунди до декількох хвилин). Я шукав відповіді, але всі вони, здається, пропонують використовувати clock()функцію, яка потім включає обчислення кількості годин, яку програма взяла, поділену на Clocks_per_secondзначення.

Я не впевнений, як Clocks_per_secondрозраховується значення?

У Java я просто приймаю поточний час у мілісекундах до та після виконання.

Чи є в С подібне? Я придивився, але я не можу знайти спосіб отримати щось краще, ніж друга резолюція.

Я також знаю, що профілер може бути варіантом, але я прагну сам реалізувати таймер.

Дякую

CLOCKS_PER_SEC- константа, яка оголошена в <time.h>. Щоб отримати час процесора, який використовується завданням у програмі C, використовуйте:

clock_t begin = clock();

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

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

Зауважте, що це повертає час як тип з плаваючою точкою. Це може бути точніше секунди (наприклад, ви вимірюєте 4,52 секунди). Точність залежить від архітектури; в сучасних системах ви легко отримуєте 10 мс і менше, але на старих машинах Windows (з епохи Win98) він був ближче до 60мс.

clock()є стандартним С; вона працює «скрізь». Існують специфічні для системи функції, такі як getrusage()у Unix-подібних системах.

Java System.currentTimeMillis()не вимірює те саме. Це "настінні годинники": він може допомогти вам виміряти, скільки часу знадобилося програмі для виконання, але він не говорить вам, скільки часу було використано процесора. У системах багатозадачності (тобто всі) вони можуть бути різними.

Якщо для запуску використовується оболонка Unix, ви можете використовувати команду time.

робити

$ time ./a.out

припустимо, що a.out як виконуваний файл дасть у час, необхідний для цього

У звичайній ванілі С:

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

Ви функціонально бажаєте цього:

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

Зауважте, що це вимірюється в мікросекундах, а не лише секундах.

Більшість простих програм мають час обчислення в мілісекундах. Отже, я гадаю, вам це стане в нагоді.

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

Якщо ви хочете обчислити час виконання всієї програми, і ви перебуваєте в системі Unix, запустіть свою програму, використовуючи команду time, як цеtime ./a.out

Дуже багато відповідей clock() а потім CLOCKS_PER_SECвід time.h. Це, мабуть, погана ідея, тому що так /bits/time.hговорить мій файл:

/* 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_SEC може бути визначено як 1000000, залежно від того, які параметри ви використовуєте для компіляції, і, таким чином, це не здається хорошим рішенням.

Відповідь Томаса Порніна як макроси:

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

Використовуйте його так:

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

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

Вихід:

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

Ви повинні врахувати, що вимірювання часу, який потребує виконання програми, багато в чому залежить від навантаження, яке має машина в той конкретний момент.

Знаючи, що спосіб отримання поточного часу в С може бути досягнутий різними способами, простішим є:

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

Сподіваюся, це допомагає.

З повагою!

(Усі відповіді тут відсутні, якщо ваш sysadmin змінює системний час, або ваш часовий пояс відрізняється зимовим та колись часовим. Тому ...)

На використання Linux: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); це не впливає, якщо системний адміністратор змінить час, або ви живете в країні, в яку зимовий час відрізняється від літнього часу тощо.

#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 констатує:

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 задає лише функції часу другої точності. Однак, якщо ви працюєте в середовищі POSIX, ви можете використовувати функцію gettimeofday (), яка забезпечує роздільну здатність мікросекунд часу, пройденого з епохи UNIX.

Як зауваження, я б не рекомендував використовувати clock (), оскільки він погано реалізований у багатьох (якщо не всіх?) Системах і не точний, крім того, що він стосується лише того, скільки часу ваша програма витратила на процесор і не загальний термін служби програми, який, відповідно до вашого запитання, - це те, що я вважаю, що ви хотіли б виміряти.

Кожне рішення не працює в моїй системі.

Я можу використати

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

Ця програма буде працювати як шарм.

Я виявив, що звичайний годинник (), який всі рекомендують тут, чомусь дико відхиляється від запуску до запуску, навіть для статичного коду без будь-яких побічних ефектів, як малюнок на екрані чи читання файлів. Це може бути тому, що процесор змінює режими енергоспоживання, ОС дає різні пріоритети тощо.

Тож єдиний спосіб надійно отримувати один і той же результат кожен раз за допомогою годинника () - запускати вимірюваний код у циклі кілька разів (протягом декількох хвилин), вживаючи запобіжних заходів, щоб запобігти оптимізації компілятора: сучасні компілятори можуть попередньо обчислити код без побічних ефектів, що працюють у циклі, і перемістіть його з циклу, наприклад, використовуючи випадковий вхід для кожної ітерації.

Після того як достатня кількість зразків збирається в масив, один сортує цей масив і бере середній елемент, званий медіаною. Медіана краща за середню, тому що вона викидає екстремальні відхилення, як-от скажімо, антивірус, який піднімає всі процесори або ОС робить деяке оновлення.

Ось проста утиліта для вимірювання ефективності виконання коду C / C ++, усереднення значень біля медіани: https://github.com/saniv/gauge

Я все ще шукаю більш надійний і швидкий спосіб вимірювання коду. Можливо, можна спробувати запустити код у контрольованих умовах на голому металі без будь-якої ОС, але це дасть нереальний результат, адже насправді ОС дійсно задіяна.

x86 має ці апаратні лічильники продуктивності, які включають фактичну кількість виконаних інструкцій, але вони складні для доступу без допомоги ОС, важко інтерпретувати та мають свої проблеми ( http://archive.gamedev.net/archive/reference/articles /article213.html ). Однак вони можуть бути корисними для дослідження характеру горловини пляшки (доступ до даних або фактичні розрахунки за цими даними).

Деяким може бути корисним інший вид введення: мені цей метод вимірювання часу був наданий у рамках університетського курсу з GPGPU-програмування за допомогою NVidia CUDA ( опис курсу ). Він поєднує в собі методи, помічені в попередніх публікаціях, і я просто розміщую його, оскільки вимоги надають йому надійності:

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

Я припускаю, що ви могли б помножитись, наприклад, 1.0 / 1000.0щоб отримати одиницю вимірювання, яка відповідає вашим потребам.

Порівняння часу виконання сортування міхура та сортування вибору У мене є програма, яка порівнює час виконання сортування міхура та сортування вибору. Щоб дізнатись час виконання блоку коду, обчисліть час до та після блоку

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

Приклад коду:

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