Waktu pelaksanaan program C.

209

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

Roger
sumber
3
kerangka kerja OS / API apa yang Anda gunakan / tersedia? C biasa saja?
typo.pl
4
Ini program yang agak kecil, hanya C
Roger
Saya telah menulis secara terperinci tentang penerapan solusi portabel dalam jawaban ini: stackoverflow.com/questions/361363/…
Alexander Saprykin
waktu yang diperlukan untuk menjalankan fungsi stackoverflow.com/a/40380118/6180077 yang
Abdullah Farweez

Jawaban:

344

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.

Thomas Pornin
sumber
1
Ini memberi saya hasil yang sangat acak - saya mendapatkan campuran angka besar / kecil / negatif atas potongan kode yang sama. GCC 4.7 Linux 3.2 AMD64
3
Ya: clock()mengembalikan waktu dalam skala internal yang disebut "jam", dan CLOCKS_PER_SECmerupakan jumlah jam per detik, jadi bagilah dengan CLOCKS_PER_SECmenghasilkan waktu dalam detik. Dalam kode di atas, nilainya adalah doublejadi Anda dapat mengaturnya sesuka hati.
Thomas Pornin
18
Peringatan besar: clock () mengembalikan jumlah waktu yang dihabiskan OS untuk menjalankan proses Anda, dan bukan jumlah aktual waktu yang berlalu. Namun, ini baik untuk menentukan waktu blok kode, tetapi tidak mengukur waktu yang berlalu di dunia nyata.
2
Dia mengatakan ingin mengukur program multi-utas. Saya tidak yakin jam () cocok untuk ini, karena meringkas waktu berjalan semua utas, sehingga hasilnya akan terlihat seperti jika kode dijalankan secara berurutan. Untuk hal-hal seperti itu saya menggunakan omp_get_wtime (), tetapi tentu saja saya perlu memastikan, sistem tidak sibuk dengan proses lain.
Youda008
1
Saya harus menyebutkan beberapa hal meskipun utas ini lebih relevan setahun yang lalu: CLOCKS_PER_SECadalah long intdengan nilai 1000000, memberikan waktu dalam mikrodetik saat tidak dibagi; bukan siklus jam CPU. Oleh karena itu, tidak perlu memperhitungkan frekuensi dinamis karena jam di sini dalam mikrodetik (mungkin siklus jam untuk CPU 1 MHz?) Saya membuat program C pendek yang mencetak nilai dan itu adalah 1000000 pada laptop i7-2640M saya, dengan frekuensi dinamis yang memungkinkan 800 MHz hingga 2,8 GHz, bahkan menggunakan Turbo Boost setinggi 3,5 GHz.
DDPWNAGE
111

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

S..K
sumber
3
@ acgtyrant tetapi hanya untuk program-program sederhana, karena ini akan menghabiskan seluruh waktu program, termasuk input, output, dll.
phuclv
1
Jika Anda menggunakan Linux, dan Anda telah mengurangi tolok ukur (mikro) Anda ke sebuah program dengan overhead startup yang dapat diabaikan, mis. Executable statis yang menjalankan hot loop Anda selama beberapa detik, Anda dapat menggunakan perf stat ./a.outuntuk mendapatkan penghitung kinerja HW untuk kesalahan cache dan mispredict cabang, dan IPC.
Peter Cordes
61

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;
}
Alexandre C.
sumber
6
Nama variabel terbaik yang pernah saya lihat. tic = "time in clock", toc = "time out clock". Tetapi juga tic-toc = "tick-tock". Beginilah cara saya memberi label waktu sejak saat ini.
Logan Schelly
60

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.

Wes Hardaker
sumber
2
Kompiler MinGW berbasis GCC. Jadi itu akan berhasil. Tetapi jika Anda menggunakan kompiler C visual, maka Anda akan mendapatkan kesalahan.
user2550754
11
Ya, itu akan bekerja pada windows dengan perpustakaan ac yang mendukung panggilan gettimeofday. Sebenarnya tidak masalah apa kompilernya, Anda hanya perlu menautkannya dengan pustaka libc yang layak. Yang mana, dalam kasus mingw, bukan yang standar.
Wes Hardaker
1
Ini berfungsi untuk saya di Windows XP dengan cygwin gcc & Linux Ubuntu. Inilah yang saya inginkan.
Cinta dan kedamaian - Joe Codeswell
gettimeofdaysudah usang dan tidak disarankan untuk kode baru. Halaman manual POSIX-nya merekomendasikan clock_gettime sebagai gantinya, yang memungkinkan Anda meminta CLOCK_MONOTONIChal itu tidak terpengaruh oleh perubahan pada jam sistem, dan karenanya lebih baik sebagai interval waktu. (Lihat jawaban Johnll ). Pada sistem Linux modern, misalnya, gettimeofday pada dasarnya adalah pembungkus untuk clock_gettime yang mengubah nanodetik menjadi mikrodetik.
Peter Cordes
12

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

