C++11 中chrono库实现高精度定时

我不是女神ヾ 2022-04-13 21:25 770阅读 0赞

一种“传统”ctime计时方法：

#include <ctime>
    using namespace std;
    
    clock_t start = clock();
    // do something...
    clock_t end   = clock();
    cout << "using" << (double)(end - start) / CLOCKS_PER_SEC << "s" << endl;

C++ 11 中的chrono库:

#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 <<  "using" 
         << double(duration.count()) * microseconds::period::num / microseconds::period::den 
         << "s" << endl;

### chrono： ###

chrono库主要包含了三种类型：时间间隔Duration、时钟Clocks和时间点Time point。

### Duration： ###

duration表示一段时间间隔，用来记录时间长度，可以表示几秒钟、几分钟或者几个小时的时间间隔，duration的原型是：

template<class Rep, class Period = std::ratio<1>> class duration;

第一个模板参数Rep是一个数值类型，表示时钟个数；第二个模板参数是一个默认模板参数std::ratio，它的原型是：

template<std::intmax\_t Num, std::intmax\_t Denom = 1> class ratio;

它表示每个时钟周期的秒数，其中第一个模板参数Num代表分子，Denom代表分母，分母默认为1，ratio代表的是一个分子除以分母的分数值，比如ratio<2>代表一个时钟周期是两秒，ratio<60>代表了一分钟，ratio<60\*60>代表一个小时，ratio<60\*60\*24>代表一天。而ratio<1, 1000>代表的则是1/1000秒即一毫秒，ratio<1, 1000000>代表一微秒，ratio<1, 1000000000>代表一纳秒。标准库为了方便使用，就定义了一些常用的时间间隔，如时、分、秒、毫秒、微秒和纳秒，在chrono命名空间下，它们的定义如下:

typedef duration <Rep, ratio<3600,1>> hours;
    typedef duration <Rep, ratio<60,1>> minutes;
    typedef duration <Rep, ratio<1,1>> seconds;
    typedef duration <Rep, ratio<1,1000>> milliseconds;
    typedef duration <Rep, ratio<1,1000000>> microseconds;
    typedef duration <Rep, ratio<1,1000000000>> nanoseconds;

`　　通过定义这些常用的时间间隔类型，我们能方便的使用它们，比如线程的休眠：`

std::this_thread::sleep_for(std::chrono::seconds(3)); //休眠三秒
    std::this_thread::sleep_for(std::chrono:: milliseconds (100)); //休眠100毫秒

### Time point： ###

time\_point表示一个时间点，用来获取1970.1.1以来的秒数和当前的时间, 可以做一些时间的比较和算术运算，可以和ctime库结合起来显示时间。time\_point必须要clock来计时，time\_point有一个函数time\_from\_eproch()用来获得1970年1月1日到time\_point时间经过的duration。下面的例子计算当前时间距离1970年1月一日有多少天：

#include <ratio>
    #include <chrono>
    
    int main ()
    {
    using namespace std::chrono;
    typedef duration<int,std::ratio<60*60*24>> days_type;
    
    time_point<system_clock,days_type> today = time_point_cast<days_type>(system_clock::now());
    
    std::cout << today.time_since_epoch().count() << " days since epoch" << std::endl;
    
    return 0;
    }

### Clocks： ###

表示当前的系统时钟，内部有time\_point, duration, Rep, Period等信息，它主要用来获取当前时间，以及实现time\_t和time\_point的相互转换。Clocks包含三种时钟：

system\_clock：从系统获取的时钟；

steady\_clock：不能被修改的时钟；

high\_resolution\_clock：高精度时钟，实际上是system\_clock或者steady\_clock的别名。

可以通过now()来获取当前时间点:

#include <iostream>
    #include <chrono>
    int main()
    {
    std::chrono::steady_clock::time_point t1 = std::chrono::system_clock::now();
    std::cout << "Hello World\n";
    std::chrono::steady_clock::time_point t2 = std::chrono:: system_clock::now();
    std::cout << (t2-t1).count()<<” tick count”<<endl;
    }

通过时钟获取两个时间点之相差多少个时钟周期，我们可以通过duration\_cast将其转换为其它时钟周期的duration：

cout << std::chrono::duration\_cast<std::chrono::microseconds>( t2-t1 ).count() <<” microseconds”<< endl;

system\_clock的to\_time\_t方法可以将一个time\_point转换为ctime，而from\_time\_t方法则是相反的，它将ctime转换为time\_point：

std::time\_t now\_c = std::chrono::system\_clock::to\_time\_t(time\_point);

可以利用high\_resolution\_clock来实现一个类似于boost.timer的定时器，这样的timer在测试性能时会经常用到，经常用它来测试函数耗时，可实现毫秒微秒级定时，它的基本用法是这样的：

