C programının yürütme süresi

Birkaç işlemci üzerinde paralel çalıştırmayı amaçlayan bir C programım var. Yürütme süresini (1 saniye ile birkaç dakika arasında herhangi bir yerde olabilir) kaydedebilmeliyim. Cevapları aradım, ama hepsi clock()fonksiyonun kullanılmasını öneriyor gibi görünüyor , bu da programın aldığı saat sayısının Clocks_per_seconddeğere bölünmesini hesaplıyor .

Clocks_per_secondDeğerin nasıl hesaplandığından emin değilim ?

Java'da, yürütmeden önce ve sonra şimdiki zamanı milisaniye olarak alıyorum.

C'de benzer bir şey var mı? Bir baktım, ama ikinci bir çözünürlükten daha iyi bir şey elde etmenin bir yolunu bulamıyorum.

Bir profil oluşturucunun bir seçenek olacağını da biliyorum, ama kendime bir zamanlayıcı uygulamak istiyorum.

Teşekkürler

CLOCKS_PER_SECiçinde bildirilen bir sabittir <time.h>. C uygulamasındaki bir görev tarafından kullanılan CPU zamanını almak için şunu kullanın:

clock_t begin = clock();

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

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

Bunun süreyi kayan nokta türü olarak döndürdüğünü unutmayın. Bu bir saniyeden daha kesin olabilir (örneğin 4.52 saniyeyi ölçersiniz). Hassasiyet mimariye bağlıdır; modern sistemlerde kolayca 10ms veya daha düşüktür, ancak eski Windows makinelerinde (Win98 döneminden) 60ms'ye daha yakındı.

clock()R, standart C'dir; "her yerde" çalışır. getrusage()Unix benzeri sistemlerde olduğu gibi sisteme özgü işlevler vardır .

Java System.currentTimeMillis()aynı şeyi ölçmez. Bu bir "duvar saati" dir: programın yürütülmesi için geçen süreyi ölçmenize yardımcı olabilir, ancak ne kadar CPU zamanı kullanıldığını size söylemez. Çok görevli sistemlerde (yani hepsi), bunlar büyük ölçüde farklı olabilir.

Unix kabuğunu çalıştırmak için kullanıyorsanız, time komutunu kullanabilirsiniz.

iş

$ time ./a.out

çalıştırılabilir olarak a.out varsayarsak u bunu çalıştırmak için gereken zamanı verecektir

Düz vanilya C'de:

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

İşlevsel olarak bunu istiyorsunuz:

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

Bunun sadece saniyeler değil mikrosaniye cinsinden ölçüldüğünü unutmayın.

Basit programların çoğunun hesaplama süresi milisaniye cinsindendir. Yani, sanırım, bunu faydalı bulacaksınız.

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

Tüm programın çalışma zamanını hesaplamak istiyorsanız ve bir Unix sistemindeyseniz, zaman komutunu kullanarak programınızı çalıştırıntime ./a.out

Bir sürü cevap önerdi clock()ve sonra CLOCKS_PER_SECgeldi time.h. Bu muhtemelen kötü bir fikir çünkü /bits/time.hdosyam şöyle diyor:

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

Bu nedenle CLOCKS_PER_SEC, derlemek için kullandığınız seçeneklere bağlı olarak 1000000 olarak tanımlanabilir ve bu nedenle iyi bir çözüm gibi görünmez.

Thomas Pornin'in makro olarak cevabı:

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

Şöyle kullanın:

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

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

Çıktı:

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

Bir programın yürütülmesi için geçen sürenin ölçülmesinin , makinenin o andaki yüküne büyük ölçüde bağlı olduğunu dikkate almalısınız.

C'de şimdiki zamanı elde etmenin farklı yollarla elde edilebileceğini bilerek, daha kolay olanı:

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

Umarım yardımcı olur.

Saygılarımızla!

(Sistem yöneticiniz sistem saatini değiştirirse veya saat diliminizde farklı kış ve sommer süreleri varsa, buradaki tüm cevaplar eksiktir. Bu nedenle ...)