adimoh
sumber
Di Windows setidaknya faktornya adalah setidaknya 100 tetapi tidak 1000 dan itu tidak tepat
boctulus
6
Jawaban ini tidak menambahkan sesuatu yang tidak di Alexandre C 's jawaban dari dua tahun sebelumnya.
Jonathan Leffler
3
@boctulus: 1s selalu 1000 ms , juga di windows.
alk
9

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.

Stephen
sumber
1
Terima kasih atas informasinya tetapi apakah ada alternatif yang lebih baik?
ozanmuyes
4
Ini bukan masalah praktis: ya sistem Posix selalu punya CLOCK_PER_SEC==1000000, tetapi pada saat yang sama, mereka semua menggunakan presisi 1-μs untuk implementasi clock mereka (); omong-omong, ini memiliki properti yang bagus untuk mengurangi masalah berbagi. Jika Anda ingin mengukur peristiwa yang berpotensi sangat cepat, katakan di bawah 1 ms, maka Anda harus terlebih dahulu khawatir tentang keakuratan (atau resolusi) dari fungsi clock (), yang tentu lebih kasar dari 1μs di Posix, tetapi juga sering lebih kasar; solusi yang biasa adalah dengan menjalankan tes berkali-kali; pertanyaan yang diajukan sepertinya tidak membutuhkannya.
AntoineL
Mengapa itu bukan solusi yang baik? Anda mendapatkan nilai dari clock(), jika Anda membagi nilai itu dengan CLOCK_PER_SECAnda dijamin mendapatkan waktu dalam hitungan detik cpu ambil. Tanggung jawab mengukur kecepatan clock aktual adalah tanggung jawab clock()fungsi, bukan tanggung jawab Anda.
Zaffy
9

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.
hklel
sumber
4

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!

redent84
sumber
4

