windows下實現微秒級的延時

1.微秒級的延時肯定不能基於訊息(SetTimer函數),因為一出現訊息堵塞等就會影響精
度,而且setTimer單位才是毫秒.實際回應時間可能要到55毫秒左右.

2.微秒級的延時也不能不能基於中斷,VxD最快的時鐘服務程式Set_Global_Time_Out函數
才能保證1毫秒的精度.其他掛接int 8H中斷處理函數等,只能保證55ms的精度.(有時還不
能)

3.因此可以想到彙編下的那種基於迴圈執行語句的那種延時.但彙編那種代碼不通用,跟
cpu的頻率有關.

所以可以用windows下的幾個函數來寫出通用代
碼.GetTickCout,timeGetTime,QueryPerformanceCounter.
1)GetTickCout響應只能保證55ms的精度
2)timeGetTime只能保證1ms的精度
3)而QueryPerformanceCounter函數不依賴計算中斷的次數,而是靠讀取別的硬體時鐘來
實現的,可以有0.8微秒的精度.這個系統不支援windows 95以下的系統,不過這些系統應
該沒人用了吧.呵呵.

下面是範例程式碼:
//LARGE_INTEGER類型類似一個64位的整型,是一個union,裡面是LongLong類型和兩個
long組成的結構體的union.
//QueryPerformanceFrequency函數得到你的電腦裡高精度計時器每秒計時多少次,
//參數LARGE_INTEGER,返回false表示你的當前電腦硬體不支援高精度計時器.
//QueryPerformanceCounter函數得到當前計時器記了多少次.類似與GetTickCout.
#include <windows.h>
#include <iostream>
using namespace std;

void main(){

int delayTime = 20; //微秒級的延時.

LARGE_INTEGER m_liPerfFreq={0};

    if (!QueryPerformanceFrequency(&m_liPerfFreq))
{
cout <<"你的當前電腦硬體不支援高精度計時器"<<endl;
return;
}
    
    LARGE_INTEGER m_liPerfStart={0};
    QueryPerformanceCounter(&m_liPerfStart);

LARGE_INTEGER liPerfNow={0};
for(;;)
{

QueryPerformanceCounter(&liPerfNow);
double time=( ((liPerfNow.QuadPart -
m_liPerfStart.QuadPart)*1000000)/(double)m_liPerfFreq.QuadPart);
if (time >= delayTime)
break;

}
cout.precision(40);
cout << "開始" <<(double)m_liPerfStart.QuadPart <<endl;
cout << "結束" <<(double)liPerfNow.QuadPart <<endl;
cout<<"時間精度"<<(1/(double)m_liPerfFreq.QuadPart)*1000000<<"微秒"<<endl;
cout << "延時" <<( ((liPerfNow.QuadPart - m_liPerfStart.QuadPart)
*1000000)/(double)m_liPerfFreq.QuadPart)<<"微秒"<<endl;

}

因為windows是多任務系統,只要保證windows執行這段代碼時不被其他進程打斷,就可以
保證延時微秒級成功.出現打斷的幾率很小.一般可以不考慮.如果代碼執行時間低於一
個時間片,那就100%不會被打斷了.

 

 

 

 

 在SDK中，可以用DWORD timeGetTime(VOID)函數擷取系統時間，其傳回值是毫秒單位的。可以用其實現延時功能的函數。
void Delay(DWORD delayTime)
{
    DWORD delayTimeBegin;
    DWORD delayTimeEnd;
    delayTimeBegin=timeGetTime();
    do
    {
        delayTimeEnd=timeGetTime();
    }while(delayTimeEnd-delayTimeBegin<delayTime)
}
註：在使用timeGetTime之前應先包含標頭檔＃i nclude <Mmsystem.h>或＃i nclude <Windows.h>並在project->settings->link->Object/library modules中添加winmm.lib
    也可以在檔案頭部添加 #pragma comment( lib,"winmm.lib" )
命令列：#pragma comment( lib,"xxx.lib" )時先行編譯處理指示，讓vc將winmm.lib添加到工程中去進行編譯。

 

 

 

 

 

在Windows平台下，常用的計時器有兩種，一種是timeGetTime多媒體計時器，它可以提供毫秒級的計時。但這個精度對很多應用場合而言還是太粗糙了。另一種是QueryPerformanceCount計數器，隨系統的不同可以提供微秒級的計數。對於即時圖形處理、多媒體資料流處理、或者即時系統構造的程式員，善用QueryPerformanceCount/QueryPerformanceFrequency是一項基本功。

　　本文要介紹的，是另一種直接利用Pentium CPU內部時間戳記進行計時的高精度計時手段。以下討論主要得益於《Windows圖形編程》一書，第15頁－17頁，有興趣的讀者可以直接參考該書。關於RDTSC指令的詳細討論，可以參考Intel產品手冊。本文僅僅作拋磚之用。
　　在Intel Pentium以上層級的CPU中，有一個稱為“時間戳記（Time Stamp）”的組件，它以64位無符號整型數的格式，記錄了自CPU上電以來所經過的刻度數。由於目前的CPU主頻都非常高，因此這個組件可以達到納秒級的計時精度。這個精確性是上述兩種方法所無法比擬的。

　　在Pentium以上的CPU中，提供了一條機器指令RDTSC（Read Time Stamp Counter）來讀取這個時間戳記的數字，並將其儲存在EDX:EAX寄存器對中。由於EDX:EAX寄存器對恰好是Win32平台下C++語言儲存函數傳回值的寄存器，所以我們可以把這條指令看成是一個普通的函數調用。像這樣：

inline unsigned __int64 GetCycleCount()
{
__asm RDTSC
}

