Waktu pelaksanaan program C.

Saya memiliki program C yang bertujuan untuk dijalankan secara paralel pada beberapa prosesor. Saya harus dapat mencatat waktu eksekusi (yang bisa di mana saja dari 1 detik hingga beberapa menit). Saya telah mencari jawaban, tetapi semuanya sepertinya menyarankan untuk menggunakan clock()fungsi ini, yang kemudian melibatkan penghitungan jumlah jam yang diambil oleh program dibagi dengan Clocks_per_secondnilainya.

Saya tidak yakin bagaimana Clocks_per_secondnilai dihitung?

Di Jawa, saya hanya mengambil waktu saat ini dalam milidetik sebelum dan sesudah eksekusi.

Apakah ada hal serupa di C? Saya sudah melihat-lihat, tapi sepertinya saya tidak bisa menemukan cara untuk mendapatkan sesuatu yang lebih baik daripada resolusi kedua.

Saya juga tahu profiler akan menjadi pilihan, tetapi saya ingin mengimplementasikan timer sendiri.

Terima kasih

CLOCKS_PER_SECadalah konstanta yang dideklarasikan dalam <time.h>. Untuk mendapatkan waktu CPU yang digunakan oleh tugas dalam aplikasi C, gunakan:

clock_t begin = clock();

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

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

Perhatikan bahwa ini mengembalikan waktu sebagai tipe titik mengambang. Ini bisa lebih tepat daripada satu detik (misalnya Anda mengukur 4,52 detik). Ketepatan tergantung pada arsitektur; pada sistem modern Anda dengan mudah mendapatkan 10 ms atau lebih rendah, tetapi pada mesin Windows yang lebih lama (dari era Win98) lebih dekat ke 60 ms.

clock()adalah standar C; ini bekerja "di mana-mana". Ada fungsi spesifik sistem, seperti getrusage()pada sistem mirip Unix.

Java System.currentTimeMillis()tidak mengukur hal yang sama. Ini adalah "jam dinding": ini dapat membantu Anda mengukur berapa banyak waktu yang diperlukan untuk menjalankan program, tetapi tidak memberi tahu Anda berapa banyak waktu CPU yang digunakan. Pada sistem multitasking (yaitu semuanya), ini bisa sangat berbeda.

Jika Anda menggunakan shell Unix untuk menjalankan, Anda dapat menggunakan perintah waktu.

perbuatan

$ time ./a.out

dengan asumsi a.out sebagai executable akan memberi Anda waktu yang dibutuhkan untuk menjalankan ini

Dalam vanila C sederhana:

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

Anda secara fungsional menginginkan ini:

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

Perhatikan bahwa ini mengukur dalam mikrodetik, bukan hanya dalam hitungan detik.

Sebagian besar program sederhana memiliki waktu komputasi dalam mili detik. Jadi, saya kira, Anda akan menemukan ini berguna.

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

Jika Anda ingin menghitung runtime seluruh program dan Anda berada di sistem Unix, jalankan program Anda menggunakan perintah waktu seperti initime ./a.out

Banyak jawaban telah menyarankan clock()dan kemudian CLOCKS_PER_SECdari time.h. Ini mungkin ide yang buruk, karena ini yang dikatakan /bits/time.hfile saya :

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

Jadi CLOCKS_PER_SECmungkin didefinisikan sebagai 1000000, tergantung pada opsi apa yang Anda gunakan untuk mengkompilasi, dan dengan demikian itu tidak tampak seperti solusi yang baik.

Jawaban Thomas Pornin sebagai makro:

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

Gunakan seperti ini:

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

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

Keluaran:

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

Anda harus memperhitungkan bahwa mengukur waktu yang diperlukan untuk menjalankan suatu program sangat tergantung pada beban yang dimiliki mesin pada saat itu.

Mengetahui bahwa, cara memperoleh waktu saat ini di C dapat dicapai dengan cara yang berbeda, yang lebih mudah adalah:

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

Semoga ini bisa membantu.

Salam!

(Semua jawaban di sini kurang, jika sysadmin Anda mengubah waktu sistem, atau zona waktu Anda memiliki waktu musim dingin dan musim dingin yang berbeda. Karena itu ...)

