C 프로그램의 실행 시간

여러 프로세서에서 병렬로 실행하려는 C 프로그램이 있습니다. 실행 시간을 기록 할 수 있어야합니다 (1 초에서 몇 분까지 가능). 나는 답을 찾았지만 모두 clock()함수를 사용하도록 제안하는 것처럼 보 였으며 프로그램에 걸린 시계 수를 Clocks_per_second값 으로 나눈 값을 계산해야 합니다.

Clocks_per_second값이 어떻게 계산 되는지 잘 모르겠습니다 .

Java에서는 실행 전후에 현재 시간을 밀리 초 단위로 사용합니다.

C에도 비슷한 것이 있습니까? 나는 보았지만 두 번째 해상도보다 더 나은 것을 얻는 방법을 찾지 못하는 것 같습니다.

또한 프로파일 러가 옵션 일 것임을 알고 있지만 타이머를 직접 구현하려고합니다.

감사

CLOCKS_PER_SEC에 선언 된 상수입니다 <time.h>. C 응용 프로그램 내에서 작업에 사용 된 CPU 시간을 얻으려면 다음을 사용하십시오.

clock_t begin = clock();

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

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

이것은 시간을 부동 소수점 유형으로 반환합니다. 이것은 1 초보다 정확할 수 있습니다 (예 : 4.52 초 측정). 정밀도는 아키텍처에 따라 다릅니다. 최신 시스템에서는 쉽게 10ms 이하를 얻을 수 있지만 구형 Windows 시스템 (Win98 시대)에서는 60ms에 가깝습니다.

clock()표준 C이고; "모든 곳에서"작동합니다. getrusage()유닉스 계열 시스템과 같은 시스템 별 기능이 있습니다.

Java System.currentTimeMillis()는 동일한 것을 측정하지 않습니다. "벽시계": 프로그램을 실행하는 데 걸리는 시간을 측정하는 데 도움이되지만 사용 된 CPU 시간을 알려주지는 않습니다. 멀티 태스킹 시스템 (즉, 모든 시스템)에서 이러한 시스템은 크게 다를 수 있습니다.

Unix 쉘을 사용하여 실행중인 경우 time 명령을 사용할 수 있습니다.

하기

$ time ./a.out

실행 파일로 a.out을 가정하면이를 실행하는 데 걸리는 시간이 주어집니다.

일반 바닐라 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;
}

당신은 기능적으로 이것을 원합니다 :

#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으로 정의 될 수 있으므로 좋은 솔루션처럼 보이지 않습니다.

매크로로 Thomas Pornin의 답변 :

#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.

프로그램을 실행하는 데 걸리는 시간 을 측정 하는 것은 기계가 특정 순간에 가하는 부하에 따라 달라진다는 점을 고려해야합니다 .

C로 현재 시간을 얻는 방법은 여러 가지 방법으로 달성 할 수 있다는 것을 알고 있으면 더 쉬운 방법입니다

#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 환경에서 실행중인 경우 , UNIX Epoch 이후에 경과 된 시간의 마이크로 초 해상도를 제공 하는 gettimeofday () 함수를 사용할 수 있습니다 .

부수적으로, clock ()은 많은 (전부는 아님) 시스템에서 잘못 구현되어 정확하지는 않기 때문에 clock ()을 사용하지 않는 것이 좋습니다. 단, 프로그램이 CPU에 소비 한 시간과 귀하의 질문에 따라 귀하가 측정하고 싶은 것으로 가정하는 프로그램의 총 수명이 아닙니다.

모든 솔루션이 시스템에서 작동하지 않습니다.

사용할 수 있습니다

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

이 프로그램은 매력처럼 작동합니다.

모든 사람들이 여기에서 권장하는 일반적인 clock ()은 어떤 이유로 든 화면에서 그리기 또는 파일 읽기와 같은 부작용이없는 정적 코드조차도 실행에서 크게 벗어납니다. CPU가 전력 소비 모드, 다른 우선 순위를 제공하는 OS 등을 변경하기 때문일 수 있습니다.

따라서 clock ()을 사용하여 매번 동일한 결과를 안정적으로 얻을 수있는 유일한 방법은 측정 코드를 여러 번 반복하여 (몇 분 동안) 컴파일러가 최적화하지 못하도록 예방 조치를 취하는 것입니다. 최신 컴파일러는 코드를 미리 계산할 수 있습니다 루프에서 부작용을 일으키지 않고 루프 밖으로 이동합니다. 예를 들어 각 반복에 임의의 입력을 사용하는 것과 같습니다.

충분한 샘플이 배열로 수집 된 후 배열을 정렬하고 중간 값이라는 중간 요소를 가져옵니다. 안티 바이러스는 모든 CPU를 차지하는 안티 바이러스 나 일부 업데이트를 수행하는 OS와 같이 극단적 인 편차를 없애기 때문에 평균보다 낫습니다.

다음은 중앙값 근처의 값을 평균화하여 C / C ++ 코드의 실행 성능을 측정하는 간단한 유틸리티입니다. https://github.com/saniv/gauge

나는 여전히 코드를 측정하는 더 강력하고 빠른 방법을 찾고 있습니다. OS없이 베어 메탈에서 제어 된 조건에서 코드를 실행하려고 시도 할 수는 있지만 실제로는 OS가 관여하기 때문에 비현실적인 결과를 얻을 수 있습니다.

x86에는 실제 실행되는 명령 수를 포함하여 이러한 하드웨어 성능 카운터가 있지만 OS의 도움 없이는 접근하기가 까다 롭고 해석하기가 어렵고 자체 문제가 있습니다 ( http://archive.gamedev.net/archive/reference/articles /article213.html ). 여전히 병목 현상의 특성 (데이터 액세스 또는 해당 데이터의 실제 계산)을 조사하는 데 도움이 될 수 있습니다.

일부는 다른 종류의 입력이 유용하다는 것을 알 수 있습니다. NVidia CUDA를 사용한 GPGPU 프로그래밍에 대한 대학 과정의 일부로 시간을 측정하는이 방법을 받았습니다 ( 코스 설명 ). 이전 게시물에서 보았던 방법을 결합한 것입니다. 요구 사항에 신뢰성이 있기 때문에 간단히 게시합니다.

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