程序运行时间的测量

最新推荐文章于 2023-01-14 11:22:16 发布
最新推荐文章于 2023-01-14 11:22:16 发布
阅读量834 收藏
点赞数
分类专栏： c++ 文章标签： c++

转自：http://blog.csdn.net/wzdworld001/article/details/1644111

程序运行时间的测量

 
摘要：本文详细的讨论了在windows平台中，测量程序运行时间的几个函数，GetTickCount, QueryPerformanceCounter和RDTSC，并给出示例代码。
　　算法的好坏有好多评价指标，其中一个重要的指标是时间复杂度。如果两个程序完成一个同样的任务，即功能相同，处理的数据相同，那么运行时间较短者为优。操作系统和库函数一般都提供了对时间测量的函数，这么函数一般都会返回一个代表当前时间的数值，通过在运行某个程序或某段代码之前调用一次时间函数来得到一个数值，在程序或者代码段运行之后再调用一次时间函数来得到另一个数值，将后者减去前者即为程序的运行时间。
　在windwos平台(指windwow95及以后的版本，下同),常用的用于测量时间的函数或方法有三种：1.API函数GetTickCount或C函数clock,　2.API函数QueryPerformanceCounter，　3:汇编指令RDSTC
1．API函数GetTickCount：
函数原形：DWORD GetTickCount(VOID)；
该函数取回从电脑开机至现在的毫秒数，即每个时间单位为1毫秒。他的分辨率比较低，常用在测量用时较长程序，如果你的程序用时为100毫秒以上，可以使用这个函数.另一个和GetTickCount类似的函数是clock，该函数的回的时间的单位的是CLOCKS_PER_SEC，在windows95/2000操作系统，该值是1000,也就是说，在windows平台，这两个函数的功能几乎完全相同。
2.API函数QueryPerformanceCounter：
函数原形：BOOL QueryPerformanceCounter( LARGE_INTEGER *lpPerformanceCount);该函数取回当前的高分辨值performance计数器，用一个64bit数来表示。如果你的硬件不支持高分辨performance计数器，系统可能返加零。不像GetTickCount，每个计数器单位表示一个固定的时间1毫秒，为了知道程序确切的执行时间，你需要调用函数QueryPerformanceFrequency来得到每秒performance计数器的次数，即频率。
3.汇编指令RDTSC:
RDTSC 指令读取CPU内部的“时间戳(TimeStamp)"，它是一个64位无符号数计数器，这条指令执行完毕后，存储在EDX:EAX寄存中。该指令从intel奔腾CPU开始引入，一些老式的CPU不支持该指令，奔腾后期的CPU包括AMD的CPU均支持这条指令。和QueryPerformanceCounter类似，要想知道程序的确实的执行时间，必须知道CPU的频率，即平常所说的CPU的主频。不幸的是没有现成的函数可以得到CPU的频率。一种办法可行的办法延时一段指定时间，时间的测量可以用QueryPerformanceCounter来做，在这段时间的开始和结束调用RDTSC,得到其时钟数的差值，然后除以这段时间的的秒数就可以了。
 
