性能测试的时间间隔获取方法

柔光的暖阳◎ 2022-06-14 07:27 428阅读 0赞

性能[测试][Link 1]的时候，一个问题就是时间间隔，有很多时间函数能获取时间，从而求取时间间隔。关于这方面的文章很多，我就不重复了，这里只是提供一些基本的信息，从而方便我自己做性能测试使用：

（1）[C语言][C]时间函数clock()和clock\_t：

time.h中的[c语言][C]时间函数clock()能获取当前时间。需要注意的是，这个函数在Windows和[Linux][]下是通用的，但是其返回值的单位是不同的，一个是毫秒，一个是微秒。

从单位也可以看出该方式获取时间的精度。总体来说，其精度在毫秒级，所以测试性能的时候，对于粗时间间隔的测试，用这个函数就足够了。

需要注意的是：在[linux][Linux]上，clock()获取的是CPU时间，不是wall-clock时间，所以如果使用了sleep()等函数，那么是不会计算在内的。但是在Windows平台上，clock()获取的时间包括Sleep()等函数的时间，所以使用clock()的时候要注意这一点，在Linux上得到的很可能不是一个正确的Elapsed time。

（2）利用CPU获取高精度时间rdtsc寄存器

rdtsc是一个64位的寄存器，新的CPU都具备这个寄存器，用于记录从计算机启动开始CPU经过的时钟周期，可见其精度之高是和CPU的频率级别的。

