计算程序运行时间（time_t, clock_t）
2010-05-11 17:03
309 查看
转载 http://blog.chinaunix.net/u2/85233/showart_1856092.html
我们有时需要得到程序的运行时间，但我们也要知道，根本不可能精确测量某一个程序运行的确切时间
[3]
，文献
[4]
中说的很明白，现摘录如
下。
我们平时常用的测量运行时间的方法并不是那么精确的，换句话说，想精确获取程序运行时间并不是那么
容易的。也许你会想，程序不就是一条条指令么，每一条指令序列都有固定执行时间，为什么不好算？真实情况下，我们的计算机并不是只运行一个程序的，进程的
切换，各种中断，共享的多用户，网络流量，高速缓存的访问，转移预测等，都会对计时产生影响。
文献
[4]
中还提到：对于进程调度来
讲，花费的时间分为两部分，第一是计时器中断处理的时间，也就是当且仅当这个时间间隔的时候，操作系统会选择，是继续当前进程的执行还是切换到另外一个进
程中去。第二是进程切换时间，当系统要从进程
A
切换到进程
B
时，它必须先进入内核模式将进程
A
的状态
保存，然后恢复进程
B
的状态。因此，这个切换过程是有内核活动来消耗时间的。具体到进程的执行时间，这个时间也包括内核
模式和用户模式两部分，模式之间的切换也是需要消耗时间，不过都算在进程执行时间中了。
那么有哪些方法能统计程序的运行时间呢？通过查找一些资料并结合自己的实践体会，摘录和总结了下面
几种方法。
一、
Linux
的
time
命令
Linux
系统下统计程序运行实践最简单直接的方法就是使用
time
命令，文献
[1, 2]
中详细介绍了
time
命令的用法。此命令的用途在于测量特定指令执行时所需消耗的时间及系统资源等资讯，在统计的时间结
果中包含以下数据：
(1)
实际时间（
real time
）：从命令行执行到运行终止的消逝时间；
(2)
用户
CPU
时间（
user CPU time
）：命
令执行完成花费的系统
CPU
时间，即命令在用户态中执行时间的总和；
(3)
系统
CPU
时间（
system CPU time
）：
命令执行完成花费的系统
CPU
时间，即命令在核心态中执行时间的总和。
其中，用户
CPU
时
间和系统
CPU
时间之和为
CPU
时
间，即命令占用
CPU
执行的时间总和。实际时间要大于
CPU
时
间，因为
Linux
是多任务操作系统，往往在执行一条命令时，系统还要处理其他任务。另一个需要注意的问题是即使每次
执行相同的命令，所花费的时间也不一定相同，因为其花费的时间与系统运行相关。
二、间隔计数
[4]
上面介绍的
time
命
令能测量特定进程执行时所消耗的时间，它是怎么做到的呢？
操作系统用计时器来记录每个进程使用的累计时间，原理很简单，计时器中断发生时，操作系统会在当前
进程列表中寻找哪个进程是活动的，一旦发现进程
A
正在运行立马就给进程
A
的计数值增加计时器的时间间隔（这也是引起较大误差的原因）。当然不是统一增加的，还要确定这个进程
是在用户空间活动还是在内核空间活动，如果是用户模式，就增加用户时间，如果是内核模式，就增加系统时间。这种方法的原理虽然简单但不精确。如果一个进程
的运行时间很短，短到和系统的计时器间隔一个数量级，用这种方法测出来的结果必然是不够精确的，头尾都有误差。不过，如果程序的时间足够长，这种误差有时
能够相互弥补，一些被高估一些被低估，平均下来刚好。从理论上很难分析这个误差的值，所以一般只有程序达到秒的数量级时用这种方法测试程序时间才有意义。
这种方法最大的优点是它的准确性不是非常依赖于系统负载。
实现方法之一就是上面介绍的
time
命
令，之二是使用
tms
结构体和
times
函
数。
在
Linux
中，提供了一个
times
函数，原型是
clock_t times( struct tms *
buf );
这个
tms
的结构体为
struct tms
{
clock_t tms_utime;
//user time
clock_t tms_stime;
//system
time
clock_t tms_cutime;
//user time of
reaped children
clock_t tms_cstime;
//system time of
reaped children
}
这里的
cutime
和
cstime
，都是对已经终止并回收的时间的累计，也就是说，
times
不能监视任何正在进行中的子进程所使用的时间。使用
times
函数需要包含头文件
sys/times.h
。
三、周期计数
[4]
为了给计时测量提供更高的准确度，很多处理器还包含一个运行在始终周期级别的计时器，它是一个特殊
的寄存器，每个时钟周期它都会自动加
1
。这个周期计数器呢，是一个
64
位无
符号数，直观理解，就是如果你的处理器是
1GHz
的，那么需要
570
年，它才会从
2
的
64
次方绕回到
0
，所以
你大可不必考虑溢出的问题。但是这种方法是依赖于硬件的。首先，并不是每种处理器都有这样的寄存器的；其次，即使大多数都有，实现机制也不一样，因此，我
们无法用统一的，与平台无关的接口来使用它们。这下，就要使用汇编了。当然，在这里实际用的是
C
语言
的嵌入汇编：
void counter( unsigned *hi, unsigned
*lo )
{
asm(”rdtsc; movl %%edx,%0; movl %%eax, %1″
: “=r”
(*hi), “=r” (*lo)
:
: “%edx”, “%eax”);
}
第一行的指令负责读取周期计数器，后面的指令表示将其转移到指定地点或寄存器。这样，我们将这段代码封装到函数中，就可以在需要测量
的代码前后均加上这个函数即可。最后得到的
hi
和
lo
值都是两个，除了相减得到间隔值外，还要进行一些处理，在此
不表。
不得不提出的是，周期计数方式还有一个问题，就是我们得到了
两次调用
counter
之间总的周期数，但我们不知道是哪个进程使用了这些周期，或者说处理器是在内核还是在用户模式
中。间隔计数的好处就是它是操作系统控制给进程计时的，我们可以知道具体哪个进程呢个模式；但是周期计数只测量经过的时间，他不管是哪个进程使用的。所
以，用周期计数的话必须很小心。举个例子：
double
time()
{
start_counter();
p();
get_counter();
}
这样一段程序，如果机器的负载很重，会导致
p
运行
时间很长，而其实
p
函数本身是不需要运行这么长时间的，而是上下文切换等过程将它的时间拖长了。
而且，转移预测和高速缓存的命中率，对这个计数值也会有影响。通常情况下，为了减少高速缓存不命中
给我们程序执行时间带来的影响，可以执行这样的代码：
double time_warm(void)
{
p();
start_counter();
p();
get_counter();
}
它让指令高速缓存和数据高速缓存都得到了
warm-up
。
接下来又有问题。如果我们的应用是属于那种每次执行都希望访问新的数据的那种呢？在这种情况下，我
们希望让指令高速缓存
warm-up
，而数据高速缓存不能
warm-up
，很明显，
time-warm
函数低估我们的运行时间了。进一步修改：
double time_cold( void )
{
p();
clear_cache();
start_counter();
p();
get_counter();
}
注意，程序中加入了一个清除数据缓存的函数，这个函数的具体实现很简
单，依情况而定，比如举个例子：
volatile int tmp;
static
int dummy
;
//N
是需要清理缓存的字节数
void clear_cache( void )
{
int i, sum = 0;
for( i=1; i<N; i++)
dummy[i] = 2;
for( i=1; i<N; i++)
sum += dummy[i];
tmp = sum;
}
具体原理很简单，定义一个数组并在其上执行一个计算，计算过程中的数据会覆盖高速数据缓存中原有的数
据。每一次的
store
和
load
都会让高速数据缓存
cache
这个数组，而定义为
volatile
的
tmp
则保证这段代码不会被优化。
这样做，是不是就万无一失了呢？不是的，因为大多数处理器，
L2
高速缓存是不分指令和数据的，这样
clear_cache
会让所有
p
的指令也被清除，只不过：
L1
缓存中的指令还会保留而已。
其实上面提到的诸多原因，都是我们不能控制的，我们无法控制让高速缓存去加载什么，不去加载什么，
加载时去掉什么。保留什么。而且，这些误差通常都是会过高估计真实的运行时间。那么具体使用时，有没有什么办法来改善这种情况呢？有，就是
The K-Best Measurement Scheme
。这其实很麻烦，所以在具体实践中都不用它。
四、
gettimeofday
函数计时
[4]
gettimeofday
是一个库函数，包含在
time.h
中。它的功能是查询系统时钟，以确定当前的日期和时间。相对于间隔计数的小适用范围和周期计数的麻烦性，
gettimeofday
是一个可移植性更好相对较准确的方法。它的原型如下：
struct timeval
{
long
tv_sec;
//
秒
域
long
tv_usec;
//
微妙域
}
int
gettimeofday( struct timeval *tv, NULL);
这个机制呢，具体的实现方式在不同系统上是不一样的，而且具体的精确程度是和系统相关的：比如在
Linux
下，是用周期计数来实现这个函数的，所以和周期计数的精确度差不多，但是在
Windows NT
下，是使用间隔计数实现的，精确度就很低了。
具体使用，就是在要计算运行时间的程序段之前和之后分别加上
gettimeofday( &tvstart,
NULL)
、
gettimeofday( &tvend,
NULL)
，然后计算：
(tvend.tv_sec-tvstart.tv_sec)+(tvend.tv_usec-tvstart.tv_usec)/1000000
就得到了以秒为单位的计时时间。
五、
clock
函数
clock
也是一个库函数，仍然包含在
time.h
中，函数原型是：
clock_t clock( void );
功能：返回自程序开始运行的处理器时间，如果无可用信息，返回
-1
。转换返回值若以秒计需除以
CLOCKS_PER_SECOND
。（注：如果编译器是
POSIX
兼
容的，
CLOCKS_PER_SECOND
定义为
1000000
。）
[5]
使用
clock
函数也比较简单：在要计
时程序段前后分别调用
clock
函数，用后一次的返回值减去前一次的返回值就得到运行的处理器时间，然后再转换为秒。举例如下：
clock_t starttime, endtime;
double totaltime;
starttime = clock();
…
endtime = clock();
totaltime = (double)( (endtime -
starttime)/(double)CLOCKS_PER_SEC );
六、
time
函数
在
time.h
中还包含另一个时间函
数：
time
。文献
[6]
对其进行了详细的介绍。通
过
time()
函数来获得日历时间（
Calendar Time
），其原型为：
time_t time( time_t * timer )
。通过
difftime
函数可以计算前后
两次的时间差：
double
difftime( time_t time1, time_t time0 )
。用
time_t
表示的时间（日历时
间）是从一个时间点（例如：
1970
年
1
月
1
日
0
时
0
分
0
秒）到此时的秒数，则此函数的前后两次时间差也是以秒为单位。
比如：
time_t startT, endT;
double totalT;
startT = time( NULL );
…
endT = time( NULL );
totalT = difftime( startT, endT);
关于此函数的其他应用请参见文献
[6]
。
总结：
使用相应的方法，调用相应的函数，还需要关注它们可以表示的范围和精度，这样才能“挑肥拣瘦”。先
来看看时间函数中经常用到的两个数据类型的定义：
// clock_t
的定义
#ifndef
_CLOCK_T_DEFINED
typedef long clock_t;
#define _CLOCK_T_DEFINED
#endif
// time_t
的定义
#ifndef _TIME_T_DEFINED
typedef long time_t;
#define _TIME_T_DEFINED
#endif
long
型数据的取值范围是
-2147483648 ~
+2147483647
。所以，
gettimeofday
函数取得的时间最大值为
2147483647 + 2147483647 / 1000000 =
2147485794.483647 s
，大约为
68.096
年；
clock
函
数取得的时间最大值为
2147483647 / 1000000 = 2147.483647 s
，大约为
35.79
分
钟；
time
函数取得的时间最大值为
2147483647 s
，大约为
68
年。
这里只是介绍
Linux
平台下
c
语言中计算程序运行时间的方法，
它们各有利弊，依据自己的需要可以使用对应的方法。在
Windows
平台下还有其他计算程序运
行时间的方法，在此不叙。
参考文献
[1]
“
linux time
命令详解”， http://www.admin99.net/read.php/185.htm
；
[2]
“
Linux
命令详解——
time
”，
http://blog.csdn.net/thinkerABC/archive/2006/04/01/647272.aspx
；
[3]
“测量程序运行时间的几种方法”， http://oss.lzu.edu.cn/blog/article.php?tid_905.html
；
[4]
“如何精确测量程序运行时间”， http://www.forwind.cn/2008/05/10/measure-time-preciely/
；
[5]
“
clock
”， http://blog.csdn.net/xxyakoo/archive/2008/12/17/3539590.aspx
；
[6]
“
c
语言对时间的处理函数和计时的实
现”，
http://blog.csdn.net/adm_qxx/archive/2007/05/02/1594788.aspx
。
我们有时需要得到程序的运行时间，但我们也要知道，根本不可能精确测量某一个程序运行的确切时间
[3]
，文献
[4]
中说的很明白，现摘录如
下。
我们平时常用的测量运行时间的方法并不是那么精确的，换句话说，想精确获取程序运行时间并不是那么
容易的。也许你会想，程序不就是一条条指令么，每一条指令序列都有固定执行时间，为什么不好算？真实情况下，我们的计算机并不是只运行一个程序的，进程的
切换，各种中断，共享的多用户，网络流量，高速缓存的访问，转移预测等，都会对计时产生影响。
文献
[4]
中还提到：对于进程调度来
讲，花费的时间分为两部分，第一是计时器中断处理的时间，也就是当且仅当这个时间间隔的时候，操作系统会选择，是继续当前进程的执行还是切换到另外一个进
程中去。第二是进程切换时间，当系统要从进程
A
切换到进程
B
时，它必须先进入内核模式将进程
A
的状态
保存，然后恢复进程
B
的状态。因此，这个切换过程是有内核活动来消耗时间的。具体到进程的执行时间，这个时间也包括内核
模式和用户模式两部分，模式之间的切换也是需要消耗时间，不过都算在进程执行时间中了。
那么有哪些方法能统计程序的运行时间呢？通过查找一些资料并结合自己的实践体会，摘录和总结了下面
几种方法。
一、
Linux
的
time
命令
Linux
系统下统计程序运行实践最简单直接的方法就是使用
time
命令，文献
[1, 2]
中详细介绍了
time
命令的用法。此命令的用途在于测量特定指令执行时所需消耗的时间及系统资源等资讯，在统计的时间结
果中包含以下数据：
(1)
实际时间（
real time
）：从命令行执行到运行终止的消逝时间；
(2)
用户
CPU
时间（
user CPU time
）：命
令执行完成花费的系统
CPU
时间，即命令在用户态中执行时间的总和；
(3)
系统
CPU
时间（
system CPU time
）：
命令执行完成花费的系统
CPU
时间，即命令在核心态中执行时间的总和。
其中，用户
CPU
时
间和系统
CPU
时间之和为
CPU
时
间，即命令占用
CPU
执行的时间总和。实际时间要大于
CPU
时
间，因为
Linux
是多任务操作系统，往往在执行一条命令时，系统还要处理其他任务。另一个需要注意的问题是即使每次
执行相同的命令，所花费的时间也不一定相同，因为其花费的时间与系统运行相关。
二、间隔计数
[4]
上面介绍的
time
命
令能测量特定进程执行时所消耗的时间，它是怎么做到的呢？
操作系统用计时器来记录每个进程使用的累计时间，原理很简单，计时器中断发生时，操作系统会在当前
进程列表中寻找哪个进程是活动的，一旦发现进程
A
正在运行立马就给进程
A
的计数值增加计时器的时间间隔（这也是引起较大误差的原因）。当然不是统一增加的，还要确定这个进程
是在用户空间活动还是在内核空间活动，如果是用户模式，就增加用户时间，如果是内核模式，就增加系统时间。这种方法的原理虽然简单但不精确。如果一个进程
的运行时间很短，短到和系统的计时器间隔一个数量级，用这种方法测出来的结果必然是不够精确的，头尾都有误差。不过，如果程序的时间足够长，这种误差有时
能够相互弥补，一些被高估一些被低估，平均下来刚好。从理论上很难分析这个误差的值，所以一般只有程序达到秒的数量级时用这种方法测试程序时间才有意义。
这种方法最大的优点是它的准确性不是非常依赖于系统负载。
实现方法之一就是上面介绍的
time
命
令，之二是使用
tms
结构体和
times
函
数。
在
Linux
中，提供了一个
times
函数，原型是
clock_t times( struct tms *
buf );
这个
tms
的结构体为
struct tms
{
clock_t tms_utime;
//user time
clock_t tms_stime;
//system
time
clock_t tms_cutime;
//user time of
reaped children
clock_t tms_cstime;
//system time of
reaped children
}
这里的
cutime
和
cstime
，都是对已经终止并回收的时间的累计，也就是说，
times
不能监视任何正在进行中的子进程所使用的时间。使用
times
函数需要包含头文件
sys/times.h
。
三、周期计数
[4]
为了给计时测量提供更高的准确度，很多处理器还包含一个运行在始终周期级别的计时器，它是一个特殊
的寄存器，每个时钟周期它都会自动加
1
。这个周期计数器呢，是一个
64
位无
符号数，直观理解，就是如果你的处理器是
1GHz
的，那么需要
570
年，它才会从
2
的
64
次方绕回到
0
，所以
你大可不必考虑溢出的问题。但是这种方法是依赖于硬件的。首先，并不是每种处理器都有这样的寄存器的；其次，即使大多数都有，实现机制也不一样，因此，我
们无法用统一的，与平台无关的接口来使用它们。这下，就要使用汇编了。当然，在这里实际用的是
C
语言
的嵌入汇编：
void counter( unsigned *hi, unsigned
*lo )
{
asm(”rdtsc; movl %%edx,%0; movl %%eax, %1″
: “=r”
(*hi), “=r” (*lo)
:
: “%edx”, “%eax”);
}
第一行的指令负责读取周期计数器，后面的指令表示将其转移到指定地点或寄存器。这样，我们将这段代码封装到函数中，就可以在需要测量
的代码前后均加上这个函数即可。最后得到的
hi
和
lo
值都是两个，除了相减得到间隔值外，还要进行一些处理，在此
不表。
不得不提出的是，周期计数方式还有一个问题，就是我们得到了
两次调用
counter
之间总的周期数，但我们不知道是哪个进程使用了这些周期，或者说处理器是在内核还是在用户模式
中。间隔计数的好处就是它是操作系统控制给进程计时的，我们可以知道具体哪个进程呢个模式；但是周期计数只测量经过的时间，他不管是哪个进程使用的。所
以，用周期计数的话必须很小心。举个例子：
double
time()
{
start_counter();
p();
get_counter();
}
这样一段程序，如果机器的负载很重，会导致
p
运行
时间很长，而其实
p
函数本身是不需要运行这么长时间的，而是上下文切换等过程将它的时间拖长了。
而且，转移预测和高速缓存的命中率，对这个计数值也会有影响。通常情况下，为了减少高速缓存不命中
给我们程序执行时间带来的影响，可以执行这样的代码：
double time_warm(void)
{
p();
start_counter();
p();
get_counter();
}
它让指令高速缓存和数据高速缓存都得到了
warm-up
。
接下来又有问题。如果我们的应用是属于那种每次执行都希望访问新的数据的那种呢？在这种情况下，我
们希望让指令高速缓存
warm-up
，而数据高速缓存不能
warm-up
，很明显，
time-warm
函数低估我们的运行时间了。进一步修改：
double time_cold( void )
{
p();
clear_cache();
start_counter();
p();
get_counter();
}
注意，程序中加入了一个清除数据缓存的函数，这个函数的具体实现很简
单，依情况而定，比如举个例子：
volatile int tmp;
static
int dummy
;
//N
是需要清理缓存的字节数
void clear_cache( void )
{
int i, sum = 0;
for( i=1; i<N; i++)
dummy[i] = 2;
for( i=1; i<N; i++)
sum += dummy[i];
tmp = sum;
}
具体原理很简单，定义一个数组并在其上执行一个计算，计算过程中的数据会覆盖高速数据缓存中原有的数
据。每一次的
store
和
load
都会让高速数据缓存
cache
这个数组，而定义为
volatile
的
tmp
则保证这段代码不会被优化。
这样做，是不是就万无一失了呢？不是的，因为大多数处理器，
L2
高速缓存是不分指令和数据的，这样
clear_cache
会让所有
p
的指令也被清除，只不过：
L1
缓存中的指令还会保留而已。
其实上面提到的诸多原因，都是我们不能控制的，我们无法控制让高速缓存去加载什么，不去加载什么，
加载时去掉什么。保留什么。而且，这些误差通常都是会过高估计真实的运行时间。那么具体使用时，有没有什么办法来改善这种情况呢？有，就是
The K-Best Measurement Scheme
。这其实很麻烦，所以在具体实践中都不用它。
四、
gettimeofday
函数计时
[4]
gettimeofday
是一个库函数，包含在
time.h
中。它的功能是查询系统时钟，以确定当前的日期和时间。相对于间隔计数的小适用范围和周期计数的麻烦性，
gettimeofday
是一个可移植性更好相对较准确的方法。它的原型如下：
struct timeval
{
long
tv_sec;
//
秒
域
long
tv_usec;
//
微妙域
}
int
gettimeofday( struct timeval *tv, NULL);
这个机制呢，具体的实现方式在不同系统上是不一样的，而且具体的精确程度是和系统相关的：比如在
Linux
下，是用周期计数来实现这个函数的，所以和周期计数的精确度差不多，但是在
Windows NT
下，是使用间隔计数实现的，精确度就很低了。
具体使用，就是在要计算运行时间的程序段之前和之后分别加上
gettimeofday( &tvstart,
NULL)
、
gettimeofday( &tvend,
NULL)
，然后计算：
(tvend.tv_sec-tvstart.tv_sec)+(tvend.tv_usec-tvstart.tv_usec)/1000000
就得到了以秒为单位的计时时间。
五、
clock
函数
clock
也是一个库函数，仍然包含在
time.h
中，函数原型是：
clock_t clock( void );
功能：返回自程序开始运行的处理器时间，如果无可用信息，返回
-1
。转换返回值若以秒计需除以
CLOCKS_PER_SECOND
。（注：如果编译器是
POSIX
兼
容的，
CLOCKS_PER_SECOND
定义为
1000000
。）
[5]
使用
clock
函数也比较简单：在要计
时程序段前后分别调用
clock
函数，用后一次的返回值减去前一次的返回值就得到运行的处理器时间，然后再转换为秒。举例如下：
clock_t starttime, endtime;
double totaltime;
starttime = clock();
…
endtime = clock();
totaltime = (double)( (endtime -
starttime)/(double)CLOCKS_PER_SEC );
六、
time
函数
在
time.h
中还包含另一个时间函
数：
time
。文献
[6]
对其进行了详细的介绍。通
过
time()
函数来获得日历时间（
Calendar Time
），其原型为：
time_t time( time_t * timer )
。通过
difftime
函数可以计算前后
两次的时间差：
double
difftime( time_t time1, time_t time0 )
。用
time_t
表示的时间（日历时
间）是从一个时间点（例如：
1970
年
1
月
1
日
0
时
0
分
0
秒）到此时的秒数，则此函数的前后两次时间差也是以秒为单位。
比如：
time_t startT, endT;
double totalT;
startT = time( NULL );
…
endT = time( NULL );
totalT = difftime( startT, endT);
关于此函数的其他应用请参见文献
[6]
。
总结：
使用相应的方法，调用相应的函数，还需要关注它们可以表示的范围和精度，这样才能“挑肥拣瘦”。先
来看看时间函数中经常用到的两个数据类型的定义：
// clock_t
的定义
#ifndef
_CLOCK_T_DEFINED
typedef long clock_t;
#define _CLOCK_T_DEFINED
#endif
// time_t
的定义
#ifndef _TIME_T_DEFINED
typedef long time_t;
#define _TIME_T_DEFINED
#endif
long
型数据的取值范围是
-2147483648 ~
+2147483647
。所以，
gettimeofday
函数取得的时间最大值为
2147483647 + 2147483647 / 1000000 =
2147485794.483647 s
，大约为
68.096
年；
clock
函
数取得的时间最大值为
2147483647 / 1000000 = 2147.483647 s
，大约为
35.79
分
钟；
time
函数取得的时间最大值为
2147483647 s
，大约为
68
年。
这里只是介绍
Linux
平台下
c
语言中计算程序运行时间的方法，
它们各有利弊，依据自己的需要可以使用对应的方法。在
Windows
平台下还有其他计算程序运
行时间的方法，在此不叙。
参考文献
[1]
“
linux time
命令详解”， http://www.admin99.net/read.php/185.htm
；
[2]
“
Linux
命令详解——
time
”，
http://blog.csdn.net/thinkerABC/archive/2006/04/01/647272.aspx
；
[3]
“测量程序运行时间的几种方法”， http://oss.lzu.edu.cn/blog/article.php?tid_905.html
；
[4]
“如何精确测量程序运行时间”， http://www.forwind.cn/2008/05/10/measure-time-preciely/
；
[5]
“
clock
”， http://blog.csdn.net/xxyakoo/archive/2008/12/17/3539590.aspx
；
[6]
“
c
语言对时间的处理函数和计时的实
现”，
http://blog.csdn.net/adm_qxx/archive/2007/05/02/1594788.aspx
。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 计算程序运行时间（time_t, clock_t）
- 计算程序运行时间（time_t, clock_t）
- 计算程序运行时间（time_t, clock_t）
- 利用System.currentTimeMillis()方法计算程序运行时间
- R-Sys.time计算程序运行时间
- python-time模块计算程序运行的时间
- time -- 计算程序运行时间
- 计算程序运行时间 C语言 clock()函数
- 计算程序运行时间的函数Sleep,clock,GetTickCount,QueryPerformanceCounter
- 如何计算程序运行的时间（clock的正确使用）
- c++中计算运行时间 clock(),clock_t程序
- 关于clock()计算进程运行的时间以及time()
- 关于clock()计算进程运行的时间以及time()
- 关于使用time.h和clock()函数获得程序运行时间
- python中的datetime，time和clock显示程序运行时间
- 关于clock()计算进程运行的时间以及time()
- [转]c++中计算运行时间 clock(),clock_t程序
- R-Sys.time计算程序运行时间
- C中计算程序运行时间差（毫秒级）
- 如何利用MATLAB并行计算缩短程序运行时间