下面的代码给出使用3个函数封装和测试代码，用RDTSC指令来计时的代码参考了一个Ticktest的源代码，作者不详。
getTime1，使用GetTickCount返回一个表示当前时间的值，单位秒。
getTime2，和getTime1类似，精度更高。
getTime3，返回一个64bit的一个计数器，欲转换为秒，需除以CPU频率。示例代码见函数test3.
#include "stdafx.h"
#include "windows.h"
#include "tchar.h"
double getTime1()
{
       DWORD t=GetTickCount();
       return (double)t/1000.00;
}
double getTime2() //使用高精度计时器
{     
       static LARGE_INTEGER s_freq;
       LARGE_INTEGER performanceCount;
       double t;
       if (s_freq.QuadPart==0)
       {
              if ( !QueryPerformanceFrequency( &s_freq))
                     return 0;
       }
      
       QueryPerformanceCounter( &performanceCount );
       t=(double)performanceCount.QuadPart / (double)s_freq.QuadPart;
       return t;
}
void test1()
{
       double t1,t2;
       t1=getTime1();
       Sleep(1000);
       t2=getTime1()-t1;
       printf("It take %.8f second/n",t2);
}
void test2()
{
       double t1,t2;
       t1=getTime2();
       Sleep(1000);
       t2=getTime2()-t1;
       printf("It take %.8f second/n",t2);
}
inline BOOL isNTOS() //检测是否运行在NT操作系统
{
       typedef BOOL (WINAPI *lpfnGetVersionEx) (LPOSVERSIONINFO);
       static int bIsNT=-1;
       if (bIsNT!=1)
              return (BOOL)bIsNT;
       // Get Kernel handle
       HMODULE hKernel32 = GetModuleHandle(_T("KERNEL32.DLL"));
       if (hKernel32 == NULL)
              return FALSE;
 #ifdef _UNICODE
    lpfnGetVersionEx lpGetVersionEx = (lpfnGetVersionEx) GetProcAddress(hKernel32, _T("GetVersionExW"));
 #else
    lpfnGetVersionEx lpGetVersionEx = (lpfnGetVersionEx) GetProcAddress(hKernel32, _T("GetVersionExA"));
 #endif
 
       if (lpGetVersionEx)
       {
              OSVERSIONINFO osvi;
              memset(&osvi, 0, sizeof(OSVERSIONINFO));
              osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
              if (!lpGetVersionEx(&osvi))
                     bIsNT=FALSE;
              else
                     bIsNT=(osvi.dwPlatformId == VER_PLATFORM_WIN32_NT);
       }
       else
       {
              //Since GetVersionEx is not available we known that
              //we are running on NT 3.1 as all modern versions of NT and
              //any version of Windows 95/98 support GetVersionEx
              bIsNT=TRUE;
       }
       return bIsNT;
}
inline static BOOL checkRDSTC() //检测CPU是否支持RDSTC指令
{
       static int bHasRDSTC= -1;
       SYSTEM_INFO sys_info;
      
       if ( bHasRDSTC !=-1 )
              return (BOOL)bHasRDSTC;
       GetSystemInfo(&sys_info);
       if (sys_info.dwProcessorType==PROCESSOR_INTEL_PENTIUM)
       {
              try
              {
                     _asm
                     {
                     _emit 0x0f                           ; rdtsc    
                     _emit 0x31
                     }
              }
              catch (...)       // Check to see if the opcode is defined.
              {
                     bHasRDSTC=FALSE; return FALSE;
              }
              // Check to see if the instruction ticks accesses something that changes.
              volatile ULARGE_INTEGER ts1,ts2;
              _asm
              {
                     xor eax,eax
                     _emit 0x0f                                  ; cpuid
                     _emit 0xa2
                     _emit 0x0f                                  ; rdtsc
                     _emit 0x31
                     mov ts1.HighPart,edx
                     mov ts1.LowPart,eax
                     xor eax,eax
                     _emit 0x0f                                  ; cpuid
                     _emit 0xa2
                     _emit 0x0f                                  ; rdtsc
                     _emit 0x31
                     mov ts2.HighPart,edx
                     mov ts2.LowPart,eax
              }
              // If we return true then there's a very good chance it's a real RDTSC instruction!
              if (ts2.HighPart>ts1.HighPart)
                  bHasRDSTC=TRUE;
              else if (ts2.HighPart==ts1.HighPart && ts2.LowPart>ts1.LowPart)
                     bHasRDSTC=TRUE;
              else
              {
                     printf("RDTSC instruction NOT present./n");
                     bHasRDSTC=FALSE;
              }
       }
       else
              bHasRDSTC=FALSE;
       return bHasRDSTC;
}
//***********************************************
void getTime3( LARGE_INTEGER *pTime) //返加当前CPU的内部计数器
{
       if (checkRDSTC())
       {
              volatile ULARGE_INTEGER ts;
       //on NT don't bother disabling interrupts as doing
       //so will generate a priviledge instruction exception
              if (!isNTOS())
                     _asm cli
           //----------------     
        _asm
              {
                     xor eax,eax
            //-------------save rigister
                     push ebx
                     push ecx
                    
                     _emit 0x0f                                  ; cpuid - serialise the processor
                     _emit 0xa2
                    
                     //------------
                     _emit 0x0f                                  ; rdtsc
                     _emit 0x31
                    
                     mov ts.HighPart,edx
                     mov ts.LowPart,eax
                    
                     pop ecx
                     pop ebx
              }
        //-----------------
              if (!isNTOS())
                     _asm      sti
              //---------       
        pTime->QuadPart=ts.QuadPart;
       }
       else
           pTime->QuadPart=0;
}
// maxDetermainTime:最大测定时间,单位毫秒，在首次调用该函数时，
// 将花费maxDetermineTime的时间来测定CPU频率，以后的调用将直接返加静态变量的值
double GetCPUFrequency(DWORD maxDetermineTime )
{
       static double CPU_freq;
       LARGE_INTEGER period,t1,t2;
       register LARGE_INTEGER goal,current;
      
       if (CPU_freq>1000)      //this value have been initilization
              return CPU_freq;
       if (!QueryPerformanceFrequency(&period) || !checkRDSTC())
       {
              CPU_freq=-1.00;
              return CPU_freq;
       }
       QueryPerformanceCounter(&goal);
       goal.QuadPart += period.QuadPart * maxDetermineTime/1000;
       getTime3( &t1);  //开始计时
       do    //延时maxDetermineTime毫秒
       {
              QueryPerformanceCounter(&current);
       } while(current.QuadPart<goal.QuadPart);
       getTime3(&t2);      //结束计时
      
       CPU_freq=double((t2.QuadPart-t1.QuadPart)*1000/maxDetermineTime);
      
       char buff[100];
       sprintf(buff,"Estimated the processor clock frequency =%gHz/n",CPU_freq);
    ::MessageBox(NULL,buff,"",MB_OK);
       return CPU_freq;
}
void test3()
{
       LARGE_INTEGER t,t1,t2;
       double f1,f2;
      
       GetCPUFrequency(100); //花费0.1秒时间计算CPU频率
       f1=getTime2();
       getTime3(&t1);
       Sleep(1000);
       getTime3(&t2);
       f2=getTime2();
       t.QuadPart=t2.QuadPart-t1.QuadPart;
       printf("It take %.8f second by getTime3/n",(double)t.QuadPart/GetCPUFrequency(100));
       printf("It take %.8f second by getTime2/n",f2-f1);
}
int main(int argc, char* argv[])
{
       test1();
       test2();
       test3();
       return 0;
}

