C程序的执行时间

我有一个旨在在多个处理器上并行运行的C程序。我需要能够记录执行时间（可能在1秒到几分钟之间的任何时间）。我已经搜索了答案，但是它们似乎都建议使用该clock()函数，然后使用该函数来计算程序所花费的时钟数除以该Clocks_per_second值。

我不确定如何Clocks_per_second计算值？

在Java中，我只是以毫秒为单位来计算执行前后的当前时间。

C中有类似的东西吗？我看了一下，但是似乎找不到一种比第二种分辨率更好的方法。

我也知道可以使用探查器，但是我希望自己实现一个计时器。

谢谢

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;

请注意，这会将时间作为浮点类型返回。这可能比一秒更精确（例如，您测量4.52秒）。精度取决于架构；在现代系统上，您很容易获得10ms或更短的时间，但是在较旧的Windows计算机上（从Win98时代开始）则接近60ms。

clock()是标准C；它可以在任何地方工作。有特定getrusage()于系统的功能，例如在类似Unix的系统上。

Java System.currentTimeMillis()不能衡量同一件事。这是一个“挂钟”：它可以帮助您测量程序执行所花费的时间，但是它不会告诉您使用了多少CPU时间。在多任务系统（即所有系统）上，它们可以有很大不同。

如果使用Unix Shell运行，则可以使用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));
}

希望能帮助到你。

问候！

（如果您的系统管理员更改了系统时间，或者时区的冬季时间和夏季时间不同，则这里缺少所有答案。因此...）

在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时代以来经过的时间的微秒分辨率。

附带说明一下，我不建议使用clock（），因为Clock（）在许多（如果不是全部？）系统上实现不好，而且不准确，除了它仅指程序在CPU和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更改了功耗模式，操作系统赋予了不同的优先级等...

因此，每次使用clock（）可靠地获得相同结果的唯一方法是多次（在几分钟内）在循环中运行被测代码，并采取预防措施以防止编译器对其进行优化：现代编译器可以预计算代码没有副作用循环运行，然后将其移出循环，例如每次迭代都使用随机输入。

在将足够多的样本收集到一个数组中之后，对数组进行排序，然后获取中间元素，称为中值。中位数比平均水平要好，因为它可以消除极端偏差，例如说杀毒软件占用了所有CPU或操作系统进行了一些更新。

这是一个用于测量C / C ++代码的执行性能的简单实用程序，可以对中值附近的值进行平均：https : //github.com/saniv/gauge

我自己仍在寻找一种更健壮和更快的方式来测量代码。人们可能会尝试在没有任何操作系统的裸机上在受控条件下运行代码，但这会产生不切实际的结果，因为实际上OS确实参与其中。

x86具有这些硬件性能计数器，其中包括实际执行的指令数量，但是在没有OS帮助的情况下它们很难访问，难以解释并且有自己的问题（http://archive.gamedev.net/archive/reference/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");
}