C程序的执行时间

需要考虑的是，测量程序执行所需时间取决于机器在特定时刻的负载情况。

了解这一点后，在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));
}

希望这有所帮助。 祝好！

我发现通常被推荐的clock()函数在运行时有很大偏差，即使是没有任何副作用（如屏幕绘制或读取文件）的静态代码。这可能是因为CPU改变了电源消耗模式，操作系统给出了不同的优先级等。

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

当收集足够的样本到一个数组中后，对该数组进行排序，并取中间元素，称为中位数。中位数比平均值更好，因为它排除了极端偏差，例如杀毒软件占用所有CPU或操作系统执行某些更新。

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

我自己仍在寻找更强大，更快速的测量代码的方法。可能可以尝试在没有任何操作系统的控制下以受控条件运行代码，但这将给出不切实际的结果，因为实际上操作系统会介入。

x86有这些硬件性能计数器，包括实际执行的指令数量，但是它们很难在没有操作系统帮助的情况下访问，解释起来也很困难，并且具有自己的问题（http://archive.gamedev.net/archive/reference/articles/article213.html）。但仍然可以通过它们来调查瓶颈的性质（数据访问或对该数据的实际计算）。

有些人可能会发现不同类型的输入很有用：我在一门关于使用NVidia CUDA进行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来进行乘法运算，以获得适合你需要的测量单位。最初的回答。

我的系统中所有的解决方案都无法使用。

我可以使用以下方式获取：

#include <time.h>

double difftime(time_t time1, time_t time0);

如果您的程序使用了GPU或者使用了sleep()函数，那么clock()函数得到的时间差将会比实际持续时间小。这是因为clock()函数返回的是CPU时钟滴答数。它只能用来计算CPU使用时间（CPU负载），而不能用于执行持续时间的计算。我们不应该使用clock()函数来计算持续时间。在C语言中，我们仍然应该使用gettimeofday()或clock_gettime()函数来计算持续时间。

perf工具更准确，可用于收集和分析运行中的程序。使用perf stat来显示与正在执行的程序相关的所有信息。

通过使用类似函数的宏，尽可能简单

#include <stdio.h>
#include <time.h>

#define printExecTime(t) printf("Elapsed: %f seconds\n", (double)(clock()-(t)) / CLOCKS_PER_SEC)

int factorialRecursion(int n) {
    return n == 1 ? 1 : n * factorialRecursion(n-1);
}

int main()
{
    clock_t t = clock();

    int j=1;
    for(int i=1; i <10; i++ , j*=i);

    printExecTime(t);
    
    // compare with recursion factorial
    t = clock();
    j = factorialRecursion(10);
    printExecTime(t);

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