pamxy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何在C/C++中测量一个函数或者功能的运行时间（串行和并行，以及三种方法的实际情况对比）
ZhongUncle的博客
11-27 3099
本文算是一个比较完整的关于在 C/C++ 中测量一个函数或者功能的总结，最后会演示三种方法的对比。最常用的clock() 最常用的测量方法是使用clock()来记录两个 CPU 时间点clock_t，然后做差。这个方法的好处在于非常简单易写，timespec。clock_gettime()的参数CLOCK_REALTIME表示系统层面的实时时间；这个地方还可以用CLOCK_MONOTONIC，这个值是从系统启动开始一直运行的，一直连续的不跳跃的（除非手动改了），这个要比CLOCK_REA：
阶乘之计算从入门到精通－程序运行时间的测量
liangbch的专栏
04-13 3942
本文详细的讨论了在windows平台中，测量程序运行时间的几个函数，GetTickCount, QueryPerformanceCounter和RDTSC，并给出示例代码。
【C++】C++中几种测试程序运行时间的方法
ArchyLi
02-17 2万+
关于C++中计算时间的一些总结 一、使用GetTickCount()函数 GetTickCount()是一个函数，可以把它理解为打点计时器。GetTickCount()是通过计算从函数开始运行计时，直到函数运行结束所求出函数的运行时间。它返回从操作系统启动所经过的毫秒数， 返回值：DWORD 头文件：winbase.h 函数原型：DWORD GetTickCount(void)
c语言测试程序执行时间
qiuchenl的专栏
12-10 2万+
http://blog.csdn.net/asaasa66/article/details/6543929 测试程序运行时间-time.h 1．计时 C/C++中的计时函数是clock()，而与其相关的数据类型是clock_t。在MSDN中，查得对clock函数定义如下： clock_t clock( void ); 这个函数返回从“开启这个程序进程”
数据结构复习题——填空题与程序填空题
weixin_46448596的博客
01-14 3618
本题要求给出希尔排序对给定初始序列{9, 8, 7, 6, 5, 4, 3, 2, 1}利用增量序列{1, 3, 7}进行排序的分步结果。本题目要求Init_SeQueue()函数初始化循环队列，返回指向队列的指针，Empty_SeQueue(c_SeQueue *q)函数判空队列，空队列返回1。本题目要求Out_SeQueue (c_SeQueue *q , datatype *x)函数将 出循环队列的值送给变量x。/*队中元素的个数*/下列代码的功能是返回带头结点的单链表L的逆转链表。
keil 仿真测量程序运行时间
01-06
有些时候我们对程序的性能需要调优，优化代码以提高起运行效率，那就需要精确的测量某一段代码的运行时间。非常高兴的是在keil里面提供了一个仿真调试手段，用来完成这个任务，好用！ 首先做好相关的设置，如下： 第...
C#测量程序运行时间及cpu使用时间实例方法
12-31
这里要指出的是， 运行一段程序，使用的cpu时间，跟实际运行的时间是不一样的。附例如下： 代码如下:private void ShowRunTime() { TimeSpan ts1 = Process.GetCurrentProcess().TotalProcessorTime; Stopwatch ...
dsp运行时间测量方法及操作说明
12-07
5种测量DSP程序运行时间的方法的详细说明及例程。文档详细介绍。5种测量DSP程序运行时间的方法的详细说明及例程。
c/c++ 实现程序运行时间精确测量
05-19
c/c++ 实现程序运行时间精确测量，本程序测得时间十分准确，精度为ms
PTA Basic level 1026 程序运行时间 (15分)
qazwsxxxxxasd的博客
05-26 829
1026 程序运行时间 (15分) 要获得一个 C 语言程序的运行时间，常用的方法是调用头文件 time.h，其中提供了 clock() 函数，可以捕捉从程序开始运行到 clock() 被调用时所耗费的时间。这个时间单位是 clock tick，即“时钟打点”。同时还有一个常数 CLK_TCK，给出了机器时钟每秒所走的时钟打点数。于是为了获得一个函数 f 的运行时间，我们只要在调用 f 之前先调用 clock()，获得一个时钟打点数 C1；在 f 执行完成后再调用 clock()，获得另一个时钟打点数 C2
5种测量DSP程序运行时间的方法的详细说明及例程
04-27
在DSP的开发中，我们往往需要知道各个代码段所需的运行时间，本文档给出了CCS3.3环境用profile测试代码运行时间的步骤，这个方法虽然简便，但是精确率低。除此之外统计时间还有3种办法，(1)根据C6000编译手册上所说，使用clock()函数。(2)DSP/BIOS下的时间分析器。(3)使用DSP片上自带的时钟，这种是最为精确的。(4)利用TSCL和TSCH测量。本文档给出了各种方法的详细说明以及例程代码。
C语言测试程序运行时间各种函数总结
07-13
C语言测试程序运行时间各种函数总结，可以便于调试程序，提高程序算法，考虑函数代码功能的方方面面，让自己对代码了解的更多
算法与数据结构 判断选择程序填空 绪论
weixin_47073308的博客
10-28 3377
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
测试程序运行时间
zhiqingxue的博客
09-12 745
在初步学习算法的时候，都喜欢一个词叫优化算法，经常做的事情就是比较两个实现同种功能的程序的运行时间。测试运行时间的函数，这就来安利一波。 1.时间函数头文件 #include<time.h> 2.设置初始时间和结束时间的变量。 int begin,end; double begin,end; （名字不限，表达出相关意思即可） （类型不限，根据你最终需要运行时间的类型设定即可） 3.输出测试时间 end-begin. #include<iostream> #include<t
C语言 计算程序运行时间（精确到毫秒/微秒）
热门推荐
Bamboo_shui的博客
12-09 7万+
C语言要计算程序的运行时间，这里总结两种方法，一种是精确到毫秒时间，一种是精确到微秒时间 方法一：精确到微秒时间 #include #include int main() { int a[10002]; int i = 0; double run_time; _LARGE_INTEGER time_start; //开始时间 _LARGE_INTEGER time_over
C语言time.h中clock()函数测程序运行时间
mengxiangjia_linxi的博客
09-30 4098
C语言中求程序执行的时间可以使用clock()函数_CRTIMP clock_t __cdecl __MINGW_NOTHROW clock (void);（可以把它直接视为clock_t clock(void);） 这个函数返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数，其中clock_t是用来保存时间的数据类型，在time.h文件
C语言如何测试算法运行时间
啦啦啦
04-16 8967
暂时没有找到原作. C/C++中的计时函数是clock()，而与其相关的数据类型是clock_t. 在MSDN中, 查得对clock函数定义如下: clock_t clock( void ); 这个函数返回从 “开启这个程序进程” 到 “程序中调用clock()函数” 时之间的CPU时钟计时单元 (clock tick) 数，在MSDN中称之为挂钟时间(wal-clock). 其中clock...
C/C++运行时间测试函数
qq_40853024的博客
11-27 391
C/C++中有很多记时函数，一般的处理都是先调用函数记录下当前的时间start，然后 处理一段时间，再调用函数记录下结束的时间end，两者之间的差值就是程序所运行的时间，由于不同函数取值的精度不一样，适用的范围也不一样。 void Test() { int i=1000000000; while (i--); } 方法一：利用time（）获取系统的时间，单位为秒 void Tim...
测量函数的运行时间
qwezhaohaihong
01-28 607
对于函数的实现效率的更精确的测量，我今天学到了clock测量时间函数 #include #include #include #include #define MAXK 1e7 using namespace std; clock_t start,stop;/* clock_t是clock()函数返回的变量类型*/ double duration;/* 记录被测函数运行时间，以秒为单
dsp测量程序运行时间
最新发布
01-05
DSP（数字信号处理）测量程序的运行时间可以通过在程序的起始和终止位置分别记录时间戳，然后计算两个时间戳之间的时间差来实现。 首先，在程序开始时记录起始时间戳，可以使用DSP芯片的定时器或者系统时钟来获取当前时间。然后在程序执行完成时记录终止时间戳。再通过对终止时间戳减去起始时间戳，即可得到程序的运行时间。 为了准确测量程序的运行时间，可以多次运行程序，并计算平均值，以减少测量误差。还可以通过在程序中加入特定的标记点，并记录这些标记点的时间戳，以便更具体地了解程序的执行时间。 除了手动记录时间戳外，还可以利用DSP芯片自带的性能计数器来实现对程序运行时间的测量。性能计数器可以精确地记录程序在不同阶段的执行时间，并且可以避免人为差错。通过将性能计数器的数值转换成实际时间，就可以得到程序的准确运行时间。 综上所述，通过记录起始时间戳和终止时间戳，或者利用DSP芯片自带的性能计数器，可以准确测量程序的运行时间，从而对程序的性能进行评估和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值