Thời gian thực hiện chương trình C

Tôi có một chương trình C nhằm mục đích chạy song song trên một số bộ xử lý. Tôi cần có khả năng ghi lại thời gian thực hiện (có thể là từ 1 giây đến vài phút). Tôi đã tìm kiếm câu trả lời, nhưng tất cả chúng dường như đề nghị sử dụng clock()hàm, sau đó liên quan đến việc tính toán số lượng đồng hồ mà chương trình đã chia cho Clocks_per_secondgiá trị.

Tôi không chắc cách tính Clocks_per_secondgiá trị?

Trong Java, tôi chỉ mất thời gian hiện tại tính bằng mili giây trước và sau khi thực hiện.

Có một điều tương tự trong C? Tôi đã có một cái nhìn, nhưng dường như tôi không thể tìm ra cách nào để có được bất cứ điều gì tốt hơn một độ phân giải thứ hai.

Tôi cũng biết rằng một hồ sơ sẽ là một lựa chọn, nhưng tôi đang tìm cách tự thực hiện một bộ đếm thời gian.

Cảm ơn

CLOCKS_PER_SEClà một hằng số được khai báo trong <time.h>. Để lấy thời gian CPU được sử dụng bởi một tác vụ trong ứng dụng C, hãy sử dụng:

clock_t begin = clock();

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

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

Lưu ý rằng điều này trả về thời gian dưới dạng loại dấu phẩy động. Điều này có thể chính xác hơn một giây (ví dụ: bạn đo 4,52 giây). Độ chính xác phụ thuộc vào kiến ​​trúc; trên các hệ thống hiện đại, bạn dễ dàng nhận được 10ms hoặc thấp hơn, nhưng trên các máy Windows cũ hơn (từ thời Win98), nó đã đạt gần 60ms.

clock()là tiêu chuẩn C; nó hoạt động "ở mọi nơi". Có các chức năng dành riêng cho hệ thống, chẳng hạn như getrusage()trên các hệ thống giống Unix.

Java System.currentTimeMillis()không đo lường điều tương tự. Đây là một "đồng hồ treo tường": nó có thể giúp bạn đo thời gian để chương trình thực hiện, nhưng nó không cho bạn biết thời gian sử dụng CPU là bao nhiêu. Trên một hệ thống đa nhiệm (tức là tất cả chúng), chúng có thể khác nhau rất nhiều.

Nếu bạn đang sử dụng shell Unix để chạy, bạn có thể sử dụng lệnh time.

đang làm

$ time ./a.out

giả sử a.out là tệp thực thi sẽ cho bạn thời gian để chạy cái này

Ở đồng bằng vani 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;
}

Bạn có chức năng muốn điều này:

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

Lưu ý rằng biện pháp này tính bằng micrô giây, không chỉ giây.

Hầu hết các chương trình đơn giản có thời gian tính toán tính bằng mili giây. Vì vậy, tôi cho rằng, bạn sẽ tìm thấy điều này hữu ích.

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

Nếu bạn muốn tính thời gian chạy của toàn bộ chương trình và bạn đang sử dụng hệ thống Unix, hãy chạy chương trình của bạn bằng lệnh thời gian như thế nàytime ./a.out

Rất nhiều câu trả lời đã được gợi ý clock()và sau đó CLOCKS_PER_SECtừ time.h. Đây có lẽ là một ý tưởng tồi, bởi vì đây là những gì /bits/time.htập tin của tôi nói:

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

Vì vậy, CLOCKS_PER_SECcó thể được định nghĩa là 1000000, tùy thuộc vào những tùy chọn bạn sử dụng để biên dịch, và do đó nó có vẻ không phải là một giải pháp tốt.

Câu trả lời của Thomas Pornin là macro:

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

Sử dụng nó như thế này:

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

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

Đầu ra:

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

Bạn phải tính đến việc đo thời gian thực hiện một chương trình để thực hiện phụ thuộc rất nhiều vào tải mà máy có trong thời điểm cụ thể đó.

Biết rằng, cách lấy được thời gian hiện tại trong C có thể đạt được theo những cách khác nhau, một cách dễ dàng hơn là:

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

Hy vọng nó giúp.

Trân trọng!

(Tất cả các câu trả lời ở đây đều thiếu, nếu sysadmin của bạn thay đổi thời gian hệ thống hoặc múi giờ của bạn có thời gian mùa đông và thời gian khác nhau. Do đó ...)

