C++ boost timer

小鱼儿 2022-06-03 06:59 241阅读 0赞

boost库中的timer类能够为程序员提供毫秒级别的操作精度和操作函数，它是一个小型的计时器，可以用来测量时间的流逝。

timer类位于boost命名空间下，使用时需要包含头文件：`#include <boost\timer.hpp>`  
下面是timer使用示例：

timer _timer;
    
        cout << "可度量的最大时间(s):" << _timer.elapsed_max() << endl;
    
        cout << "可度量的最小时间(s):" << _timer.elapsed_min() << endl;
    
        cout << "已经流逝的时间(s):" << _timer.elapsed() << endl;

输出可以参考下面的结果：

可度量的最大时间:2.14748e+06
    可度量的最小时间:0.001
    已经流逝的时间:0.195

由于机器的不同，其中elapsed\_max()返回的结果也不同，这一点相信大家都有所了解，这里的结果仅供参考。

timer类是很短小精悍的一个类，它的代码行数很少，而且加上构造函数也就五个函数。这里贴出它的源码：

// boost timer.hpp header file ---------------------------------------------//
    
    // Copyright Beman Dawes 1994-99. Distributed under the Boost
    // Software License, Version 1.0. (See accompanying file
    // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
    
    // See http://www.boost.org/libs/timer for documentation.
    
    // Revision History
    // 01 Apr 01 Modified to use new <boost/limits.hpp> header. (JMaddock)
    // 12 Jan 01 Change to inline implementation to allow use without library
    // builds. See docs for more rationale. (Beman Dawes) 
    // 25 Sep 99 elapsed_max() and elapsed_min() added (John Maddock)
    // 16 Jul 99 Second beta
    // 6 Jul 99 Initial boost version
    
    #ifndef BOOST_TIMER_HPP
    #define BOOST_TIMER_HPP
    
    #include <boost/config.hpp>
    #include <ctime>
    #include <boost/limits.hpp>
    
    # ifdef BOOST_NO_STDC_NAMESPACE
        namespace std {  using ::clock_t; using ::clock; }
    # endif
    
    
    namespace boost { 
    
    // timer -------------------------------------------------------------------//
    
    // A timer object measures elapsed time.
    
    // It is recommended that implementations measure wall clock rather than CPU
    // time since the intended use is performance measurement on systems where
    // total elapsed time is more important than just process or CPU time.
    
    // Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
    // due to implementation limitations. The accuracy of timings depends on the
    // accuracy of timing information provided by the underlying platform, and
    // this varies a great deal from platform to platform.
    
    class timer { 
     public:
             timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
    // timer( const timer& src ); // post: elapsed()==src.elapsed()
    // ~timer(){}
    // timer& operator=( const timer& src ); // post: elapsed()==src.elapsed()
      void   restart() { _start_time = std::clock(); } // post: elapsed()==0
      double elapsed() const                  // return elapsed time in seconds
        { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
    
      double elapsed_max() const   // return estimated maximum value for elapsed()
      // Portability warning: elapsed_max() may return too high a value on systems
      // where std::clock_t overflows or resets at surprising values.
      {
        return (double((std::numeric_limits<std::clock_t>::max)())
           - double(_start_time)) / double(CLOCKS_PER_SEC); 
      }
    
      double elapsed_min() const            // return minimum value for elapsed()
       { return double(1)/double(CLOCKS_PER_SEC); }
    
     private:
      std::clock_t _start_time;
    }; // timer
    
    } // namespace boost
    
    #endif // BOOST_TIMER_HPP

可以看到，在我们构造timer对象的时候，它调用的是 std::clock()，返回程序启动以来的clock数，并且保存在私有变量\_start\_time中。每次调用elapsed()函数，它会重新调用std::clock()函数获取此时的clock数，然后减去启动clock数，然后除以每秒的clock数来获得已经用了多长时间。

其中CLOCKS\_PER\_SEC是一个宏定义，\#define CLOCKS\_PER\_SEC ((clock\_t)1000)  
可以看到它的值是每秒1000.

至于获取最小度量，那就是一次要多少秒，计算很简单，1/CLOCKS\_PER\_SEC =0.001

其中还有一个函数restart（），调用该函数会重新开始计数，\_start\_time的值将被重置。

大家看到这里可能会注意到，timer类并没有析构函数，在看下类的定义，只有一个本质为long型的\_start\_time变量，所以这里其实也没有资源来特意释放的。

既然boost中可以使用timer来获取时间跨度，那么我们在温习以下c++中是怎么使用的。  
这里我用了一种不经常使用的方式。

double time = 0;
        double counts = 0;
        LARGE_INTEGER nFreq;
        LARGE_INTEGER nBeginTime;
        LARGE_INTEGER nEndTime;
        QueryPerformanceFrequency(&nFreq);
        QueryPerformanceCounter(&nBeginTime);//开始计时 
        while (counts++ < 1000000)
        {
            continue;
        }
        QueryPerformanceCounter(&nEndTime);//停止计时 
        time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / (double)nFreq.QuadPart;//计算程序执行时间单位为s 
        cout << "运行时间：" << time * 1000 << "ms" << endl;

其中的函数我们先放一边，待会在仔细看，这里我们先看下结果：

运行时间：5.50927ms

百万次级别的count++运算才只用了5毫秒左右，不得不说还是挺快的，当然这和我在代码中写的逻辑比较简单有关。

我们先看下其中用到的LARGE\_INTEGER联合体：

typedef union _LARGE_INTEGER {
        struct {
            DWORD LowPart;
            LONG HighPart;
        } DUMMYSTRUCTNAME;
        struct {
            DWORD LowPart;
            LONG HighPart;
        } u;
        LONGLONG QuadPart;
    } LARGE_INTEGER;

这个联合体中： LowPart表示低32位，HighPart表示高32位，QuadPart表示一个64位的整型。

如果你的操作系统不支持64位，那么存储数据的时候就应该使用LowPart和HighPart成员来存储，否则的话直接使用QuadPart就好了。

QueryPerformanceFrequency函数：获得机器内部计时器的时钟频率  
检索性能计数器的频率。性能计数器的频率在系统启动时固定，并且在所有处理器中保持一致。因此，只需要在应用程序初始化时查询频率，结果就可以被缓存。

原型：

BOOL WINAPI QueryPerformanceFrequency（
      _Out_ LARGE_INTEGER * lpFrequency
    ）;

参数  
lpFrequency \[out\]  
指向一个变量的指针，以每秒计数的形式接收当前的性能计数器频率。如果安装的硬件不支持高分辨率性能计数器，则此参数可以为零（在运行Windows XP或更高版本的系统上不会发生此问题）。

返回值  
如果安装的硬件支持高分辨率性能计数器，则返回值不为零。

如果函数失败，返回值为零。要获得扩展错误信息，请调用GetLastError。在运行Windows XP或更高版本的系统上，该函数将始终成功，因此永远不会返回零。

QueryPerformanceCounter函数  
检索性能计数器的当前值，该值是高分辨率（<1us）时间戳，可用于时间间隔测量。

句法  
BOOL WINAPI QueryPerformanceCounter（  
*Out* LARGE\_INTEGER \* lpPerformanceCount  
）;

参数  
lpPerformanceCount \[out\]  
指向接收当前性能计数器值的变量的指针（以计数为单位）。

返回值  
如果函数成功，返回值是非零的。