论时间片与定时器

元始天尊

    此贴解决了心里一大疑团，也说明了很多问题，比如高精度定时是否一定起作用了，如果异议，请给出充分理由
    众所周知，我们编写的应用程序，或者游戏，作为进程形式运行在系统中，而现代系统为了充分发挥cpu的作用，采用了时间片造成程序并行运行的假象。当然如果有多核的话，也能实现一部分并行计算，不过主要还是靠分时间片运行程序。这就带来了一个问题：如何让程序在指定时间做某件事。这不是一个容易回答的问题，因为该程序在正常情况下通常需要先获得cpu时间片，才可以做一会自己的工作，时间片用完后该进程返回就绪队列等待cpu下次调度。那么这就会有一个问题，在应用层程序设计中，如果指定时间到了，而时间片恰好没有轮到该进程，会怎样呢，程序是否能真正实现准确定时？笔者认为答案是否定的，下面这些采用已知定时器函数足以说明问题：

1. 
   
2. #include <windows.h>
   
3. #include <stdio.h>
   
4. 
   
5. HINSTANCE hinst;
   
6. int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int);
   
7. BOOL InitApplication(HINSTANCE);
   
8. BOOL InitInstance(HINSTANCE, int);
   
9. LRESULT CALLBACK MainWndProc(HWND, UINT, WPARAM, LPARAM);
   
10. 
    
11. #define IDT_TIMER1 10
    
12. #define IDT_TIMER2 20
    
13. #define IDT_TIMER3 30
    
14. 
    
15. static int count1=1;
    
16. static int count2=1;
    
17. static HWND mainwnd;
    
18. 
    