(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.
JohnSll
sumber
Bisakah Anda menjelaskan perhitungan yang Anda gunakan untuk mendapatkan jumlah detik? Tidak jelas apa yang terjadi.
Colin Keenan
1
Bukankah ini (end.tv_nsec - begin.tv_nsec) / 1000000000.0menghasilkan 0selalu?
alk
@alk: tidak ada, membagi oleh doublepemicu literal int atau longuntuk doublekonversi sebelum divisi. Tentu saja Anda bisa tetap berpegang pada bilangan bulat dan mencetak tv_secbagian dan kemudian bagian pecahan dengan nol seperti %ld.%09ld, tetapi mengkonversi menjadi dua kali lebih mudah dan presisi 53 bit biasanya banyak untuk waktu benchmark.
Peter Cordes
1
(Ups, pengurangan bagian nanodetik mungkin perlu dibawa ke bagian detik, jadi gunakan ganda dan biarkan negatif menghindari masalah itu. Untuk menggunakan string format integer murni, Anda akan memerlukan timespec_subtractseperti yang timeval_subtractdisarankan dalam manual glibc : gnu.org/software/libc/manual/html_node/Elapsed-Time.html )
Peter Cordes
3

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.

Shinnok
sumber
ISO C Standard (dengan asumsi inilah arti ANSI C ) dengan sengaja tidak menentukan ketepatan fungsi waktu . Kemudian khusus pada implementasi POSIX, atau pada Windows, ketepatan fungsi jam dinding (lihat jawaban Thomas) dalam hitungan detik. Tetapi presisi clock () biasanya lebih besar, dan selalu 1μs di Posix (terlepas dari akurasi.)
AntoineL
2

Setiap solusi tidak berfungsi di sistem saya.

Saya bisa menggunakannya

#include <time.h>

double difftime(time_t time1, time_t time0);
Ankit Chilamatur
sumber
2
Ini memberikan perbedaan antara dua time_tnilai sebagai nilai ganda. Karena time_tnilai hanya akurat hingga sedetik, nilai itu terbatas dalam mencetak waktu yang dibutuhkan oleh program yang berjalan singkat, meskipun mungkin berguna untuk program yang berjalan untuk jangka waktu lama.
Jonathan Leffler
Untuk alasan apa pun, melewati sepasang clock_ts difftimesepertinya bekerja untuk saya hingga seperseratus detik. Ini ada di linux x86. Saya juga tidak bisa mendapatkan pengurangan stopdan startuntuk bekerja.
ragerdl
@ragerdl: Anda harus beralih ke difftime() clock() / CLOCKS_PER_SEC, seperti yang diharapkan detik.
alk
2
    #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.

Ravi Kumar Yadav
sumber
2

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

SmugLispWeenie
sumber
Ya, CPU x86 modern idle jauh lebih lambat daripada max turbo. Bergantung pada pengaturan "gubernur", meningkatkan hingga kecepatan clock maksimum mungkin memerlukan milidetik (Skylake dengan manajemen P-state perangkat keras, terutama dengan pengaturan energy_performance_preference diatur ke performance) atau puluhan milidetik. en.wikipedia.org/wiki/Dynamic_frequency_scaling . Dan ya, kinerja median biasanya merupakan pilihan yang baik; kelas atas biasanya memiliki beberapa paku dari gangguan.
Peter Cordes
Seringkali taruhan terbaik Anda untuk menghindari pekerjaan tidak optimal adalah input baris perintah dan mengembalikan hasilnya. Atau tulis fungsi dalam file terpisah dari mainyang mengambil argumen dan mengembalikan hasil, dan jangan gunakan optimasi waktu tautan. Maka kompiler tidak bisa memasukkannya ke pemanggil. Hanya berfungsi jika fungsinya sudah termasuk semacam loop, jika tidak panggilan / ret overhead terlalu tinggi.
Peter Cordes
Kompiler masih dapat mengoptimalkan input baris perintah tunggal dari loop, jika Anda memprosesnya dengan kode statis tanpa efek samping. Jadi yang terbaik adalah menghasilkan input acak untuk setiap iterasi. Jelas rand () harus dipanggil di luar kode yang diukur, sebelum jam pertama (), karena rand () juga dapat menghasilkan panggilan sistem, pengambilan sampel beberapa generator entropi perangkat keras (yang pada sistem yang lebih lama adalah pergerakan mouse). Hanya saja, jangan lupa untuk mencetak setiap bit dari output, jika tidak kompiler dapat memutuskan Anda tidak perlu semua output secara keseluruhan atau bagian dari itu. Itu bisa dilakukan dengan mengatakan CRC32.
SmugLispWeenie
Jika kode Anda diuji di dalam file terpisah dan Anda tidak menggunakan optimasi waktu-tautan, tidak mungkin kompiler dapat melakukan CSE untuk mengoptimalkan antar panggilan. Penelepon tidak dapat berasumsi tentang callee yang tidak memiliki efek samping yang terlihat. Ini memungkinkan Anda memasukkan sesuatu yang relatif pendek ke dalam loop berulang untuk membuatnya cukup lama, dengan hanya memanggil / ret overhead. Jika Anda membiarkannya sebaris, maka Anda harus memeriksa asm yang dihasilkan untuk memastikan itu tidak menaikkan perhitungan dari loop seperti yang Anda katakan.
Peter Cordes
Cara khusus kompiler adalah dengan menggunakan (misalnya) GNU C inline asm untuk memaksa kompiler mewujudkan hasil dalam register, dan / atau melupakan apa yang diketahui tentang nilai variabel, tanpa benar-benar memperkenalkan instruksi tambahan. Setara dengan "Escape" dan "Clobber" dalam tautan MSVC ke video tentang profiling dan microbenchmarking (pembicaraan dentang pengembang Chandler Carruth's CppCon 2015) Tidak ada yang setara MSVC, tetapi pertanyaan itu sendiri menunjukkan fungsi GNU C dan bagaimana menggunakannya.
Peter Cordes
0

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.

ワ イ き ん ぐ
sumber
1
gettimeofday sudah usang dan tidak direkomendasikan. Halaman manual POSIX clock_gettimesebagai gantinya merekomendasikan , yang memungkinkan Anda meminta CLOCK_MONOTONICyang tidak terpengaruh oleh perubahan jam sistem, dan karenanya lebih baik sebagai penghitung waktu jeda. Pada sistem Linux modern, misalnya, gettimeofdaypada dasarnya adalah pembungkus untuk clock_gettimeyang mengkonversi nanodetik ke mikrodetik. (Lihat jawaban Johnll).
Peter Cordes
Metode ini ditambahkan oleh @Wes Hardaker, perbedaan utamanya adalah menggunakan timeval_subtract.
ワ イ き ん ぐ
Oke, jadi satu-satunya bagian yang berguna dari jawaban Anda adalah nama fungsi yang tidak Anda tetapkan, dan itu tidak ada di pustaka standar. (Hanya di manual glibc: gnu.org/software/libc/manual/html_node/Elapsed-Time.html ).
Peter Cordes
-2

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");
}
JAGDISH DUDHATE
sumber
4
Ini tidak benar-benar menambahkan sesuatu yang baru dibandingkan dengan adimoh 's jawaban , kecuali bahwa itu mengisi 'executable code' blok (atau dua dari mereka) dengan beberapa kode yang sebenarnya. Dan bahwa jawaban tidak menambahkan sesuatu yang tidak di Alexandre C 's jawaban dari dua tahun sebelumnya.
Jonathan Leffler