C++实现统计代码运行时间的示例详解

博君一肖 · 发布于 2023-5-12 13:47:57

原本想自己写的，一看github上面都有就不再反复造轮子了。github上的项目如下：

std::chrono::high_resolution_clock

std::chrono::steady_clock

QueryPerformanceCounter

std::chrono::steady_clock

纯规范库实现

第一种纯规范库实现的Stopwatch.hpp内容如下：
// Copyright Ingo Proff 2017.
// https://github.com/CrikeeIP/Stopwatch
// Distributed under the MIT Software License (X11 license).
// (See accompanying file LICENSE)

#pragma once

#include <vector>
#include <string>
#include <chrono>

namespace stopwatch{

class Stopwatch{
public:
enum TimeFormat{ NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS };

Stopwatch(): start_time(), laps({}) {
   start();
}

void start(){
   start_time = std::chrono::high_resolution_clock::now();
   laps = {start_time};
}

template<TimeFormat fmt = TimeFormat::MILLISECONDS>
std::uint64_t lap(){
   const auto t = std::chrono::high_resolution_clock::now();
   const auto last_r = laps.back();
   laps.push_back( t );
   return ticks<fmt>(last_r, t);
}

template<TimeFormat fmt = TimeFormat::MILLISECONDS>
std::uint64_t elapsed(){
   const auto end_time = std::chrono::high_resolution_clock::now();
   return ticks<fmt>(start_time, end_time);
}

template<TimeFormat fmt_total = TimeFormat::MILLISECONDS, TimeFormat fmt_lap = fmt_total>
std::pair<std::uint64_t, std::vector<std::uint64_t>> elapsed_laps(){
   std::vector<std::uint64_t> lap_times;
   lap_times.reserve(laps.size()-1);

   for( std::size_t idx = 0; idx <= laps.size()-2; idx++){
      const auto lap_end = laps[idx+1];
      const auto lap_start = laps[idx];
      lap_times.push_back( ticks<fmt_lap>(lap_start, lap_end) );
   }

   return { ticks<fmt_total>(start_time, laps.back()), lap_times };
}

private:
typedef std::chrono::time_point<std::chrono::high_resolution_clock> time_pt;
time_pt start_time;
std::vector<time_pt> laps;

template<TimeFormat fmt = TimeFormat::MILLISECONDS>
static std::uint64_t ticks( const time_pt& start_time, const time_pt& end_time){
   const auto duration = end_time - start_time;
   const std::uint64_t ns_count = std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count();

   switch(fmt){
   case TimeFormat::NANOSECONDS:
   {
      return ns_count;
   }
   case TimeFormat::MICROSECONDS:
   {
      std::uint64_t up = ((ns_count/100)%10 >= 5) ? 1 : 0;
      const auto mus_count = (ns_count /1000) + up;
      return mus_count;
   }
   case TimeFormat::MILLISECONDS:
   {
      std::uint64_t up = ((ns_count/100000)%10 >= 5) ? 1 : 0;
      const auto ms_count = (ns_count /1000000) + up;
      return ms_count;
   }
   case TimeFormat::SECONDS:
   {
      std::uint64_t up = ((ns_count/100000000)%10 >= 5) ? 1 : 0;
      const auto s_count = (ns_count /1000000000) + up;
      return s_count;
   }
   }
}
};

constexpr Stopwatch::TimeFormat ns = Stopwatch::TimeFormat::NANOSECONDS;
constexpr Stopwatch::TimeFormat mus = Stopwatch::TimeFormat::MICROSECONDS;
constexpr Stopwatch::TimeFormat ms = Stopwatch::TimeFormat::MILLISECONDS;
constexpr Stopwatch::TimeFormat s = Stopwatch::TimeFormat::SECONDS;

constexpr Stopwatch::TimeFormat nanoseconds = Stopwatch::TimeFormat::NANOSECONDS;
constexpr Stopwatch::TimeFormat microseconds = Stopwatch::TimeFormat::MICROSECONDS;
constexpr Stopwatch::TimeFormat milliseconds = Stopwatch::TimeFormat::MILLISECONDS;
constexpr Stopwatch::TimeFormat seconds = Stopwatch::TimeFormat::SECONDS;

std::string show_times( const std::vector<std::uint64_t>& times ){
std::string result("{");
for( const auto& t : times ){
      result += std::to_string(t) + ",";
}
result.back() = static_cast<char>('}');
return result;
}

}
使用示例如下：
//创建一个stopwatch
sw::Stopwatch my_watch;
my_watch.start();

