1. 编程号首页

c++ 计时_c++计算程序运行时间[通俗易懂]

编程小号 • • 未分类

c++ 计时_c++计算程序运行时间[通俗易懂]C++算法计时器有时为了检测和比较算法效率和复杂度，需要一个计时器，而这个计时器往往需要精确到毫秒ms甚至纳秒ns_c++计时器

c++

C++算法计时器

有时为了检测和比较算法效率和复杂度，需要一个计时器，而这个计时器往往需要精确到毫秒ms、微秒μs甚至纳秒ns，不太常用的库或api就不放上来了。

1.毫秒级精度

1.1 CLOCKS_PER_SEC

在头文件time.h或ctime中，clock()函数返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数，在MSDN中称之为挂钟时间（wal-clock），常量CLOCKS_PER_SEC，它用来表示一秒钟会有多少个时钟计时单元，精确到毫秒，其使用方法如下:

精华代码：

#include <iostream>
#include<vector>
#include <algorithm>
#include <ctime>
using namespace std;
int main()
{ 
   
    
    clock_t begin, end;
    begin = clock();
    for (int i = 1; i <= 100; ++i)
    { 
   
       
    }
    end = clock();
    cout << "100次循环所用时间：" << double(end - begin) / CLOCKS_PER_SEC * 1000 << "ms" << endl;
       
    return 0;
}

示例为检测二叉堆不同输入一个一个插入所用时间（不能直接跑）：

#include <iostream>
#include<vector>
#include <algorithm>
#include <ctime>
using namespace std;

int main()
{ 
   
    int num, mode;
    cout << "输入大小和模式，其中模式1为正序，2为倒序，3位随机" << endl;
    cout << "示例：1000 2" << endl;
    cin >> num >> mode;//输入大小和模式，其中模式1为正序，2为倒序，3位随机
    BinaryHeap<int> heap1,heap2;
    clock_t begin, end;
    switch (mode)
    { 
   
    case 1://正序
        begin = clock();
        for (int i = 1; i <= num; ++i)
        { 
   
            heap1.insert(i);
        }
        end = clock();
        cout << "一个一个正序插入所用时间：" << double(end - begin) / CLOCKS_PER_SEC * 1000 << "ms" << endl;
        break;
    case 2://倒序
        begin = clock();
        for (int i = num; i >= 1; --i)
        { 
   
            heap1.insert(i);
        }
        end = clock();
        cout << "一个一个倒序插入所用时间：" << double(end - begin) / CLOCKS_PER_SEC * 1000 << "ms" << endl;
        break;
    case 3://正倒序交叉模拟随机
        begin = clock();
        for (int i = 1; i<num/2; ++i)
        { 
   
            heap1.insert(i);
            heap1.insert(num - i);
        }
        end = clock();
        cout << "一个一个随机插入所用时间：" << double(end - begin) / CLOCKS_PER_SEC * 1000 << "ms" << endl;
        break;
    default:
        break;
    }
  
 
    return 0;
}

1.2 GetTickCount()函数 （Windows API）

GetTickCount返回（retrieve）从操作系统启动所经过（elapsed）的毫秒数，它的返回值是DWORD。

#include <stdio.h>
#include <windows.h>
#include<iostream>
#pragma comment(lib, "winmm.lib") //告诉编译器要导入winmm库，有时候可删

int main()
{ 
   
    DWORD t1, t2;
    t1 = GetTickCount();
    for(int i=1;i<=10000;++i)
    { 
   
        
    }//do something
    t2 = GetTickCount();
    //printf("Use Time:%f\n", (t2 - t1) * 1.0);
    cout<<"Use Time:"<<(double)(t2-t1)<<"ms"<<endl;
    return 0;
}

1.3 timeGetTime()函数（Windows API）

以毫秒计的系统时间，该时间为从系统开启算起所经过的时间。在使用timeGetTime之前应先包含头文件＃include <Mmsystem.h>或＃include <Windows.h>并在project->settings->link->Object/library modules中添加winmm.lib。也可以在文件头部添加 #pragma comment( lib,“winmm.lib” )。

备注：命令行：#pragma comment( lib,“xxx.lib” )时预编译处理指令，让vc将winmm.lib添加到工程中去进行编译。

//#include<stdio.h>
#include<windows.h>
#include<iostream>
#pragma comment( lib,"winmm.lib" )

int main()
{ 
   
    DWORD t1, t2;
    t1 = timeGetTime();
    foo();//do something
    t2 = timeGetTime();
    //printf("Use Time:%f\n", (t2 - t1)*1.0 / 1000);
    cout<<"Use Time:"<<(double)(t2-t1)<<"ms"<<endl;
    return 0;
}

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

