เวลาดำเนินการของโปรแกรม C

ฉันมีโปรแกรม C ที่มีวัตถุประสงค์เพื่อให้ทำงานแบบขนานกับโปรเซสเซอร์หลายตัว ฉันต้องสามารถบันทึกเวลาดำเนินการ (ซึ่งอาจเป็นที่ใดก็ได้จาก 1 วินาทีถึงหลายนาที) ฉันค้นหาคำตอบแล้ว แต่พวกเขาดูเหมือนจะแนะนำให้ใช้clock()ฟังก์ชันซึ่งเกี่ยวข้องกับการคำนวณจำนวนนาฬิกาที่โปรแกรมใช้หารด้วยClocks_per_secondค่า

ฉันไม่แน่ใจว่าClocks_per_secondคำนวณค่าได้อย่างไร?

ใน Java ฉันใช้เวลาปัจจุบันเป็นมิลลิวินาทีก่อนและหลังการทำงาน

มีสิ่งที่คล้ายกันใน C? ฉันดูแล้ว แต่ฉันไม่สามารถหาวิธีที่จะได้อะไรที่ดีไปกว่าความละเอียดที่สอง

ฉันยังรู้ว่า profiler จะเป็นตัวเลือก แต่ฉันต้องการใช้ตัวจับเวลา

ขอบคุณ

CLOCKS_PER_SEC<time.h>เป็นค่าคงที่ซึ่งจะมีการประกาศใน ในการรับเวลา CPU ที่ใช้โดยงานภายในแอปพลิเคชัน 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 วินาที) ความแม่นยำขึ้นอยู่กับสถาปัตยกรรม ในระบบที่ทันสมัยคุณจะได้รับ 10ms หรือต่ำกว่าได้ง่าย แต่สำหรับเครื่อง Windows รุ่นเก่า (จากยุค Win98) มันใกล้ถึง 60ms

clock()คือมาตรฐาน C; มันทำงานได้ "ทุกที่" มีฟังก์ชั่นเฉพาะgetrusage()ระบบเช่นระบบ Unix

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

หวังว่ามันจะช่วย

ความนับถือ!

(คำตอบทั้งหมดที่นี่ขาดหากดูแลระบบของคุณเปลี่ยน systemtime หรือเขตเวลาของคุณมีฤดูหนาวและซัมเมอร์ต่างกันดังนั้น ... )

เกี่ยวกับการใช้งาน 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 Epoch

ในฐานะที่เป็นหมายเหตุด้านข้างฉันไม่แนะนำให้ใช้ 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);
}

โปรแกรมนี้จะทำงานเหมือนมีเสน่ห์

ฉันพบว่านาฬิกาปกติ () ทุกคนแนะนำที่นี่ด้วยเหตุผลบางอย่างเบี่ยงเบนอย่างรุนแรงจากการทำงานเพื่อเรียกใช้แม้สำหรับรหัสคงที่ไม่มีผลข้างเคียงใด ๆ เช่นการวาดภาพไปที่หน้าจอหรือการอ่านไฟล์ อาจเป็นเพราะ CPU เปลี่ยนโหมดการใช้พลังงานระบบปฏิบัติการที่ให้ความสำคัญต่างกัน ฯลฯ

ดังนั้นวิธีเดียวที่จะได้ผลลัพธ์เดียวกันอย่างน่าเชื่อถือทุกครั้งที่มีนาฬิกา () คือการเรียกใช้โค้ดที่วัดได้ในลูปหลาย ๆ ครั้ง (เป็นเวลาหลายนาที) การระมัดระวังเพื่อป้องกันคอมไพเลอร์จากการปรับมันออก: คอมไพเลอร์สมัยใหม่ ไม่มีผลข้างเคียงที่ทำงานในลูปและย้ายออกจากลูปเช่นใช้การสุ่มอินพุตสำหรับการวนซ้ำแต่ละครั้ง

หลังจากเก็บตัวอย่างเพียงพอไปยังอาร์เรย์หนึ่งประเภทนั้นจะเรียงลำดับและใช้องค์ประกอบกลางเรียกว่ามัธยฐาน ค่ามัธยฐานนั้นดีกว่าค่าเฉลี่ยเพราะมันเบี่ยงเบนความเบี่ยงเบนอย่างสุดขั้วออกไปเช่นบอกว่าการป้องกันไวรัสทำให้ CPU ทั้งหมดหรือระบบปฏิบัติการทำการอัพเดท

นี่คือยูทิลิตี้ง่าย ๆ ในการวัดประสิทธิภาพการทำงานของรหัส C / C ++ โดยเฉลี่ยค่าใกล้กับค่ามัธยฐาน: https://github.com/saniv/gauge

ฉันเองยังคงมองหาวิธีที่แข็งแกร่งและเร็วกว่าในการวัดโค้ด หนึ่งอาจลองใช้รหัสในสภาพควบคุมบนโลหะเปลือยโดยไม่มีระบบปฏิบัติการใด ๆ แต่ที่จะให้ผลลัพธ์ที่ไม่สมจริงเพราะในความเป็นจริงระบบปฏิบัติการจะมีส่วนร่วม

x86 มีตัวนับประสิทธิภาพของฮาร์ดแวร์เหล่านี้ซึ่งรวมถึงจำนวนคำสั่งที่เรียกใช้จริง แต่ทำได้ยากหากต้องการเข้าถึงโดยไม่ต้องใช้ระบบปฏิบัติการช่วยเหลือยากที่จะตีความและมีปัญหาของตัวเอง ( http://archive.gamedev.net/archive/reference/articles/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");
}