//Do something time-consuming here...

//纳秒
std::uint64_t elapsed_ns = my_watch.elapsed<sw::ns>();
//微秒
std::uint64_t elapsed_mus = my_watch.elapsed<sw::mus>();
//毫秒
std::uint64_t elapsed_ms = my_watch.elapsed();
//秒
std::uint64_t elapsed_s = my_watch.elapsed<sw::s>();

类似C#的实现

第二品种似C#的实现，StopWatch.h代码如下：
#ifndef __STOPWATCH_H__
#define __STOPWATCH_H__

#if defined(_MSC_VER) || defined(__MINGW32__) || defined(WIN32)
#include <Windows.h>
#else
#include <chrono>
#endif

class StopWatch
{
public:
StopWatch();
~StopWatch();

//开启计时
void Start();

//暂停计时
void Stop();

//重新计时
void ReStart();

//微秒
double Elapsed();

//毫秒
double ElapsedMS();

//秒
double ElapsedSecond();

private:
long long elapsed_;
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(WIN32)
LARGE_INTEGER start_;
LARGE_INTEGER stop_;
LARGE_INTEGER frequency_;
#else
typedef std::chrono::high_resolution_clock Clock;
typedef std::chrono::microseconds MicroSeconds;
std::chrono::steady_clock::time_point start_;
std::chrono::steady_clock::time_point stop_;
#endif

};

#endif // __STOPWATCH_H__
StopWatch.cpp代码如下：
#include "StopWatch.h"

#if defined(_MSC_VER) || defined(__MINGW32__) || defined(WIN32)
StopWatch::StopWatch():elapsed_(0)
{
elapsed_ = 0;
start_.QuadPart = 0;
stop_.QuadPart = 0;
QueryPerformanceFrequency(&frequency_);
}
#else
StopWatch::StopWatch():elapsed_(0),start_(MicroSeconds::zero()),stop_(MicroSeconds::zero())
{
}
#endif

StopWatch::~StopWatch()
{
}

void StopWatch::Start()
{
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(WIN32)
QueryPerformanceCounter(&start_);
#else
start_ = Clock::now();
#endif

}

void StopWatch::Stop()
{
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(WIN32)
QueryPerformanceCounter(&stop_);
elapsed_ += (stop_.QuadPart - start_.QuadPart) * 1000000 / frequency_.QuadPart;
#else
stop_ = Clock::now();
elapsed_ = std::chrono::duration_cast<MicroSeconds>(stop_ - start_).count();
#endif

}

void StopWatch::ReStart()
{
elapsed_ = 0;
Start();
}

double StopWatch::Elapsed()
{
return static_cast<double>(elapsed_);
}

double StopWatch::ElapsedMS()
{
return elapsed_ / 1000.0;
}

double StopWatch::ElapsedSecond()
{
return elapsed_ / 1000000.0;
}
使用示例如下（和C#比较像）：
StopWatch sw;
sw.Start();
//Do something time-consuming here...
sw.Stop();
std::cout << "运行时间：" << sw.ElapsedMS() << "毫秒" << std::endl;

总结

到此这篇关于C++实现统计代码运行时间的示例详解的文章就介绍到这了,更多相关C++统计代码运行时间内容请搜索网站以前的文章或继续阅读下面的相关文章希望大家以后多多支持网站！