Linux+Qt 算法运行时间（计时函数）

Bertha 。 2022-08-13 15:52 201阅读 0赞

【问题描述】程序运行时间是编程的一项重要指标，如何测算程序的运行时间呢？

【解析】

2017年7月18日更新:

#include <chrono>   
    using namespace std;
    using namespace chrono;
    auto start = system_clock::now();
    // do something...
    auto end = system_clock::now();
    auto duration = duration_cast<microseconds>(end - start);
    cout << "花费了"<< double(duration.count())<< "毫秒" << endl;

测试函数

**\[html\]**  [view plain][] [copy][view plain]

1.  \#include **<****math.h****>**  
2.    
3.  void function()  
4.  \{  
5.      unsigned int i,j;  
6.      double y;  
7.    
8.      for(i=0;i**<****1000**;i++)  
9.          for(j=0;j**<****1000**;j++)  
10.             y=sin((double)i);  
11. \}

**方法1** 如果在QT中，利用QTime，其精度为ms级\----------在QT中使用。

**\[html\]**  [view plain][] [copy][view plain]

1.  \#include **<****QDebug****>**  
2.  \#include **<****QTime****>**  
3.    
4.  QTime time;  
5.    
6.  time.start();  
7.  function();  
8.    
9.  qDebug()**<****<****time.elapsed**()/1000.0**<****<**"s";

运行结果：0.109 s

**方法2** 利用gettimeofday()，其精度为us级\----------C语言实现，在C++环境、QT、VC中也能用。

**\[html\]**  [view plain][] [copy][view plain]

1.  \#include **<****QDebug****>**  
2.  \#include **<****sys**/time.h**>**  
3.    
4.  struct timeval tpstart,tpend;  
5.  float timeuse;  
6.    
7.  gettimeofday(&tpstart,NULL);  
8.  function();  
9.  gettimeofday(&tpend,NULL);  
10. timeuse=(1000000\*(tpend.tv\_sec-tpstart.tv\_sec) + tpend.tv\_usec-tpstart.tv\_usec)/1000000.0;  
11.   
12. qDebug()**<****<****timeuse****<****<**"s";

运行结果：0.109375 s

**方法3** 利用clock()，其精度为ms级\----------C++实现，在VC和QT中也可以使用。

**\[html\]**  [view plain][] [copy][view plain]

1.  \#include **<****QDebug****>**  
2.  \#include **<****sys**/time.h**>**  
3.    
4.  double time\_Start = (double)clock();  
5.  function();  
6.  double time\_End = (double)clock();  
7.        
8.  qDebug()**<****<**(time\_End - time\_Start)/1000.0**<****<**"s";

运行结果：0.11 s

**方法4** 利用windows.h(VC)函数，其精度为us级\----------在VC和QT中使用。

**\[html\]**  [view plain][] [copy][view plain]

1.  \#include **<****QDebug****>**  
2.  \#include **<****windows.h****>**  
3.    
4.  LARGE\_INTEGER litmp;  
5.  LONGLONG Qpart1,Qpart2,Useingtime;  
6.  double dfMinus,dfFreq,dfTime;  
7.    
8.  //获得CPU计时器的时钟频率  
9.  QueryPerformanceFrequency(&litmp);//取得高精度运行计数器的频率f,单位是每秒多少次（n/s），  
10. dfFreq = (double)litmp.QuadPart;  
11.   
12. QueryPerformanceCounter(&litmp);//取得高精度运行计数器的数值  
13. Qpart1 = litmp.QuadPart; //开始计时  
14.   
15. function(); //待测试的计算函数等  
16.   
17. QueryPerformanceCounter(&litmp);//取得高精度运行计数器的数值  
18. Qpart2 = litmp.QuadPart; //终止计时  
19.   
20. dfMinus = (double)(Qpart2 - Qpart1);//计算计数器值  
21. dfTime = dfMinus / dfFreq;//获得对应时间，单位为秒,可以乘1000000精确到微秒级（us）  
22. Useingtime = dfTime\*1000000;  
23.   
24. qDebug()**<****<****dfTime****<****<**"s";

运行结果：0.107415 s

【代码清单】

**\[html\]**  [view plain][] [copy][view plain]