但是不行，因為RDTSC不被C++的內嵌彙編器直接支援，所以我們要用_emit偽指令直接嵌入該指令的機器碼形式0X0F、0X31，如下：

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

以後在需要計數器的場合，可以像使用普通的Win32 API一樣，調用兩次GetCycleCount函數，比較兩個傳回值的差，像這樣：

unsigned long t;
t = (unsigned long)GetCycleCount();
//Do Something time-intensive ...
t -= (unsigned long)GetCycleCount();

　　《Windows圖形編程》第15頁編寫了一個類，把這個計數器封裝起來。有興趣的讀者可以去參考那個類的代碼。作者為了更精確的定時，做了一點小小的改進，把執行RDTSC指令的時間，通過連續兩次調用GetCycleCountFunction Compute出來並儲存了起來，以後每次計時結束後，都從實際得到的計數中減掉這一小段時間，以得到更準確的計時數字。但我個人覺得這一點點改進意義不大。在我的機器上實測，這條指令大概花掉了幾十到100多個周期，在Celeron 800MHz的機器上，這不過是十分之一微秒的時間。對大多數應用來說，這點時間完全可以忽略不計；而對那些確實要精確到納秒數量級的應用來說，這個補償也過於粗糙了。

這個方法的優點是：

1.高精度。可以直接達到納秒級的計時精度（在1GHz的CPU上每個刻度就是一納秒），這是其他計時方法所難以企及的。

2.成本低。timeGetTime 函數需要連結多媒體庫winmm.lib，QueryPerformance* 函數根據MSDN的說明，需要硬體的支援（雖然我還沒有見過不支援的機器）和KERNEL庫的支援，所以二者都只能在Windows平台下使用（關於DOS平台下的高精度計時問題，可以參考《圖形程式開發人員指南》，裡面有關於控制定時器8253的詳細說明）。但RDTSC指令是一條CPU指令，凡是i386平台下Pentium以上的機器均支援，甚至沒有平台的限制（我相信i386版本UNIX和Linux下這個方法同樣適用，但沒有條件實驗），而且函數調用的開銷是最小的。

3.具有和CPU主頻直接對應的速率關係。一個計數相當於1/(CPU主頻Hz數)秒，這樣只要知道了CPU的主頻，可以直接計算出時間。這和QueryPerformanceCount不同，後者需要通過QueryPerformanceFrequency擷取當前計數器每秒的計數次數才能換算成時間。

這個方法的缺點是：

1.現有的C/C++編譯器多數不直接支援使用RDTSC指令，需要用直接嵌入機器碼的方式編程，比較麻煩。

2.資料抖動比較厲害。其實對任何計量手段而言，精度和穩定性永遠是一對矛盾。如果用低精度的timeGetTime來計時，基本上每次計時的結果都是相同的；而RDTSC指令每次結果都不一樣，經常有幾百甚至上千的差距。這是這種方法高精度本身固有的矛盾。

關於這個方法計時的最大長度，我們可以簡單的用下列公式計算：

自CPU上電以來的秒數 = RDTSC讀出的周期數 / CPU主頻速率（Hz）

64位不帶正負號的整數所能表達的最大數字是1.8×10^19，在我的Celeron 800上可以計時大約700年（書中說可以在200MHz的Pentium上計時117年，這個數字不知道是怎麼得出來的，與我的計算有出入）。無論如何，我們大可不必關心溢出的問題。

下面是幾個小例子，簡要比較了三種計時方法的用法與精度

//Timer1.cpp 使用了RDTSC指令的Timer類//KTimer類的定義可以參見《Windows圖形編程》P15
//編譯行：CL Timer1.cpp /link USER32.lib
#include <stdio.h>
#include "KTimer.h"
main()
{
unsigned t;
KTimer timer;
timer.Start();
Sleep(1000);
t = timer.Stop();
printf("Lasting Time: %d/n",t);
}

//Timer2.cpp 使用了timeGetTime函數
//需包含<mmsys.h>，但由於Windows標頭檔錯綜複雜的關係
//簡單包含<windows.h>比較偷懶：）
//編譯行：CL timer2.cpp /link winmm.lib
#include <windows.h>
#include <stdio.h>

main()
{
DWORD t1, t2;
t1 = timeGetTime();
Sleep(1000);
t2 = timeGetTime();
printf("Begin Time: %u/n", t1);
printf("End Time: %u/n", t2);
printf("Lasting Time: %u/n",(t2-t1));
}

//Timer3.cpp 使用了QueryPerformanceCounter函數
//編譯行：CL timer3.cpp /link KERNEl32.lib
#include <windows.h>
#include <stdio.h>

main()
{
LARGE_INTEGER t1, t2, tc;
QueryPerformanceFrequency(&tc);
printf("Frequency: %u/n", tc.QuadPart);
QueryPerformanceCounter(&t1);
Sleep(1000);
QueryPerformanceCounter(&t2);
printf("Begin Time: %u/n", t1.QuadPart);
printf("End Time: %u/n", t2.QuadPart);
printf("Lasting Time: %u/n",( t2.QuadPart- t1.QuadPart));
}

////////////////////////////////////////////////
//以上三個樣本程式都是測試1秒鐘休眠所耗費的時間
file://測/試環境：Celeron 800MHz / 256M SDRAM
// Windows 2000 Professional SP2
// Microsoft Visual C++ 6.0 SP5
////////////////////////////////////////////////

以下是Timer1的運行結果，使用的是高精度的RDTSC指令
Lasting Time: 804586872

以下是Timer2的運行結果，使用的是最粗糙的timeGetTime API
Begin Time: 20254254
End Time: 20255255
Lasting Time: 1001

以下是Timer3的運行結果，使用的是QueryPerformanceCount API
Frequency: 3579545
Begin Time: 3804729124
End Time: 3808298836
Lasting Time: 3569712