Linux kullanımında: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); Sistem yöneticisi zamanı değiştirirse veya kış saati yaz saatinden farklı bir ülkede yaşıyorsanız etkilenmez.

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

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 yalnızca ikinci hassas zaman fonksiyonlarını belirtir. Ancak, POSIX ortamında çalışıyorsanız gettimeofday () yöntemini kullanabilirsiniz. , UNIX Çağından bu yana geçen sürenin mikrosaniye çözünürlüğünü sağlayan işlevini .

Yan not olarak, birçok (hepsi değilse de?) Sistemlerde kötü bir şekilde uygulandığı ve doğru olmadığı için clock () kullanılmasını önermem, ayrıca programınızın CPU üzerinde ne kadar zaman harcadığını ve programın toplam ömrü değil, sorunuza göre ölçmek istediğinizi varsayıyorum.

Her çözüm benim sistemimde çalışmıyor.

Kullanabilirim

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

Bu program cazibe gibi çalışacaktır.

Ben her zamanki saat (), herkesin burada tavsiye, bazı nedenlerle ekrandan çizim veya okuma dosyaları gibi herhangi bir yan etkisi olmayan statik kod için bile, çalıştırmak çalıştırmak için çılgınca saptığını buldum. Bunun nedeni CPU'nun güç tüketimi modlarını, işletim sisteminin farklı öncelikler vermesini vb.

Bu nedenle, clock () ile her seferinde aynı sonucu güvenilir bir şekilde almanın tek yolu, ölçülen kodu bir döngüde birkaç kez (birkaç dakika) çalıştırmak ve derleyicinin optimize etmesini önlemek için önlemler almaktır: modern derleyiciler kodu önceden hesaplayabilir yan etkiler olmadan bir döngü içinde çalışır ve döngüden çıkarır, örneğin her yineleme için rasgele girdi kullanmak gibi.

Bir diziye yeterince örnek toplandıktan sonra, bir dizi bu diziyi sıralar ve medyan adı verilen orta öğeyi alır. Ortalamadan daha iyidir, çünkü antivirüsün tüm CPU'yu kapladığı veya işletim sisteminin bir miktar güncelleme yapması gibi aşırı sapmaları atar.

İşte medyan yakınındaki değerlerin ortalamasını alan C / C ++ kodunun yürütme performansını ölçmek için basit bir yardımcı program: https://github.com/saniv/gauge

Kendimi hala kod ölçmek için daha sağlam ve daha hızlı bir yol arıyorum. Muhtemelen herhangi bir işletim sistemi olmadan çıplak metal üzerinde kontrollü koşullarda kod çalıştırmayı deneyebilir, ancak bu gerçekçi olmayan sonuç verecektir, çünkü gerçekte işletim sistemi devreye girer.

x86, çalıştırılan gerçek talimatları içeren bu donanım performans sayaçlarına sahiptir, ancak işletim sistemi yardımı olmadan erişmek zordur, yorumlanması zordur ve kendi sorunları vardır ( http://archive.gamedev.net/archive/reference/articles /article213.html ). Yine de şişe boynunun doğasını araştırmaya yardımcı olabilirler (veri erişimi veya bu verilerdeki gerçek hesaplamalar).

Bazıları farklı türde bir girdi yararlı bulabilir: NVidia CUDA ile GPGPU programlama üzerine bir üniversite dersinin bir parçası olarak bu zaman ölçme yöntemi verildi ( ders açıklaması ). Önceki yazılarda görülen yöntemleri birleştirir ve gereksinimler güvenilirlik verdiği için gönderirim:

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

Örneğin 1.0 / 1000.0ihtiyaçlarınızı karşılayan ölçü birimini almak için çarpabileceğinizi düşünüyorum.

Kabarcık sıralama ve seçim sıralama yürütme süresinin karşılaştırılması Kabarcık sıralama ve seçim sıralama yürütme süresini karşılaştıran bir program var. Bir kod bloğunun yürütülme zamanını bulmak için, bloktan önceki ve sonraki zamanı hesaplayın.

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

Örnek kod:

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