#include<chrono>
    usingnamespace std;
    usingnamespace std::chrono;
    classTimer
    {
    public:
    Timer() : m_begin(high_resolution_clock::now()) {}
    void reset() { m_begin = high_resolution_clock::now(); }
    //默认输出毫秒
    int64_t elapsed() const
    {
    return duration_cast<chrono::milliseconds>(high_resolution_clock::now() - m_begin).count();
    }
    //微秒
    int64_t elapsed_micro() const
    {
    return duration_cast<chrono::microseconds>(high_resolution_clock::now() - m_begin).count();
    }
    //纳秒
    int64_t elapsed_nano() const
    {
    return duration_cast<chrono::nanoseconds>(high_resolution_clock::now() - m_begin).count();
    }
    //秒
    int64_t elapsed_seconds() const
    {
    return duration_cast<chrono::seconds>(high_resolution_clock::now() - m_begin).count();
    }
    //分
    int64_t elapsed_minutes() const
    {
    return duration_cast<chrono::minutes>(high_resolution_clock::now() - m_begin).count();
    }
    //时
    int64_t elapsed_hours() const
    {
    return duration_cast<chrono::hours>(high_resolution_clock::now() - m_begin).count();
    }
    private:
    time_point<high_resolution_clock> m_begin;
    };

测试代码：

void fun()
    {
    cout<<”hello word”<<endl;
    }
    int main()
    {
    timer t; //开始计时
    fun()
    cout<<t.elapsed()<<endl; //打印fun函数耗时多少毫秒
    cout<<t.elapsed_micro ()<<endl; //打印微秒
    cout<<t.elapsed_nano ()<<endl; //打印纳秒
    cout<<t.elapsed_seconds()<<endl; //打印秒
    cout<<t.elapsed_minutes()<<endl; //打印分钟
    cout<<t.elapsed_hours()<<endl; //打印小时
    }

### 下面介绍duration中一些重要的成员函数： ###

template<class _Rep2,
            class = typename enable_if<is_convertible<_Rep2, _Rep>::value
                && (treat_as_floating_point<_Rep>::value
                    || !treat_as_floating_point<_Rep2>::value),
                void>::type>
            constexpr explicit duration(const _Rep2& _Val)
                : _MyRep(static_cast<_Rep>(_Val))
            {    // construct from representation
            }

使用另一个数值类型的值来构造。它是使用static\_cast()来进行转换的。要求1：\_Rep2必须能够隐式转换为\_Rep:。要求2：\_Rep为浮点型或者\_Rep2不是浮点型。否则编译失败。

template<class _Rep2,
            class _Period2,
            class = typename enable_if<treat_as_floating_point<_Rep>::value
                || (_Ratio_divide_sfinae<_Period2, _Period>::den == 1
                    && !treat_as_floating_point<_Rep2>::value),
                void>::type>
            constexpr duration(const duration<_Rep2, _Period2>& _Dur)
                : _MyRep(chrono::duration_cast<_Myt>(_Dur).count())
            {    // construct from a duration
            }

使用另一个chrono对象来构造，内部通过duration\_cast()来转换。以下2种情况可以通过编译：  
1.\_Rep是一种浮点型。

2.\_Rep和\_Rep都是一种整型，此时要求ratio\_divide<\_Period2, \_Period>::type::den必须为1。意思就是\_Period2是\_Period的整数倍。

这样规定的目的是为了避免精度损失，以及避免从小单位向大单位转换。如果不使用这个构造函数，而直接使用duration\_cast()函数，则直接绕过了这些检查，可能会导致精度丢失或数据截断。

constexpr \_Rep count() const  
        \{    // get stored rep  
        return (\_MyRep);  
        \}  
得到当前对象保存的\_Period的个数。

template<class _Rep1,
        class _Period1,
        class _Rep2,
        class _Period2> inline
        constexpr bool operator==(
            const duration<_Rep1, _Period1>& _Left,
            const duration<_Rep2, _Period2>& _Right)
        {    // test if duration == duration
        typedef typename common_type<
            duration<_Rep1, _Period1>,
            duration<_Rep2, _Period2> >::type _CT;
        return (_CT(_Left).count() == _CT(_Right).count());
        }

比较两个duration对象是否想等，由源码得知，比较前先将两个对象转换为通用类型，然后再比较。  
例如：duration<int,std::ratio<2,3> >和duration<int,std::ratio<3,7> >都转换为duration<int,std::ratio<1,21> >。

还有min()、max()、zero()函数，分别代表最小、最大、0值，返回的都是自身类型。

剩下的就是一些算术运算和关系运算函数。

参考链接:

[https://blog.csdn.net/u013390476/article/details/50209603][https_blog.csdn.net_u013390476_article_details_50209603]

[https://en.cppreference.com/w/cpp/chrono/duration][https_en.cppreference.com_w_cpp_chrono_duration]

[https://blog.csdn.net/oncealong/article/details/28599655][https_blog.csdn.net_oncealong_article_details_28599655]

[https://blog.csdn.net/t114211200/article/details/78029553][https_blog.csdn.net_t114211200_article_details_78029553]

[https_blog.csdn.net_u013390476_article_details_50209603]: https://blog.csdn.net/u013390476/article/details/50209603
[https_en.cppreference.com_w_cpp_chrono_duration]: https://en.cppreference.com/w/cpp/chrono/duration
[https_blog.csdn.net_oncealong_article_details_28599655]: https://blog.csdn.net/oncealong/article/details/28599655
[https_blog.csdn.net_t114211200_article_details_78029553]: https://blog.csdn.net/t114211200/article/details/78029553