C程序的执行时间

我有一个C计划,旨在将并行在几个处理器上运行。 我需要能够记录的执行时间(可以是至数分钟从1秒的任何地方)。 我已经寻找答案,但他们似乎都使用时钟()函数,然后包括计算时钟程序拿了由Clocks_per_second值除以数量建议。

我不知道该Clocks_per_second价值是如何计算的?

在Java中,我只拿以毫秒为单位的当前时间之前和执行之后。 有没有在C类似的事情? 我一看,但我似乎无法找到得到任何东西比第二分辨率更好的方式。

我也知道一个分析器将是一种选择,但我希望实现一个定时器我自己。

谢谢

--------------解决方案-------------

CLOCKS_PER_SEC是这是在宣布一个恒定<time.h> 。 为了得到一个C应用程序中的一个任务使用的CPU时间,使用方法:

clock_t begin, end;
double time_spent;

begin = clock();
/* here, do your time-consuming job */
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;

注意,这个返回时间作为浮点类型。 这可能比第二个更精确的(例如,你衡量4.52秒)。 精度取决于建筑风格; 现代系统你轻松搞定为10ms或更低,但旧的Windows机器(从Win98中的时代)是接近60ms的。

clock()是标准C; 它的工作原理“无处不在”。 有一些特定的系统功能,如getrusage()的类Unix系统。

Java的System.currentTimeMillis()不测量同样的事情。 这是一个“挂钟”:它可以帮助你衡量多少时间把该程序来执行,但它不会告诉你多少CPU时间使用。 在多任务系统(即所有的人),这些都可以广泛不同。

如果您使用的是Unix外壳运行,您可以使用time命令。

$ time ./a.out

假设的a.out的可执行文件将作罢运行此所用的时间

在普通的香草C:

#include <time.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_SECtime.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取决于你用什么办法来编译,因此它似乎并不像一个很好的解决方案。

ANSI C仅指定秒的精确时间的函数。 但是,如果你是在一个POSIX环境中运行,你可以使用函数gettimeofday()函数提供的自Unix纪元时间的推移微秒分辨率。

作为一个方面说明,我不建议使用时钟(),因为它是严重很多实现(如果不是全部?)系统和不准确的,除了事实上,它只是指你的程序了多长时间度过了CPU上没有计划,根据你的问题的总生存期是什么,我想你想测量。

你必须考虑到该测量了程序执行的时间很大程度上取决于该机器具有在特定时刻的负荷。

知道,得到在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));
}

希望它帮助。

商祺!

杰格迪什Dudhate:

的冒泡排序和选择排序的执行时间比较,我有一个计划,其中比较冒泡排序和选择排序的执行时间,找出一个代码块的执行时间前计算时间和块的一端由

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>
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 Selectionsort by %f seconds\n\n",extime1-extime);
else
printf("\tBoth algo has same execution time\n\n");

}

每一个解决方案的并不在我的系统工作。

我可以使用

#include <time.h>

double difftime(time_t time1, time_t time0);

分类:C# 时间:2015-03-15 人气:0
本文关键词: C#代码时机
分享到:

相关文章

Copyright (C) 55228885.com, All Rights Reserved.

55228885 版权所有 京ICP备15002868号

processed in 0.723 (s). 10 q(s)