19. int WINAPI WinMain(HINSTANCE hinstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
    
20. {
    
21.         MSG msg;
    
22.         if (!InitApplication(hinstance))
    
23.                 return FALSE;
    
24.         if (!InitInstance(hinstance, nCmdShow))
    
25.                 return FALSE;
    
26.         BOOL fGotMessage;
    
27. 
    
28.         SetTimer(mainwnd,IDT_TIMER1,14,NULL);
    
29.         SetTimer(mainwnd,IDT_TIMER2,15,NULL);
    
30.         SetTimer(mainwnd,IDT_TIMER3,100,NULL);
    
31. 
    
32.         while (GetMessage(&msg, (HWND) NULL, 0, 0))
    
33.         {
    
34.                 TranslateMessage(&msg);
    
35.                 DispatchMessage(&msg);
    
36.         }
    
37.         return msg.wParam;
    
38.         UNREFERENCED_PARAMETER(lpCmdLine);
    
39. }
    
40. 
    
41. BOOL InitApplication(HINSTANCE hinstance)
    
42. {
    
43.         WNDCLASSEX wcx;
    
44.         ZeroMemory(&wcx,sizeof(wcx));
    
45.         wcx.cbSize = sizeof(wcx);
    
46.         wcx.style = CS_HREDRAW | CS_VREDRAW;
    
47.         wcx.lpfnWndProc = MainWndProc;
    
48.         wcx.hInstance = hinstance;
    
49.         wcx.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    
50.         wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
    
51.         wcx.hbrBackground = (HBRUSH)GetStockObject( WHITE_BRUSH);
    
52.         wcx.lpszMenuName =  "MainMenu";
    
53.         wcx.lpszClassName = "MainWClass";
    
54.         wcx.hIconSm = (HICON)LoadImage(hinstance,MAKEINTRESOURCE(5),IMAGE_ICON, GetSystemMetrics(SM_CXSMICON),
    
55.                 GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR);
    
56.         return RegisterClassEx(&wcx);
    
57. }
    
58. 
    
59. BOOL InitInstance(HINSTANCE hinstance, int nCmdShow)
    
60. {
    
61.         HWND hwnd;
    
62.         hinst = hinstance;
    
63.         hwnd = CreateWindow( "MainWClass","Sample",WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,
    
64.                 CW_USEDEFAULT,(HWND) NULL,(HMENU) NULL,hinstance,(LPVOID) NULL);
    
65.         if (!hwnd)
    
66.                 return FALSE;
    
67.         mainwnd=hwnd;
    
68.         ShowWindow(hwnd, nCmdShow);
    
69.         UpdateWindow(hwnd);
    
70.         return TRUE;
    
71. }
    
72. 
    
73. LRESULT CALLBACK MainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    
74. {
    
75.         if(uMsg == WM_TIMER)
    
76.         {
    
77.                 if(wParam == IDT_TIMER1)
    
78.                 {
    
79.                         count1++;
    
80.                         return 0;
    
81.                 }
    
82.                 else if(wParam == IDT_TIMER2)
    
83.                 {
    
84.                         count2++;
    
85.                         return 0;
    
86.                 }
    
87.                 else if(wParam == IDT_TIMER3)
    
88.                 {
    
89.                         char str[20];
    
90.                         sprintf_s(str,"%d-%d\n",count1,count2);
    
91.                         SetWindowText(hWnd,str);
    
92.                         return 0;
    
93.                 }
    
94.         }
    
95.         return DefWindowProc(hWnd,uMsg,wParam,lParam);
    
96. }
    

复制代码

    以上程序在我机子上测试，发现时间间隔调整为14 15时才有变化。这个是利用WM_TIMER消息进行定时，因此有消息传播时延，不过还是可以在一定程序上得出结论，SetTimer一定有个最小间隔，其内核函数对应NtUserSetTimer，如果传入时间<15ms，那么间隔就设为15ms（具体请参阅ReactOS源码）。这个最小间隔一定是基于时间片长度的考量，而windows时间片据说是10-20ms之间的。

其它函数的测试，为了减少冗余指令和时间片和其他因素的影响，我采取了一种特殊方式并提供了模板如下（以SleepEx为例）：

1. 
   
2. #include <windows.h>
   
3. #include <stdio.h>
   
4. static int i=0;
   
5. static int j=0;
   
6. 
   
7. DWORD WINAPI mythread1(LPVOID)
   
8. {
   
9.         while(true)
   
10.         {
    
11.                 SleepEx(1,FALSE);
    
12.                 i++;
    
13.                 printf("i=%d\n",i);
    
14.         }
    
15. }
    
16. 
    
17. DWORD WINAPI mythread2(LPVOID)
    
18. {
    
19.         while(true)
    
20.         {
    
21.                 SleepEx(10,FALSE);
    
22.                 j++;
    
23.                 printf("j=%d\n",j);
    
24.         }
    
25. }
    
26. 
    
27. int main()
    
28. {
    
29.         HANDLE hthread[2];
    
30.         hthread[0]=CreateThread(NULL,0,mythread1,NULL,0,NULL);
    
31.         hthread[1]=CreateThread(NULL,0,mythread2,NULL,0,NULL);
    
32.         WaitForMultipleObjects(2,hthread,TRUE,INFINITE);
    
33.         CloseHandle(hthread[0]);
    
34.         CloseHandle(hthread[1]);
    
35. }
    

复制代码

i=23973
j=13963
i=23974
i=23975
j=13964
i=23976
i=23977
j=13965
i=23978
i=23979
j=13966
i=23980
i=23981
j=13967
i=23982
i=23983
j=13968
i=23984
j=13969
i=23985
j=13970
i=23986
i=23987
    1GHZ的cpu，一般1s可以执行上亿条指令，而已知win的时间片为10ms-20ms，因此需要谨慎选择对比的时间间隔，使要考察的执行时间远大于无关冗余代码执行时间，而又能分辨出时间片，我选择的间隔为5ms和10ms，结果如上。可见随着递增，i和j的倍数关系甚至小于2，而本来这个倍数应该接近10的。足以说明时间片是有影响的，而使定时不够精确。其他代码我都有测试，结果相同：GetTickCount,timeGetTime

1. 
   
2. #include <windows.h>
   
3. #include <stdio.h>
   
4. static int i=0;
   
5. static int j=0;
   
6. 
   
7. DWORD WINAPI mythread1(LPVOID)
   
8. {
   
9.         while(true)
   
10.         {
    
11.                 DWORD dwStart=GetTickCount();
    
12.                 DWORD dwEnd=dwStart;
    
13.                 do
    
14.                 {
    
15.                         dwEnd=GetTickCount()-dwStart;
    
16.                 }
    
17.                 while(dwEnd<5);
    
18. 
    
19.                 i++;
    
20.                 printf("i=%d\n",i);
    
21.         }
    
22. }
    
23. 
    
24. DWORD WINAPI mythread2(LPVOID)
    
25. {
    
26.         while(true)
    
27.         {
    
28.                 DWORD dwStart=GetTickCount();
    
29.                 DWORD dwEnd=dwStart;
    
30.                 do
    
31.                 {
    
32.                         dwEnd=GetTickCount()-dwStart;
    
33.                 }
    
34.                 while(dwEnd<10);
    
35. 
    
36.                 j++;
    
37.                 printf("j=%d\n",j);
    
38.         }
    
39. }
    
40. 
    
41. int main()
    
42. {
    
43.         HANDLE hthread[2];
    
44.         hthread[0]=CreateThread(NULL,0,mythread1,NULL,0,NULL);
    
45.         hthread[1]=CreateThread(NULL,0,mythread2,NULL,0,NULL);
    
46.         WaitForMultipleObjects(2,hthread,TRUE,INFINITE);
    
47.         CloseHandle(hthread[0]);
    
48.         CloseHandle(hthread[1]);
    
49. 
    
50. }
    
51. 
    
52. 
    
53. #include <windows.h>
    
54. #include <stdio.h>
    
55. #pragma comment(lib,"winmm.lib")
    
56. static int i=0;
    
57. static int j=0;
    
58. 
    
59. DWORD WINAPI mythread1(LPVOID)
    
60. {
    
61.         while(true)
    
62.         {
    
63.                 DWORD dwStart=timeGetTime();
    
64.                 DWORD dwEnd=dwStart;
    
65.                 do
    
66.                 {
    
67.                         dwEnd=timeGetTime()-dwStart;
    
68.                 }
    
69.                 while(dwEnd<10);
    
70. 
    
71.                 i++;
    
72.                 printf("i=%d\n",i);
    
73.         }
    
74. }
    
75. 
    
76. DWORD WINAPI mythread2(LPVOID)
    
77. {
    
78.         while(true)
    
79.         {
    
80.                 DWORD dwStart=timeGetTime();
    
81.                 DWORD dwEnd=dwStart;
    
82.                 do
    
83.                 {
    
84.                         dwEnd=timeGetTime()-dwStart;
    
85.                 }
    
86.                 while(dwEnd<20);
    
87. 
    
88.                 j++;
    
89.                 printf("j=%d\n",j);
    
90.         }
    
91. }
    
92. 
    
93. int main()
    
94. {
    
95.         HANDLE hthread[2];
    
96.         hthread[0]=CreateThread(NULL,0,mythread1,NULL,0,NULL);
    
97.         hthread[1]=CreateThread(NULL,0,mythread2,NULL,0,NULL);
    
98.         WaitForMultipleObjects(2,hthread,TRUE,INFINITE);
    
99.         CloseHandle(hthread[0]);
    
100.         CloseHandle(hthread[1]);
     
101. 
     
102. }
     

复制代码

    如果不能实现如此精准的定时，那么我觉得在游戏中采用如此精准的时间是否有实际用途就不得而知了。当然这是仅仅考虑除cpu定时器的情况下得出的，如果采用其他设备的定时器结果如何笔者还不得而知，不过笔者认为，只要程序遵循时间片，且不强制剥夺时间片，那么必然还是无法达到精确时间。除非此执行代码段独立于进程且作为定时回调，是否有这种情况，还需要大家广开言路了。当然这不是说无法获取到精确时间，显然精确时间可以获取到，只是无法做到精确定时，在这种时候，获取到精确时间作用也不是很大。如果以上分析有误或有更好的解释和证明，请给出。

0xAA55

对于一款游戏，它确实需要精确的定时，其实就是在每一帧的开头取得当前帧开始的时间，然后通过不同帧时间之间相减取得每帧渲染所消耗的时间（包括垂直同步）。因此只有取得了精确的时间才能取得正确的弹性时间，来作为物理计算的参数。如果取得的时间以毫秒为单位的话，假设在一种没有打开垂直同步的渲染模式下渲染游戏，显卡比较好，那么FPS值可能会到达很高的水平，弹性时间计算出来可能会变成一个非常小的正值甚至是零，甚至小于零，导致物理引擎崩溃（FPU除零等问题）

此外，有些游戏是音乐游戏，比如OSU，歌姬计划，太鼓达人，DjMax，劲舞团（及其山寨版本“QQ炫舞”），还有安卓上的Deemo、节操大师等，这些游戏考验的是玩家的节奏感，也就是玩家要跟着节拍和谱面进行“演奏”，评分的标准是节拍是否打得精准，反应是否够快，按键是否正确等。因此这些游戏对“取得时间”这个操作的精度的要求非常高。我不是音乐人但是我也知道作为一个音乐人，他应该对节奏和时间的把握是很精确的。