Khi sử dụng linux: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); Sẽ không bị ảnh hưởng nếu quản trị viên hệ thống thay đổi thời gian hoặc bạn sống ở một quốc gia có thời gian mùa đông khác với thời gian mùa hè, v.v.

#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 Những trạng thái:

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 chỉ xác định các hàm thời gian chính xác thứ hai. Tuy nhiên, nếu bạn đang chạy trong môi trường POSIX, bạn có thể sử dụng gettimeofday () cung cấp độ phân giải thời gian micro giây trong thời gian kể từ UNIX Epoch.

Một lưu ý phụ, tôi không khuyên bạn nên sử dụng clock () vì nó được triển khai kém trên nhiều hệ thống (nếu không phải tất cả?) Và không chính xác, bên cạnh thực tế là nó chỉ đề cập đến thời gian chương trình của bạn dành cho CPU và không phải là toàn bộ thời gian của chương trình, mà theo câu hỏi của bạn là những gì tôi cho rằng bạn muốn đo lường.

Mọi giải pháp đều không hoạt động trong hệ thống của tôi.

Tôi có thể sử dụng

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

Chương trình này sẽ hoạt động như quyến rũ.

Tôi đã thấy rằng đồng hồ thông thường (), mọi người đều khuyên dùng ở đây, vì một số lý do khiến chúng ta chạy lệch khỏi chạy để chạy, ngay cả đối với mã tĩnh mà không có bất kỳ tác dụng phụ nào, như vẽ lên màn hình hoặc đọc tệp. Có thể là do CPU thay đổi chế độ tiêu thụ năng lượng, HĐH đưa ra các ưu tiên khác nhau, v.v ...

Vì vậy, cách duy nhất để có được kết quả tương tự mỗi lần với clock () là chạy mã được đo trong một vòng lặp nhiều lần (trong vài phút), thực hiện các biện pháp phòng ngừa để ngăn chặn trình biên dịch tối ưu hóa: trình biên dịch hiện đại có thể tính toán trước mã không có tác dụng phụ chạy trong một vòng lặp và di chuyển nó ra khỏi vòng lặp., giống như sử dụng đầu vào ngẫu nhiên cho mỗi lần lặp.

Sau khi đủ các mẫu được thu thập vào một mảng, người ta sắp xếp mảng đó và lấy phần tử ở giữa, được gọi là trung vị. Median tốt hơn mức trung bình, bởi vì nó loại bỏ các độ lệch cực lớn, như nói rằng chương trình chống vi-rút chiếm hết CPU hoặc HĐH thực hiện một số cập nhật.

Đây là một tiện ích đơn giản để đo hiệu suất thực thi của mã C / C ++, tính trung bình các giá trị gần trung vị: https://github.com/saniv/gauge

Bản thân tôi vẫn đang tìm kiếm một cách mạnh mẽ hơn và nhanh hơn để đo lường mã. Người ta có thể thử chạy mã trong các điều kiện được kiểm soát trên kim loại trần mà không cần bất kỳ HĐH nào, nhưng điều đó sẽ cho kết quả không thực tế, bởi vì trong thực tế, HĐH có liên quan.

x86 có các bộ đếm hiệu suất phần cứng này, bao gồm số lượng lệnh thực tế được thực thi, nhưng chúng rất khó truy cập mà không có sự trợ giúp của hệ điều hành, khó diễn giải và có vấn đề riêng ( http://archive.gamedev.net/archive/reference/articles /article213.html ). Tuy nhiên, chúng có thể hữu ích trong việc điều tra bản chất của cổ chai (truy cập dữ liệu hoặc tính toán thực tế trên dữ liệu đó).

Một số có thể thấy một loại đầu vào khác hữu ích: Tôi đã được cung cấp phương pháp đo thời gian này như một phần của khóa học đại học về lập trình GPGPU với NVidia CUDA ( mô tả khóa học ). Nó kết hợp các phương thức được thấy trong các bài viết trước đó và tôi chỉ đơn giản đăng nó vì các yêu cầu mang lại cho nó sự tin cậy:

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

Tôi cho rằng bạn có thể nhân với ví dụ 1.0 / 1000.0để có được đơn vị đo phù hợp với nhu cầu của bạn.

So sánh thời gian thực hiện sắp xếp bong bóng và sắp xếp lựa chọn Tôi có một chương trình so sánh thời gian thực hiện sắp xếp bong bóng và sắp xếp lựa chọn. Để tìm ra thời gian thực hiện một khối mã tính thời gian trước và sau khối bằng

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

Mã ví dụ:

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