1.  \#include **<****QDebug****>**  
2.  \#include **<****QTime****>**  
3.  \#include **<****sys**/time.h**>**  
4.  \#include **<****windows.h****>**  
5.  \#include **<****math.h****>**  
6.    
7.  void function();  
8.    
9.  int main(void)  
10. \{  
11.     qDebug()**<****<**"-------------------------------";  
12.     //-1-  
13.     QTime time;  
14.     time.start();  
15.     function();  
16.     qDebug()**<****<****time.elapsed**()/1000.0**<****<**"s";  
17.   
18.     //-2-  
19.     struct timeval tpstart,tpend;  
20.     float timeuse;  
21.     gettimeofday(&tpstart,NULL);  
22.     function();  
23.     gettimeofday(&tpend,NULL);  
24.     timeuse=(1000000\*(tpend.tv\_sec-tpstart.tv\_sec) + tpend.tv\_usec-tpstart.tv\_usec)/1000000.0;  
25.     qDebug()**<****<****timeuse****<****<**"s";  
26.   
27.     //-3-  
28.     double time\_Start = (double)clock();  
29.     function();  
30.     double time\_End = (double)clock();  
31.     qDebug()**<****<**(time\_End - time\_Start)/1000.0**<****<**"s";  
32.   
33.     //-4-  
34.     LARGE\_INTEGER litmp;  
35.     LONGLONG Qpart1,Qpart2,Useingtime;  
36.     double dfMinus,dfFreq,dfTime;  
37.   
38.     //获得CPU计时器的时钟频率  
39.     QueryPerformanceFrequency(&litmp);//取得高精度运行计数器的频率f,单位是每秒多少次（n/s），  
40.     dfFreq = (double)litmp.QuadPart;  
41.   
42.     QueryPerformanceCounter(&litmp);//取得高精度运行计数器的数值  
43.     Qpart1 = litmp.QuadPart; //开始计时  
44.   
45.     function(); //待测试的计算函数等  
46.   
47.     QueryPerformanceCounter(&litmp);//取得高精度运行计数器的数值  
48.     Qpart2 = litmp.QuadPart; //终止计时  
49.   
50.     dfMinus = (double)(Qpart2 - Qpart1);//计算计数器值  
51.     dfTime = dfMinus / dfFreq;//获得对应时间，单位为秒,可以乘1000000精确到微秒级（us）  
52.     Useingtime = dfTime\*1000000;  
53.   
54.     qDebug()**<****<****dfTime****<****<**"s";  
55.   
56.     return 0;  
57. \}  
58.   
59. void function()  
60. \{  
61.     unsigned int i,j;  
62.     double y;  
63.   
64.     for(i=0;i**<****1000**;i++)  
65.         for(j=0;j**<****1000**;j++)  
66.             y=sin((double)i);  
67. \}

1.  
2.  
3.  \----------------------------------------------------------------------------
4.  **另外，方法2可具体参考：**
5.  在测试程序时，我们往往需要了解程序执行所需的时间，在C语言可以使用函数gettimeofday来得到时间，它的调用格式是：
    
    \#include <sys/time.h>int gettimeofday(struct timeval \*tv,struct timezone \*tz);int settimeofday(const struct timeval \*tv , const structtimezone \*tz);
    
    其中结构timeval的定义为：
    
    strut timeval \{long tv\_sec;long tv\_usec;\};
    
    可以看出，使用这种方式计时，精度可达微秒。
    
    进行计时的时候，我们需要前后调用两次gettimeofday，然后计算中间的差值,实例代码如下：
    
    \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
    
    gettimeofday( &start, NULL );
    
    foo(); //示例函数
    
    gettimeofday( &end, NULL);
    
    timeuse = 1000000 \* ( end.tv\_sec - start.tv\_sec ) + end.tv\_usec -start.tv\_usec;
    
    timeuse /=1000000;
    
    \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
    
    其中start，end 是结构体所定义的timeval型。