void Delay(DWORD delayTime)
{ 
   
　　DWORD delayTimeBegin;
　　DWORD delayTimeEnd;
　　delayTimeBegin=timeGetTime();
　　do
　　{ 
   　　　　
　　	delayTimeEnd=timeGetTime();
　　}while((delayTimeEnd-delayTimeBegin)<delayTime)
}

1.4 timeval结构体（Linux）

timeval结构体

#include <sys/time.h> 
#include <iostream> 
#include <time.h> 
double get_wall_time() 
{ 
    
  struct timeval time ; 
  if (gettimeofday(&time,NULL)){ 
    
    return 0; 
  } 
  return (double)time.tv_sec + (double)time.tv_usec * .000001; 
} 
 
int main() 
{ 
    
  unsigned int t = 0; 
  double start_time = get_wall_time() 
  while(t++<10e+6); 
  double end_time = get_wall_time() 
  std::cout<<"循环耗时为:"<<end_time-start_time<<"ms"; 
  return 0; 
}

2.微秒级精度

QueryPerformanceCounter()函数和QueryPerformanceFrequency()函数（Windows API）

QueryPerformanceFrequency()函数返回高精确度性能计数器的值,它可以以微妙为单位计时，但是QueryPerformanceCounter()确切的精确计时的最小单位是与系统有关的,所以,必须要查询系统以得到QueryPerformanceCounter()返回的嘀哒声的频率。QueryPerformanceFrequency()提供了这个频率值,返回每秒嘀哒声的个数。

//#include<stdio.h>
#include<iostream>
#include<windows.h>
#pragma comment( lib,"winmm.lib" )

int main()
{ 
   
    LARGE_INTEGER t1, t2, tc;
    QueryPerformanceFrequency(&tc);
    QueryPerformanceCounter(&t1);
    foo();//do something
    QueryPerformanceCounter(&t2);
    //printf("Use Time:%f\n", (t2.QuadPart - t1.QuadPart)*1.0 / tc.QuadPart);
    cout << "Use Time:" << (double)((t2.QuadPart - t1.QuadPart) * 1000000.0 / tc.QuadPart) << "μs" << endl;
    return 0;
}

封装好的易于调用的代码：

//MyTimer.h// 
#ifndef __MyTimer_H__ 
#define __MyTimer_H__ 
#include <windows.h> 
 
class MyTimer 
{ 
    
private: 
  int _freq; 
  LARGE_INTEGER _begin; 
  LARGE_INTEGER _end; 
 
public: 
  long costTime;      // 花费的时间(精确到微秒) 
 
public: 
  MyTimer() 
  { 
    
    LARGE_INTEGER tmp; 
    QueryPerformanceFrequency(&tmp);//QueryPerformanceFrequency()作用：返回硬件支持的高精度计数器的频率。 
 
    _freq = tmp.QuadPart; 
    costTime = 0; 
  } 
 
  void Start()      // 开始计时 
  { 
    
    QueryPerformanceCounter(&_begin);//获得初始值 
  } 
 
  void End()        // 结束计时 
  { 
    
    QueryPerformanceCounter(&_end);//获得终止值 
    costTime = (long)((_end.QuadPart - _begin.QuadPart) * 1000000 / _freq); 
  } 
 
  void Reset()      // 计时清0 
  { 
    
    costTime = 0; 
  } 
}; 
#endif 
 
//main.cpp 
#include "MyTimer.h" 
#include <iostream> 
 
 
int main() 
{ 
    
  MyTimer timer; 
  unsigned int t = 0;  
  timer.Start(); 
  while (t++ < 10e+5); 
  timer.End();  
  std::cout << "耗时为：" << timer.costTime << "us"; 
  return 0 ; 
}

3.纳秒级精度

要先获取CPU频率。

在Intel Pentium以上级别的CPU中，有一个称为“时间戳（Time Stamp）”的部件，它以64位无符号整型数的格式，记录了自CPU上电以来所经过的时钟周期数。由于目前的CPU主频都非常高，因此这个部件可以达到纳秒级的计时精度。这个精确性是上述几种方法所无法比拟的.在Pentium以上的CPU中，提供了一条机器指令RDTSC（Read Time Stamp Counter）来读取这个时间戳的数字，并将其保存在EDX:EAX寄存器对中。由于EDX:EAX寄存器对恰好是Win32平台下C++语言保存函数返回值的寄存器，所以我们可以把这条指令看成是一个普通的函数调用，因为RDTSC不被C++的内嵌汇编器直接支持，所以我们要用_emit伪指令直接嵌入该指令的机器码形式0X0F、0X31。

inline unsigned __int64 GetCycleCount()
{ 
   
    __asm
    { 
   
        _emit 0x0F;
        _emit 0x31;
    }
}

