测试程序执行时间

　     本文介绍两种测试程序时间的方法，一种是通过间隔计数，另一种通过周期计数器。针对这两种方法，分别给出Windows和 UNIX 下的实现。

       首先介绍这两种方法的含义，摘自《深入理解计算机系统》。间隔计数：操作系统维护者每个进程使用的用户时间量和系统时间量的计数值，当计时器中断发生时，操作系统会确定哪个进程是活动的，并且对那个进程的一个计数值增加计时器间隔时间。如果系统是在内核模式中执行的，那么就增加系统时间，否则增加用户时间。这种方法一般使用clock函数实现；周期计数器：处理器内部包含一个运行在时钟周期级的计数器，每个时钟周期它都会家1。可以利用特殊的机器指令来读这个计数器的值。如果要测试一段代码的时间，只需在代码段前后分别获取计数器的值，然后将这两个计数器的值相减，除以处理器频率，就可以得到这段代码的运行时间。

       当然了，这里给出的方法适用于负载轻的系统，要在负载很重的系统获得准确的计时本身就特别困难。另外程序的运行时间受到上下文切换、高速缓存、分支预测等的影响，所以本文介绍的测试方法及实现仅仅是一种参考，尚需完善。

      下面给出Windows中的实现，一共有三个版本，都用C++实现并进行了封装。第一、二种都是属于周期计数器法，第三种是间隔计数法。三个版本的使用方式一样，除了版本二需要设置处理器频率。如下所示：

 Runtime rt;
 //rt.SetHZ(2327500000.0); //版本二需设置处理器频率,我电脑的CPU频率是2.33GHz
 rt.Begin();      //代码段执行前
 P();             //要测试的代码段
 rt.End();        //代码段执行后
 rt.GetRuntime(); //获得运行时间

     版本一，利用Windows提供的API函数实现。这种方法的精度非常高。属于周期计数器法。

 #include <windows.h>
 class Runtime
 {
 private:
     LARGE_INTEGER m_begin;
     LARGE_INTEGER m_end;
 public:
     inline void Begin() { QueryPerformanceCounter(&m_begin); }
     inline void End() { QueryPerformanceCounter(&m_end); }
     inline double GetRuntime()
     {
         LARGE_INTEGER frequency;
         QueryPerformanceFrequency(&frequency); //获得机器内部计时器的时钟频率
         return (double)(m_end.QuadPart - m_begin.QuadPart)/frequency.QuadPart;
     }
 };

     版本二，直接用汇编代码实现，利用的是IA32的周期计数器。因此局限于IA32架构。属于周期计数器法。

 #include <ctime>
 using namespace std;

 class Runtime
 {
 private:
     unsigned m_hi, m_lo;
     unsigned m_nhi, m_nlo;
     double m_hz;
 public:
     inline void SetHZ(double hz) { m_hz = hz; }
     inline void Begin()
     {
         unsigned hi, lo;
         __asm{
             rdtsc;
             mov hi,edx;
             mov lo,eax
         };
         m_hi = hi;
         m_lo = lo;
     }
     inline void End()
     {
         unsigned hi, lo;
         __asm{
             rdtsc;
             mov hi,edx;
             mov lo,eax
         };
         m_nhi = hi;
         m_nlo = lo;
     }
     inline double GetRuntime()
     {
         unsigned hi, lo, borrow;
         lo = m_nlo - m_lo;           //低位差
         borrow = lo > m_nlo;         //需向高位借位
         hi = m_nhi - m_hi - borrow;  //高位差
         return (hi * (1 << 30) * 4 + lo)/m_hz;
     }
 };

     版本三，利用ANSI C定义的clock函数实现，测量程序总的运行时间。注意一点clock函数返回的是时钟滴答，为了表示成秒数需除以CLOCK_PER_SEC。

 #include <ctime>
 using namespace std;

 class Runtime
 {
 private:
     clock_t m_begin;
     clock_t m_end;
 public:
     inline void Begin() { m_begin = clock(); }
     inline void End() { m_end = clock(); }
     inline double GetRuntime() { return (m_end - m_begin)/ (double)CLOCKS_PER_SEC; }
 };

      给完Windows的实现，接着来介绍UNIX下的实现。第一种为周期计数器法，第二种为间隔计数法，第三种利用gettimeofday函数实现。三个版本的使用方式一样，除了版本1需定义处理器频率。如下所示：

 begin_time();
 P();
 end_time();
 get_runtime();

     版本一，直接用汇编代码实现，利用的是IA32的周期计数器。因此局限于IA32架构。属于周期计数器法。

 #include <time.h>
 #include <unistd.h>

 #define CPUHZ 2327500000.0   //处理器频率
 unsigned cyc_hi = 0, cyc_lo = 0;
 unsigned ncyc_hi = 0, ncyc_lo = 0;

 void access_counter(unsigned *hi, unsigned *lo)
 {
     asm("rdtsc; movl %%edx,%0; movl %%eax,%1"
             : "=r" (*hi), "=r" (*lo)
             :
             : "%edx", "%eax");
 }
 void begin_time() { access_counter(&cyc_hi, &cyc_lo); }
 void end_time() { access_counter(&ncyc_hi, &ncyc_lo); }
 double get_runtime()
 {
     unsigned hi, lo, borrow;
     lo = ncyc_lo - cyc_lo;
     borrow = lo > ncyc_lo;
     hi = ncyc_hi - cyc_hi - borrow;
     return ((double)hi * (1 << 30) * 4 + lo)/ CPUHZ;
 }

     版本二，利用ANSI C定义的clock函数实现，测量程序总的运行时间。

 #include <time.h>
 clock_t begin, end;
 void begin_time() { begin = clock(); }
 void end_time() { end = clock(); }
 double get_runtime() { return (end - begin)/ (double)CLOCKS_PER_SEC; }

     版本三，利用gettimeofday函数实现，弥补了IA32周期计数器只能在IA32 系统上工作的缺陷。

 #include <sys/time.h>
 #include <unistd.h>
 struct timeval begin;
 struct timeval end;

 void begin_time() { gettimeofday(&begin, NULL); }
 void end_time() { gettimeofday(&end, NULL); }
 double get_runtime()
 {
     long sec, usec;
     sec = end.tv_sec - begin.tv_sec;
     usec = end.tv_usec - begin.tv_usec;
     return (double)sec + 1e-6 * usec;
 }