6.  \--------------------------------------------------------------------------------
7.  **方法3可具体参考：**
8.  我现在用C++语言写了一段程序，想计算这段程序运行的准确时间，这是要用于跟其它实验结果作对比的，所以要精确到毫秒，C++程序运行时间 确实很难掌握啊！
    
    [C++][C]程序运行时间中的计时函数是clock()，而与其相关的数据类型是clock\_t。在MSDN中，查得对clock函数定义如下：  
    
        #ifndef   _CLOCK_T_DEFINED     
               typedef   long   clock_t;     
               #define   _CLOCK_T_DEFINED     
               #endif    
    
    这个函数返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock   tick）数，在MSDN中称之为挂钟时间（wal-clock）。其中clock\_t是用来保存时间的数据类型，在time.h文件中，我们可以找到对 它的定义：  
    
        #ifndef   _CLOCK_T_DEFINED     
               typedef   long   clock_t;     
               #define   _CLOCK_T_DEFINED     
               #endif    
    
    很明显，clock\_t是一个长整形数。在time.h文件中，还定义了一个常量CLOCKS\_PER\_SEC，它用来表示一秒钟会有多少个时钟计时单元，其定义如下：   
    
         
              int   main(   void   )     
              {     
                    long         i   =   10000000L;     
                    clock_t   start,   finish;     
                    double     duration;     
                    /*   测量一个事件持续的时间*/     
                    printf(   "Time   to   do   %ld   empty   loops   is   ",   i   );     
                    start   =   clock();     
                    while(   i--   )             ;     
                    finish   =   clock();     
                    duration   =   (double)(finish   -   start)   /   CLOCKS_PER_SEC;     
                    printf(   "%f   seconds"n",   duration   );     
                    system("pause");     
              }    
    
    可以看到每过千分之一秒（1毫秒），调用clock（）函数返回的值就加1。下面举个例子，你可以使用公式clock()/CLOCKS\_PER\_SEC来计算一个进程自身的C++程序运行时间 ：
    
        void   elapsed_time()     
                {     
                printf("Elapsed   time:%u   secs."n",clock()/CLOCKS_PER_SEC);     
                }    
    
    当然，你也可以用clock函数来计算你的机器运行一个循环或者处理其它事件到底花了多少时间：  
    
         
              int   main(   void   )     
              {     
                    long         i   =   10000000L;     
                    clock_t   start,   finish;     
                    double     duration;     
                    /*   测量一个事件持续的时间*/     
                    printf(   "Time   to   do   %ld   empty   loops   is   ",   i   );     
                    start   =   clock();     
                    while(   i--   )             ;     
                    finish   =   clock();     
                    duration   =   (double)(finish   -   start)   /   CLOCKS_PER_SEC;     
                    printf(   "%f   seconds"n",   duration   );     
                    system("pause");     
              }    
    
    上面我们看到时钟计时单元的长度为1毫秒，那么计时的精度也为1毫秒，那么我们可不可以通过改变CLOCKS\_PER\_SEC的定义，通过把它定义的大一 些，从而使计时精度更高呢？通过尝试，你会发现这样是不行的。在标准C++程序运行时间 中，最小的计时单位是一毫秒。

[view plain]: http://blog.csdn.net/tandesir/article/details/7821698#
[C]: http://developer.51cto.com/art/200509/3641.htm

发表评论取消回复

表情：

评论列表（有 0 条评论，201人围观）

还没有评论，来说两句吧...

相关阅读

相关 python 控制函数运行时间

版本1 from contextlib import contextmanager @contextmanager def timeout(dura

绝地灬酷狼/ 2023年01月17日 10:43/ 0 赞/ 96 阅读

相关 matlab程序运行计时,【求教】请问如何为程序的运行时间计时

\[R\] query -- Display system parameters \[R\] set -- Overview of system parameters Sy

Love The Way You Lie/ 2023年01月15日 03:55/ 0 赞/ 155 阅读

相关 js 天数倒计时时间倒计时

export function getOverTimeDown(endDateStr: string, outValue?: { value: string }, fn

àì夳堔傛蜴生んèń/ 2022年09月11日 12:10/ 0 赞/ 260 阅读

相关 Linux+Qt 算法运行时间（计时函数）

【问题描述】程序运行时间是编程的一项重要指标，如何测算程序的运行时间呢？【解析】 2017年7月18日更新: include <chr

Bertha 。/ 2022年08月13日 15:52/ 0 赞/ 202 阅读

相关 opencv 计时函数

opencv 计时我们知道opencv中有时候需要知道算法的执行时间，来衡量算法的优劣性,那么opencv 怎样进行计时呢？opencv中主要用两个函数来进行计时操

川长思鸟来/ 2022年08月08日 03:19/ 0 赞/ 182 阅读

相关时间倒计时

距年底还有多长时间 <div id="a"></div> <div id="b"></div> <script> functio

柔光的暖阳◎/ 2022年07月15日 15:10/ 0 赞/ 179 阅读

相关时间戳倒计时

var defaultTimeStamp = Math.floor(Date.now()/1000); var dayA = defaultTi

￡神魔★判官ぃ/ 2022年05月23日 13:41/ 0 赞/ 205 阅读

相关 JS时间倒计时

[JS时间倒计时][JS] HTML <div class="con"> <div class="time">

逃离我推掉我的手/ 2022年04月24日 04:44/ 0 赞/ 203 阅读

相关 python测量函数运行时间长度

python测试函数运行时间长度的方法如下 import time def measure_time(): def wraps(func):

深碍√TFBOYSˉ_/ 2021年12月23日 10:51/ 0 赞/ 337 阅读

相关检验函数运行时间

<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> ...

红太狼/ 2021年03月26日 15:00/ 0 赞/ 522 阅读