Pada penggunaan linux: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); Tidak terpengaruh jika admin sistem mengubah waktu, atau Anda tinggal di negara dengan waktu musim dingin berbeda dari waktu musim panas, dll.

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

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 hanya menentukan fungsi waktu presisi kedua. Namun, jika Anda menjalankan dalam lingkungan POSIX Anda dapat menggunakan gettimeofday () yang memberikan resolusi mikrodetik waktu yang berlalu sejak UNIX Epoch.

Sebagai catatan, saya tidak akan merekomendasikan menggunakan clock () karena ini diimplementasikan dengan buruk pada banyak (jika tidak semua?) Sistem dan tidak akurat, selain itu hanya merujuk pada berapa lama program Anda menghabiskan pada CPU dan bukan total umur program, yang menurut pertanyaan Anda adalah apa yang saya asumsikan ingin Anda ukur.

Setiap solusi tidak berfungsi di sistem saya.

Saya bisa menggunakannya

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

Program ini akan bekerja seperti pesona.

Saya telah menemukan bahwa jam biasa (), semua orang merekomendasikan di sini, untuk beberapa alasan menyimpang dari menjalankan untuk menjalankan, bahkan untuk kode statis tanpa efek samping, seperti menggambar ke layar atau membaca file. Bisa jadi karena CPU mengubah mode konsumsi daya, OS memberikan prioritas yang berbeda, dll ...

Jadi satu-satunya cara untuk secara andal mendapatkan hasil yang sama setiap kali dengan clock () adalah dengan menjalankan kode terukur dalam satu loop beberapa kali (selama beberapa menit), mengambil tindakan pencegahan untuk mencegah kompiler mengoptimalkannya: kompiler modern dapat melakukan precode kode tanpa efek samping berjalan dalam satu lingkaran, dan memindahkannya keluar dari loop., seperti menggunakan input acak untuk setiap iterasi.

Setelah cukup sampel dikumpulkan ke dalam array, satu macam array itu, dan mengambil elemen tengah, yang disebut median. Median lebih baik daripada rata-rata, karena itu membuang penyimpangan ekstrim, seperti mengatakan antivirus mengambil semua CPU atau OS melakukan beberapa pembaruan.

Berikut ini adalah utilitas sederhana untuk mengukur kinerja eksekusi kode C / C ++, rata-rata nilai dekat median: https://github.com/saniv/gauge

Saya sendiri masih mencari cara yang lebih kuat dan lebih cepat untuk mengukur kode. Seseorang mungkin dapat mencoba menjalankan kode dalam kondisi terkendali pada bare metal tanpa OS apa pun, tetapi itu akan memberikan hasil yang tidak realistis, karena pada kenyataannya OS memang terlibat.

x86 memiliki penghitung kinerja perangkat keras ini, yang termasuk jumlah instruksi aktual yang dijalankan, tetapi mereka sulit diakses tanpa bantuan OS, sulit ditafsirkan dan memiliki masalah sendiri ( http://archive.gamedev.net/archive/reference/articles /article213.html ). Tetap mereka bisa membantu menyelidiki sifat leher botol (akses data atau perhitungan aktual pada data itu).

Beberapa mungkin menemukan jenis input yang berbeda berguna: Saya diberikan metode ini untuk mengukur waktu sebagai bagian dari program universitas tentang pemrograman GPGPU dengan NVidia CUDA ( deskripsi kursus ). Ini menggabungkan metode yang terlihat di posting sebelumnya, dan saya hanya mempostingnya karena persyaratan memberikan kredibilitas:

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

Saya kira Anda bisa mengalikan dengan mis 1.0 / 1000.0untuk mendapatkan unit pengukuran yang sesuai dengan kebutuhan Anda.

Perbandingan waktu eksekusi semacam gelembung dan jenis pilihan Saya memiliki program yang membandingkan waktu pelaksanaan jenis gelembung dan jenis pilihan. Untuk mengetahui waktu eksekusi suatu blok kode hitung waktu sebelum dan sesudah blok dengan

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

Kode contoh:

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