Cプログラムの実行時間

複数のプロセッサーで並列実行することを目的としたCプログラムがあります。実行時間を記録できるようにする必要があります（1秒から数分の場合もあります）。私は答えを探しましたが、それらはすべて、clock()関数の使用を提案しているようです。この関数は、プログラムが取ったクロック数をClocks_per_second値で割って計算します。

Clocks_per_second値の計算方法がわかりません。

Javaでは、実行の前後に現在の時間をミリ秒単位で取得します。

Cにも同様のものはありますか？私は見ましたが、2番目の解像度よりも優れたものを得る方法を見つけることができないようです。

プロファイラーがオプションになることも知っていますが、タイマーを自分で実装することを検討しています。

ありがとう

CLOCKS_PER_SECで宣言されている定数<time.h>です。Cアプリケーション内のタスクで使用されるCPU時間を取得するには、次のコマンドを使用します。

clock_t begin = clock();

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

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

これは、浮動小数点型として時間を返すことに注意してください。これは1秒よりも正確である可能性があります（例：4.52秒を測定）。精度はアーキテクチャによって異なります。最近のシステムでは10ミリ秒以下になりがちですが、（Win98時代の）古いWindowsマシンでは60ミリ秒近くでした。

clock()標準Cです。「どこでも」機能します。getrusage()Unixライクなシステムなど、システム固有の機能があります。

Java System.currentTimeMillis()は同じことを測定しません。これは「壁時計」です。プログラムの実行にかかった時間を測定するのに役立ちますが、使用されたCPU時間はわかりません。マルチタスクシステム（つまり、それらすべて）では、これらは大きく異なる場合があります。

実行にUnixシェルを使用している場合は、timeコマンドを使用できます。

している

$ time ./a.out

実行可能ファイルとしてa.outを想定すると、これを実行するのにかかる時間がuになります。

プレーンバニラ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));
}

それが役に立てば幸い。

よろしく！

（システム管理者がシステム時間を変更した場合、またはタイムゾーンの冬時間と夏時間が異なる場合、ここでの回答はすべて欠けています。したがって...）

Linuxでの使用：clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); system-adminが時刻を変更した場合、または冬時間と夏時間とが異なる国に住んでいる場合などは影響を受けません。

#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は、2番目の精度の時間関数のみを指定します。ただし、POSIX環境で実行している場合は、UNIXエポックから経過した時間をマイクロ秒単位で解決するgettimeofday（）関数を使用できます。

余談ですが、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);
}

このプログラムは魅力のように動作します。

画面への描画やファイルの読み取りなどの副作用のない静的コードであっても、何らかの理由で実行から実行に大きく逸脱する、通常のclock（）がここで推奨されていることがわかりました。CPUが電力消費モードを変更したり、OSが異なる優先順位を与えたりするなどの理由が考えられます。

したがって、clock（）を使用して毎回確実に同じ結果を得る唯一の方法は、測定されたコードを複数回（数分間）ループで実行し、コンパイラーが最適化しないように予防策を講じることです。最新のコンパイラーはコードを事前計算できますループで実行されている副作用なしで、ループの外に移動します。つまり、反復ごとにランダム入力を使用するようなものです。

十分なサンプルが配列に収集された後、1つはその配列を並べ替え、中央値と呼ばれる中央の要素を取ります。中央値は平均よりも優れています。これは、ウイルス対策がCPUをすべて占有したり、OSが更新を行ったりするなど、極端な偏差を捨てるからです。

C / C ++コードの実行パフォーマンスを測定し、中央値に近い値を平均化する簡単なユーティリティを次に示します。https：//github.com/saniv/gauge

私はまだ、コードを測定するためのより堅牢でより高速な方法を探しています。おそらくOSなしでベアメタルの制御された条件でコードを実行してみることができますが、実際にはOSが関与するため、非現実的な結果が得られます。

x86には、実行された実際の命令数を含むこれらのハードウェアパフォーマンスカウンターがありますが、OSのヘルプなしではアクセスが難しく、解釈が難しく、独自の問題があります（http://archive.gamedev.net/archive/reference/articles /article213.html）。それでも、ボトルネックの性質（データアクセスまたはそのデータの実際の計算）を調査するのに役立ちます。

別の種類の入力が役立つと感じる人もいます。NVidiaCUDAを使用したGPGPUプログラミングに関する大学のコースの一部として、この時間を測定する方法が与えられました（コースの説明）。それは以前の投稿で見られた方法を組み合わせたものであり、要件によって信頼性が与えられるため、私は単に投稿します。

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