void test()
{ 
   
    unsigned long t1,t2;
    t1 = (unsigned long)GetCycleCount();
    foo();//dosomething
    t2 = (unsigned long)GetCycleCount();
    printf("Use Time:%f\n",(t2 - t1)*1.0/FREQUENCY);   //FREQUENCY指CPU的频率
}

下面为获取CPU精度的代码

#include<Windows.h>
LONGLONG GetFrequency(DWORD sleepTime) //获取CPU主频

{ 
   

    DWORD low1 = 0, high1 = 0, low2 = 0, high2 = 0;

    LARGE_INTEGER fq, st, ed;

    /*在定时前应该先调用QueryPerformanceFrequency()函数获得机器内部计时器的时钟频率。接着在 需要严格计时的事件发生前和发生之后分别调用QueryPerformanceCounter()，利用两次获得的技术 之差和时钟的频率，就可以计算出时间经历的精确时间。*/

    ::QueryPerformanceFrequency(&fq); //精确计时（返回硬件支持的高精度计数器的频率）

    ::QueryPerformanceCounter(&st); //获得起始时间

    __asm { 
    //获得当前CPU的时间数

rdtsc

mov low1, eax

mov high1, edx

    }

    ::Sleep(sleepTime); //将线程挂起片刻

    ::QueryPerformanceCounter(&ed); //获得结束时间

    __asm { 
   
rdtsc //读取CPU的时间戳计数器

mov low2, eax

mov high2, edx

    }

    //将CPU得时间周期数转化成64位整数

    LONGLONG begin = (LONGLONG)high1 << 32 | low1;

    LONGLONG end = (LONGLONG)high2 << 32 | low2;

    //将两次获得的CPU时间周期数除以间隔时间，即得到CPU的频率

    //由于windows的Sleep函数有大约15毫秒的误差，故以windows的精确计时为准

    return (end - begin) * fq.QuadPart / (ed.QuadPart - st.QuadPart);
}

4.利用chrono的各精度集成版（本质微秒）

4.1 chrono库介绍

函数原型：

template <class Clock, class Duration = typename Clock::duration>
  class time_point;

std::chrono::time_point 表示一个具体时间

第一个模板参数Clock用来指定所要使用的时钟,在标准库中有三种时钟，分别为：

  • system_clock：当前系统范围(即对各进程都一致)的一个实时的日历时钟(wallclock)
  • steady_clock：当前系统实现的一个维定时钟，该时钟的每个时间嘀嗒单位是均匀的(即长度相等)。
  • high_resolution_clock：当前系统实现的一个高分辨率时钟。
    第二个模板函数参数用来表示时间的计量单位(特化的std::chrono::duration<> )

时间点都有一个时间戳，即时间原点。chrono库中采用的是Unix的时间戳1970年1月1日 00:00。所以time_point也就是距离时间戳(epoch)的时间长度（duration）。

4.2 代码示例

#include <iostream>
#include <chrono>
 
using namespace std;
using namespace std::chrono;
 
class TimerClock
{ 
   
public:
 TimerClock()
 { 
   
  update();
 }
 
 ~TimerClock()
 { 
   
 }
 
 void update()
 { 
   
  _start = high_resolution_clock::now();
 }
 //获取秒
 double getTimerSecond()
 { 
   
  return getTimerMicroSec() * 0.000001;
 }
 //获取毫秒
 double getTimerMilliSec()
 { 
   
  return getTimerMicroSec()*0.001;
 }
 //获取微妙
 long long getTimerMicroSec()
 { 
   
  //当前时钟减去开始时钟的count
  return duration_cast<microseconds>(high_resolution_clock::now() - _start).count();
 }
private:
 time_point<high_resolution_clock>_start;
};
 
//测试的主函数
int main()
{ 
   
 TimerClock TC;
 int sum = 0;
 TC.update();
 for (int i = 0; i > 100000; i++)
 { 
   
  sum++;
 }
 cout << "cost time:" << TC.getTimerMilliSec() <<"ms"<< endl;
 cout << "cost time:" << TC.getTimerMicroSec() << "us" << endl;
 
 return 0;
}

5.秒级精度

单纯以备不时之需，没人用吧。

time() 函数

在头文件time.h中，time()获取当前的系统时间，只能精确到秒，返回的结果是一个time_t类型，其使用方法如下：

#include <time.h> 
#include <stdio.h> 

int main()
 { 
     
     time_t first, second;  
     first=time(NULL);  
     delay(2000);  
     second=time(NULL);  
     printf("The difference is: %f seconds",difftime(second,first));  //调用difftime求出时间差
     return 0;   
}

今天的文章c++ 计时_c++计算程序运行时间[通俗易懂]分享到此就结束了，感谢您的阅读。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/64247.html

赞 (0)
编程小号编程小号
0

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用 * 标注