可以参考[http://blog.sina.com.cn/s/blog\_5d9051c00100jcsn.html][http_blog.sina.com.cn_s_blog_5d9051c00100jcsn.html]的文章。

由于是寄存器，所以只要使用汇编读取寄存器的值就可以得到时间了，具体关于汇编的写法有一些不同的形式，具体可以参考网上的写法，而且windows和Linux下也可能是有一些区别。需要注意的是，即使都是在Linux下或都是Windows下，编译64位和32位的时候，其写法也会不一样，参考：[http://www.phpzy.com/php/1068620.html][http_www.phpzy.com_php_1068620.html]和[http://www.uplook.cn/index-Index-show-view2681.html?treeid=624][http_www.uplook.cn_index-Index-show-view2681.html_treeid_624]（如果错误使用，得到的时间间隔可能为负数）

PS：在Linux上，-m32和-m64选项分别表示生成32位和64位程序，使用-m32会定义\_\_i386\_\_宏，使用-m64则使用\_\_x86\_64\_\_宏。

关于Windows上，也可以使用rdtsc寄存器，但是windows上生成64位程序的时候，不知道该如何获得正确值，参考[http://sunxiunan.com/?p=983][http_sunxiunan.com_p_983]里面有64位的情况，但是只能用于Itanium CPU上。根据MSDN的说明（[http://msdn.microsoft.com/en-us/library/ee417693.aspx][http_msdn.microsoft.com_en-us_library_ee417693.aspx]），不建议使用rdtsc寄存器，建议使用更精确的windows API的QueryPerformanceCounter和QueryPerformanceFrequency。

（3）Windows平台的QueryPerformanceCounter和QueryPerformanceFrequency的使用：

参考：[http://www.oschina.net/code/snippet\_197161\_6789][http_www.oschina.net_code_snippet_197161_6789]

（4）Timing.h和测试：

下面是能运行于Linux和Windows的代码，可以用于计算程序运行时间，对于一样的性能测试，应该可以胜任。

1.  // Timing.h  
2.  \#ifndef TIMING\_H  
3.  \#define TIMING\_H  
4.    
5.  \#include <time.h>  
6.  \#include <stdio.h>  
7.    
8.  \#ifdef WIN  
9.  \#include <windows.h>  
10. \#define timing\_t double  
11. **static** \_LARGE\_INTEGER time\_start, time\_over;  
12. **static** **double** dqFreq;  
13.   
14. **static** **inline** **void** startTiming()  
15. \{  
16.     \_LARGE\_INTEGER f;  
17.     QueryPerformanceFrequency(&f);  
18.     dqFreq=(**double**)f.QuadPart;  
19.       
20.     QueryPerformanceCounter(&time\_start);  
21. \}  
22.   
23. // unit: ms  
24. **static** **inline** timing\_t stopTiming()  
25. \{  
26.     QueryPerformanceCounter(&time\_over);  
27.     **return** ((**double**)(time\_over.QuadPart-time\_start.QuadPart)/dqFreq\*1000);  
28. \}  
29.   
30. **static** **inline** timing\_t stopWithPrintTiming()  
31. \{  
32.     timing\_t timing;  
33.     QueryPerformanceCounter(&time\_over);  
34.     timing = ((**double**)(time\_over.QuadPart-time\_start.QuadPart)/dqFreq\*1000);  
35.     printf("----------Elapsed Timing(ms) : %.3lf\\n", timing);  
36.     printf("----------------------------------------\\n");  
37.   
38.     **return** timing;  
39. \}  
40.   
41. \#else  
42. \#include <unistd.h>  
43. **typedef** unsigned **long** **long** int64;  
44. \#define timing\_t int64  
45. \#if defined(\_\_i386\_\_)  
46. **inline** int64 GetCycleCount() \{  
47.     int64 result;  
48.     \_\_asm\_\_ \_\_volatile\_\_ ("rdtsc" : "=A" (result));  
49.     **return** result;  
50. \}  
51. \#elif defined(\_\_x86\_64\_\_)  
52. **inline** int64 GetCycleCount()   
53. \{  
54.     int64 hi, lo;  
55.     \_\_asm\_\_ \_\_volatile\_\_ ("rdtsc" : "=a"(lo), "=d"(hi));  
56.     **return** ( (int64)lo)|( ((int64)hi)<<32 );  
57. \}  
58. \#endif  
59.   
60. **static** int64 ticks\_start, ticks\_end;  
61.   
62. **static** **inline** **void** startTiming()  
63. \{  
64.     ticks\_start = GetCycleCount();  
65. \}  
66.   
67. // unit: cycles  
68. **static** **inline** int64 stopTiming()  
69. \{  
70.     ticks\_end = GetCycleCount();  
71.     **return** (ticks\_end - ticks\_start);  
72. \}  
73.   
74. **static** **inline** int64 stopWithPrintTiming()  
75. \{  
76.     int64 timing;  
77.     ticks\_end = GetCycleCount();  
78.     timing = (ticks\_end - ticks\_start);  
79.     printf("----------Elapsed Timing(Cycles) : %llu\\n", timing);  
80.     printf("----------------------------------------\\n");  
81.   
82.     **return** timing;  
83. \}  
84. \#endif  
85.   
86. // unit: ms  
87. **static** **inline** **void** wait(**int** ms)  
88. \{  
89. \#ifdef WIN32  
90.     Sleep(ms);  
91. \#else  
92.     usleep(ms\*1000);  
93. \#endif  
94. \}  
95.   
96. \#endif

1.  // foo.cpp  
2.  \#include "timing.h"  
3.    
4.  **int** main()  
5.  \{  
6.      timing\_t ticks\_start, ticks\_end;  
7.      startTiming();  
8.    
9.      wait(3000); // 3 seconds  
10.     timing\_t timing = stopWithPrintTiming();  
11.       
12.     **return** 1;  
13. \}

Windows上编译：cl foo.cpp /DWIN，分别启动64bit和32bit的VS控制台进行测试。

Linux上编译：gcc foo.cpp -m32和gcc foo.cpp -m64进行测试。

# C语言中常用计时方法总结 #

## 1. time() ##

**头文件**：time.h

**函数原型**：time\_t time(time\_t \* timer)

**功能**：返回以格林尼治时间（GMT）为标准，从1970年1月1日00:00:00到现在的此时此刻所经过的秒数。

用time()函数结合其他函数（如：localtime、gmtime、asctime、ctime）可以获得当前系统时间或是标准时间。

用difftime函数可以计算两个time\_t类型的时间的差值，可以用于计时。用difftime(t2,t1)要比t2-t1更准确，因为C标准中并没有规定time\_t的单位一定是秒，而difftime会根据机器进行转换，更可靠。

**用法**：

**\[cpp\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  **time\_t** start,end;  
2.  start =time(NULL);//or time(&start);  
3.  //…calculating…  
4.  end =time(NULL);  
5.  printf("time=%d\\n",difftime(end,start));

**总结**：C标准库中的函数，可移植性最好，性能也很稳定，但精度太低，只能精确到秒，对于一般的事件计时还算够用，而对运算时间的计时就明显不够用了。

## 2. clock() ##

**头文件**：time.h

**函数原型**：clock\_t clock(void);

**功能**：该函数返回值是硬件滴答数，要换算成秒，需要除以CLK\_TCK或者 CLK\_TCKCLOCKS\_PER\_SEC。比如，在VC++6.0下，这两个量的值都是1000。

**用法**：

**\[cpp\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  **clock\_t** start,end;  
2.  start = clock();  
3.  //…calculating…  
4.  end = clock();  
5.  printf("time=%f\\n",(**double**)end-start)/CLK\_TCK);

**总结**：可以精确到毫秒，适合一般场合的使用。

## 3. timeGetTime() ##

WIN32API

**头文件**：Mmsystem.h  **引用库**： Winmm.lib

**函数原型**：DWORD timeGetTime(VOID);

**功能**：返回系统时间，以毫秒为单位。系统时间是从系统启动到调用函数时所经过的毫秒数。注意，这个值是32位的，会在0到2^32之间循环，约49.71天。

**用法**：

**\[cpp\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  DWORDstart,end;  
2.  start= timeGetTime();  
3.  //…calculating…  
4.  end= timeGetTime();  
5.  printf("time=%d\\n",end-start);

**总结**：该函数的时间精度是五毫秒或更大一些，这取决于机器的性能。可用timeBeginPeriod和timeEndPeriod函数提高timeGetTime函数的精度。如果使用了，连续调用timeGetTime函数，一系列返回值的差异由timeBeginPeriod和timeEndPeriod决定。

## 4. GetTickCount() ##

WIN32API

**头文件**：windows.h

**函数原型**：DWORD WINAPI GetTickCount(void);

**功能**：返回自设备启动后的毫秒数（不含系统暂停时间）。

**用法**：

**\[cpp\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  DWORDstart,end;  
2.  start= GetTickCount();  
3.  //…calculating…  
4.  end= GetTickCount();  
5.  printf("time=%d\\n",end-start);

**总结**：精确到毫秒。对于一般的实时控制，使用GetTickCount()函数就可以满足精度要求。

## 5. QueryPerformanceCounter()、QueryPerformanceFrequency() ##

WIN32API

**头文件**：windows.h

**函数原型**：BOOLQueryPerformanceCounter(LARGE\_INTEGER \*lpPerformanceCount);

BOOLQueryPerformanceFrequency(LARGE\_INTEGER \*lpFrequency);

**功能**：前者获得的是CPU从开机以来执行的时钟周期数。后者用于获得你的机器一秒钟执行多少次，就是你的时钟周期。

**补充**：LARGE\_INTEGER既可以是一个8字节长的整型数，也可以是两个4字节长的整型数的联合结构， 其具体用法根据编译器是否支持64位而定：

**\[cpp\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  **typedef** union\_LARGE\_INTEGER  
2.  \{  
3.      **struct**  
4.      \{  
5.          **DWORD** LowPart ;  
6.          **LONG** HighPart;  
7.      \};  
8.      **LONGLONG** QuadPart ;  
9.  \}LARGE\_INTEGER;

**用法**：

在进行定时之前，先调用QueryPerformanceFrequency()函数获得机器内部定时器的时钟频率，然后在需要严格定时的事件发生之前和发生之后分别调用QueryPerformanceCounter()函数，利用两次获得的计数之差及时钟频率，计算出事件经历的精确时间。

**\[cpp\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  LARGE\_INTEGER  num;  
2.  longlong start,end,freq;  
3.  QueryPerformanceFrequency(&num);  
4.  freq=num.QuadPart;  
5.  QueryPerformanceCounter(&num);   
6.  start= num.QuadPart;   
7.  //…calculating…  
8.  QueryPerformanceCounter(&num);   
9.  end= num.QuadPart;    
10. printf("time=%d\\n",(end-start)\*1000/freq);

**总结**：这种方法的定时误差不超过1微秒，精度与CPU等机器配置有关，一般认为精度为透微秒级。在Windows平台下进行高精度计时的时候可以考虑这种方法。

## 6. gettimeofday() ##

[Linux][] C函数。

**头文件**：sys/time.h

**函数原型**：int gettimeofday(struct timeval \*tv,struct timezone \*tz);

**说明**：其参数tv是保存获取时间结果的结构体，参数tz用于保存时区结果（若不使用则传入NULL即可）。

timeval的定义为：

**\[cpp\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  **struct** timeval \{  
2.  　　**long** tv\_sec; // 秒数  
3.  　　**long** tv\_usec; //微秒数  
4.  \}

可见该函数可用于在linux中获得微秒精度的时间。

**用法**：

**\[cpp\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  **struct** timeval start,end;  
2.  gettimeofday(&start, NULL );  
3.  //…calculating…  
4.  gettimeofday(&end, NULL );  
5.  **long** timeuse =1000000 \* ( end.tv\_sec - start.tv\_sec ) + end.tv\_usec - start.tv\_usec;  
6.  printf("time=%f\\n",timeuse /1000000.0);

**总结**：使用这种方式计时，精度可达微秒。经验证，在arm+linux的环境下此函数仍可使用。推荐。

## 7. RDTSC - 读取时间标签计数器 ##

X86[架构][Link 2]CPU汇编指令。

**操作码**：0F 31 **指令**：RDTSC

**功能**：将时间标签计数器读入 EDX:EAX寄存器中。

**说明**：在Pentium以上的CPU中，提供了一条机器指令RDTSC来读取这个时间戳的数字，并将其保存在EDX:EAX寄存器对中。由于EDX:EAX寄存器对恰好是Win32平台下C++语言保存函数返回值的寄存器，所以我们可以把这条指令看成是一个普通的函数调用：

**\[cpp\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  **inline** unsigned **long** longGetCycleCount()   
2.  \{   
3.      \_\_asm RDTSC   
4.  \}

如果编译器不允许直接用RDTSC的话，可以用\_emit伪指令直接嵌入该指令的机器码形式0X0F、0X31：

**\[cpp\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  **inline** unsigned **long** **long** GetCycleCount()   
2.  \{  
3.      \_\_asm \_emit 0x0F   
4.      \_\_asm \_emit 0x31  
5.  \}

计算时还需要将得到的数字除以CPU的主频（单位GHZ），就能得到纳秒级的时间了。暂时我还没找到好的获得机器主频的方法，Windows平台下可以考虑用QueryPerformanceFrequency()函数，但这样一来就没办法在Linux下使用此方法。后来我考虑配合sleep函数，获取1秒中的机器周期数的方法来得到CPU主频。如果哪位有更好的方法，还请多多请教。

**\[cpp\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  \#ifdef WIN32  
2.  \#include <windows.h>  
3.  \#else  
4.  \#include <sys/unistd.h>  
5.  \#endif  
6.  **inline** unsigned **long** **long** GetNTime()  
7.  \{  
8.      \_\_asm("RDTSC");  
9.  \}  
10.   
11. **static** **double** hz=0.0;  
12.   
13. **void** init\_timer()  
14. \{  
15.     longlong t1=GetNTime();  
16. \#ifdef WIN32  
17.     Sleep(1000);  
18. \#else  
19.     sleep(1);  
20. \#endif  
21.     longlong t=GetNTime()-t1;  
22.     hz=(**double**)t/1000000000;  
23.     printf("hz=%fGhz\\n",hz);  
24. \}  
25.   
26. **long** **long** u\_timer(**long** **long** \*t,**int** mode)  
27. \{  
28.     **if**(hz<0.001)  
29.         init\_timer();  
30.     **if**(!mode)  
31.     \{  
32.         \*t=GetNTime();  
33.         return0;  
34.     \}  
35.   
36.     longlong t1=GetNTime()-\*t;  
37.     t1/=hz;  
38.     longlong ns=t1%1000;  
39.     longlong us=(t1/1000)%1000;  
40.     longlong ms=(t1/1000000)%1000;  
41.     longlong s=t1/1000000000;  
42.   
43.     printf("time=");  
44.     **if**(s!=0)  
45.         printf("%llds",s);  
46.     **if**(ms!=0)  
47.         printf("%lldms",ms);  
48.     **if**(us!=0)  
49.         printf("%lldus",us);  
50.     **if**(ns!=0)  
51.         printf("%lldns",ns);  
52.     printf("\\n");  
53.   
54.     \*t=GetNTime();  
55.     returnt1;  
56. \}

**总结**：这种方法精确到纳秒，但缺点是非常短时间的计时会不稳定。最近因为项目需要，我也找了一下ARM+Linux平台上可以用的计时方法，后来选择了gettimeofday()。不知道ARM+Linux平台上有没有类似RDTSC的这种指令。

[Link 1]: http://lib.csdn.net/base/softwaretest
[C]: http://lib.csdn.net/base/c
[Linux]: http://lib.csdn.net/base/linux
[http_blog.sina.com.cn_s_blog_5d9051c00100jcsn.html]: http://blog.sina.com.cn/s/blog_5d9051c00100jcsn.html
[http_www.phpzy.com_php_1068620.html]: http://www.phpzy.com/php/1068620.html
[http_www.uplook.cn_index-Index-show-view2681.html_treeid_624]: http://www.uplook.cn/index-Index-show-view2681.html?treeid=624
[http_sunxiunan.com_p_983]: http://sunxiunan.com/?p=983
[http_msdn.microsoft.com_en-us_library_ee417693.aspx]: http://msdn.microsoft.com/en-us/library/ee417693.aspx
[http_www.oschina.net_code_snippet_197161_6789]: http://www.oschina.net/code/snippet_197161_6789
[view plain]: http://blog.csdn.net/fz_ywj/article/details/8109368#
[Link 2]: http://lib.csdn.net/base/architecture