Windows Compute program Run time (high precision timing)

First, meet the Clock () and GetTickCount ():

One, clock ()
Clock () is a timing function in C/s + +, and its associated data type is clock_t. In MSDN, the check for the clock function is defined as follows:
clock_t clock (void);
In simple terms, it is the time that the program consumes the CPU from startup to function calls. This function returns the number of CPU clock ticks (clock ticks) from "Open this program process" to "call clock () function in program", called Wall Clock Time (Wal-clock) in MSDN, and returns 1 if the wall clock time is not desirable. Where clock_t is the data type used to hold the time.

In the time.h file, we can find the definition of it:

[CPP]View PlainCopy

1. #ifndef _clock_t_defined
2. typedef LONG clock_t;
3. #define _clock_t_defined
4. #endif

Clock_t is a long shaping number. In the Time.h file, you also define a constant clocks_per_sec, which is used to indicate how many clock units are in a second, defined as follows:
#define CLOCKS_PER_SEC ((clock_t) 1000)

You can see that every 1 per thousand seconds (1 milliseconds), the value returned by the call to the clock () function increases by 1. Simply put, the clock () can be accurate to 1 milliseconds.
Under the Linux system, the value of the clocks_per_sec may be different, the current use of the Linux print out the value is 1000000, indicating a microsecond. This is a point to note.

Second, GetTickCount ()
GetTickCount function: It returns the number of milliseconds that have elapsed from the operating system boot to the current, and its return value is DWORD. Often used to determine when a method executes, its function prototype is a DWORD GetTickCount (void), and the return value is stored in a 32-bit double-word type DWORD, so the maximum value that can be stored is (2^32-1) MS is approximately 49.71 days, so if the system is running for more than 49.71 days, this number will be referred to in 0,MSDN as well: "Retrieves the numbers of milliseconds that has elapsed since the System was started, up to 49.7 days. ". Therefore, if you are writing server-side programs, you must be extremely careful here to avoid causing unexpected conditions.
Special Note: This function is not sent in real time, but is sent by the system every 18ms, so its minimum precision is 18ms. When a precision calculation of less than 18ms is required, the stopwatch method should be used.

Use clock to calculate the time difference:

[CPP]View PlainCopy

2. #include <time.h>
4. #include <stdio.h>
6. int main ()
8. {
10. double start,end,cost;
12. Start=clock ();
14. Sleep (1);
16. End=clock ();
18. Cost=end-start;
20. printf ("%f/n", cost);
22. return 0;
24. }

Use GetTickCount to calculate the time difference:

[CPP]View PlainCopy

2. #include <iostream>
4. #include <windows.h>
6. Using namespace std;
8. int main ()
10. {
12. Double start = GetTickCount ();
14. Sleep (1000);
16. double End=gettickcount ();
18. cout << "GetTickCount:" << end-start << Endl;
20. return 0;
22. }

It can be concluded that clock is more accurate than gettickcount, so it is recommended to use clock if a higher precision time difference is required. When the program time-consuming statistics, you can use clock to help complete the time difference calculation.

Third, if the need for higher time accuracy (such as server program time-consuming statistics), you can start the timing statistics before the call QueryPerformanceFrequency () function to obtain the clock frequency of the machine internal timer, Then QueryPerformanceCounter () is called before and after the event that requires strict timing, and the exact time of the event (the precision can reach microsecond level) can be calculated using the difference in counts and the clock frequency of two times. Here is the sample code:

[CPP]View PlainCopy

2. #include <windows.h>
4. #include <iostream>
8. int main ()
10. {
12. Large_integer Timestart; //Start time
14. Large_integer Timeend; //End time
18. Large_integer frequency; //Timer frequency
20. QueryPerformanceFrequency (&frequency);
22. Double QuadPart = (double) frequency. QuadPart; //Timer frequency
26. QueryPerformanceCounter (&timestart);
28. Sleep (1000); //Delay one second
30. QueryPerformanceCounter (&timeend);
34. //Get two time-consuming
36. double elapsed = (Timeend.quadpart-timestart.quadpart)/QuadPart;
38. Std::cout << elapsed << Std::endl; //unit is seconds, precision is microseconds (1000000/cpu frequency)
42. System ("pause");
44. return 0;
46. }

Run a few more times, you can see that each sleep time spent is different, so sleep time accuracy is very low!

51330028

Windows Compute program Run time (high precision timing)