首页 文章

C程序的执行时间

提问于
浏览 次
167

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

我不确定如何计算 Clocks_per_second 值？

在Java中，我只是在执行之前和之后以毫秒为单位 .

C中有类似的东西吗？我看过了，但我似乎无法找到比第二种解决方案更好的方法 .

我也知道分析器是一个选项，但我希望自己实现一个计时器 .

谢谢

c code-timing

13 回答

  • 1

    在普通香草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;
}
    回复于
  • 2

    每个解决方案都不适用于我的系统 .

    我可以使用

    #include <time.h>

double difftime(time_t time1, time_t time0);
    回复于
  • 0

    ANSI C仅指定第二个精确时间函数 . 但是，如果您在POSIX环境中运行，则可以使用gettimeofday()函数，该函数提供自UNIX Epoch以来经过的微秒分辨率 .

    作为旁注，我不推荐使用clock（），因为它在很多（如果不是全部？）系统上实现得很糟糕而且不准确，除了它只是指你的程序花了多长时间在CPU和不是程序的总寿命，根据你的问题，我认为你想测量 .

    回复于
  • 284

    很多答案一直在建议 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，具体取决于您用于编译的选项，因此它似乎不是一个好的解决方案 .

    回复于
  • 7

    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秒） . 精度取决于架构;在现代系统上你很容易获得10毫秒或更低，但在较旧的Windows机器上（从Win98时代）它接近60毫秒 .

    clock() 是标准C;它有效"everywhere" . 有类似系统的功能，例如类Unix系统上的 getrusage() .

    Java的 System.currentTimeMillis() 并没有衡量同样的事情 . 它是"wall clock"：它可以帮助您测量程序执行所花费的时间，但它并不能告诉您使用了多少CPU时间 . 在多任务系统（即所有这些系统）上，这些可以是广泛不同的 .

    回复于
  • 51

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

    在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.
    回复于
  • 3

    如果您使用Unix shell运行，则可以使用time命令 .

    干

    $ time ./a.out

    假设a.out，因为可执行文件将给你运行它的时间

    回复于
  • 3

    冒泡排序和选择排序的执行时间的比较我有一个程序，它比较冒泡排序和选择排序的执行时间 . 要找出执行代码块的时间，请计算块之前和之后的时间

    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");
}
    回复于
  • 1

    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.
    回复于
  • 98

    大多数简单程序的计算时间以毫秒为单位 . 所以，我想，你会发现这很有用 .

    #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

    回复于
  • 50

    你在功能上想要这个：

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

    请注意，这以微秒为单位，而不仅仅是秒 .

    回复于
  • 2

    您必须考虑到，测量执行程序的 time 在很大程度上取决于机器在该特定时刻的负载 .

    知道了，在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));
}

    希望能帮助到你 .

    问候！

    回复于
  • 11
    #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);
}

    这个程序将像魅力一样工作 .

    回复于

相关问题