Windows 7 计时功能 - 如何正确使用 GetSystemTimeAdju

Windows 7 timing functions - How to use GetSystemTimeAdjustment correctly?(Windows 7 计时功能 - 如何正确使用 GetSystemTimeAdjustment?)

问题描述

我在 Windows 7 上使用 GetSystemTimeAdjustment 函数运行了一些测试，得到了一些我无法解释的有趣结果.据我所知，如果系统时间是定期同步的，则此方法应该返回，如果是，则以哪个间隔和以哪个增量更新(参见 MSDN 上的 GetSystemTimeAdjustment 函数).

从这里我遵循，如果我查询系统时间，例如使用 GetSystemTimeAsFileTime 重复我应该要么没有变化(系统时钟尚未更新)，要么是变化的倍数GetSystemTimeAdjustment 检索到的增量.问题一:这个假设正确吗?

现在考虑以下测试代码:

#include #include #include int main(){FILETIME 文件开始；GetSystemTimeAsFileTime(&fileStart);ULARGE_INTEGER 开始；start.HighPart = fileStart.dwHighDateTime;start.LowPart = fileStart.dwLowDateTime;for (int i=20; i>0; --i){FILETIME时间戳1；ULARGE_INTEGER ts1;GetSystemTimeAsFileTime(&timeStamp1);ts1.HighPart = timeStamp1.dwHighDateTime;ts1.LowPart = timeStamp1.dwLowDateTime;std::cout <<时间戳:" <<std::setprecision(20) <<(double)(ts1.QuadPart - start.QuadPart)/10000000 <<std::endl;}DWORD dwTimeAdjustment = 0, dwTimeIncrement = 0, dwClockTick;BOOL fAdjustmentDisabled = TRUE;GetSystemTimeAdjustment(&dwTimeAdjustment, &dwTimeIncrement, &fAdjustmentDisabled);std::cout <<"
时间调整禁用:" <<f 调整禁用<<"
时间调整:" <<(double)dwTimeAdjustment/10000000<<"
时间增量:" <<(double)dwTimeIncrement/10000000 <<std::endl;}

它在一个循环中需要 20 个时间戳并将它们打印到控制台.最后，它打印系统时钟更新的增量.我希望循环中打印的时间戳之间的差异是此增量的 0 或倍数.但是，我得到这样的结果:

时间戳:0时间戳:0.0025000000000000001时间戳:0.0074999999999999997时间戳:0.01时间戳:0.012500000000000001时间戳:0.014999999999999999时间戳:0.017500000000000002时间戳:0.022499999999999999时间戳:0.025000000000000001时间戳:0.0275时间戳:0.029999999999999999时间戳:0.032500000000000001时间戳:0.035000000000000003时间戳:0.040000000000000001时间戳:0.042500000000000003时间戳:0.044999999999999998时间戳:0.050000000000000003时间戳:0.052499999999999998时间戳:0.055时间戳:0.057500000000000002时间调整禁用:0时间调整:0.0156001时间增量:0.0156001

因此看起来系统时间是使用大约 0.0025 秒而不是 GetSystemTimeAdjustment 返回的 0.0156 秒的间隔更新的.

问题二:这是什么原因?

GetSystemTimeAsFileTimeAPI 提供对文件时间格式的系统挂钟的访问.

64 位 FILETIME 结构以 100ns 为单位接收系统时间作为 FILETIME，该时间自 1601 年 1 月 1 日起已过期.对 GetSystemTimeAsFileTime 的调用通常需要 10 ns 到 15 ns.

为了调查此 API 提供的系统时间的真实准确性，需要讨论与时间值一起出现的粒度.换句话说:系统时间多久更新一次?第一个估计值由隐藏的 API 调用提供:

NTSTATUS NtQueryTimerResolution(OUT PULONG MinimumResolution,OUT PULONG 最大分辨率，OUT PULONG 实际分辨率)；

NtQueryTimerResolution 由本地 Windows NT 库 NTDLL.DLL 导出.本次调用上报的ActualResolution以100ns为单位表示系统时间的更新周期，不一定与中断周期匹配.该值取决于硬件平台.常见硬件平台为 ActualResolution 报告 156,250 或 100,144；较旧的平台可能会报告更大的数字；较新的系统，尤其是在支持 HPET(高精度事件计时器)或 常量/不变 TSC 时，可能会为 ActualResolution 返回 156,001.

这是控制系统的心跳之一.MinimumResolution 和 ActualResolution 与多媒体计时器配置相关.

ActualResolution 可以通过 API 调用设置

NTSTATUS NtSetTimerResolution(IN ULONG RequestedResolution,在布尔集合中，OUT PULONG 实际分辨率)；

或通过多媒体定时器界面

MMRESULT timeBeginPeriod(UINT uPeriod);

从允许的范围推导出 uPeriod 的值

MMRESULT timeGetDevCaps(LPTIMECAPS ptc, UINT cbtc);

填充结构

typedef struct {UINT wPeriodMin;UINT wPeriodMax;TIMECAPS;

wPeriodMin 的典型值为 1 ms，wPeriodMax 的典型值为 1,000,000 ms.

在这里查看最小值/最大值时存在一个不幸的误解:

• wPeriodMin 定义了最短时间段，在此上下文中很清楚.
• MinimumResolution 另一方面由 NtQueryTimerResolution 返回指定分辨率.可获得的最低分辨率(MinimumResolution)可达20 ms左右，而可获得的最高分辨率(MaximumResolution)可达0.5 ms.但是，无法通过 timeBeginPeriod 访问 0.5 毫秒的结果.

多媒体定时器接口处理周期，NtQueryTimerResolution() 处理分辨率(周期的倒数).

总结: GetSystemTimeAdjustment 不是要查看的函数.此功能仅说明如何以及是否完成时间更改.根据多媒体定时器界面timeBeginPeriod的设置，时间进度可能会更频繁，更小部分.使用 NtQueryTimerResolution 接收实际时间增量.请注意，多媒体计时器 API 的设置确实会影响这些值.(例如:当媒体播放器播放视频时，时间越来越短.)

我诊断出 Windows 时间在很大程度上很重要.部分结果可以在此处找到.

注意:时间调整:0.0156001在您的系统上使用 HPET 和/或 constant/invariant TSC 清楚地识别 Windows VISTA 或更高版本.

实施:如果你想抓住时间的转变:

FILETIME FileTime,LastFileTime;长长的到期时间，最后时间；长 FileTimeTransitionPeriod;GetSystemTimeAsFileTime(&FileTime);for (int i = 0; i <20; i++) {LastFileTime.dwLowDateTime = FileTime.dwLowDateTime;while (FileTime.dwLowDateTime == LastFileTime.dwLowDateTime) GetSystemTimeAsFileTime(&FileTime);//足以只看低部分来捕捉过渡CopyMemory(&DueTime,&FileTime,sizeof(FILETIME));CopyMemory(&LastTime,&LastFileTime,sizeof(FILETIME));FileTimeTransitionPeriod = (long)(DueTime-LastTime);fprintf(stdout,"transition period: % 7.4lf ms)
",(double)(FileTimeTransitionPeriod)/10000);}//警告:此代码以 20 个文件时间增量消耗 100% 的 cpu.//在 15.625 毫秒的标准文件时间增量下，这对应于 312.5 毫秒！

但是:当文件时间转换非常短时(例如由 timeBeginPeriod(wPeriodMin) 设置)任何输出，如 fprintf 或 std::cout 可能会破坏结果，因为它会延迟循环.在这种情况下，我建议将 20 个结果存储在一个数据结构中，然后再进行输出.

并且:文件时间转换可能并不总是相同的.很可能是文件时间增量与更新周期不匹配.请参阅上面的链接以获取有关此行为的更多详细信息和示例.

调用 timeBeginPeriod 时要小心，因为频繁调用会显着影响系统时钟 MSDN.此行为适用于 Windows 版本 7.

对timeBeginPeriod/timeEndPeriod 或NtSetTimerResolution 的调用可能会改变系统时间与ActualResolution 一样多.经常这样做会导致系统时间发生相当大的变化.但是，当在系统时间转换时或附近进行调用时，偏差要小得多.对于要求苛刻的应用程序(如 NTP 客户端)，建议在调用上述函数之前轮询系统时间转换/增量.当系统时间进程发生意外跳转时，很难同步到 NTP 服务器.

I ran some tests using the GetSystemTimeAdjustment function on Windows 7, and got some interesting results which I cannot explain. As fas as I understand, this method should return if the system time is synchronized periodically and if it is, at which interval and with which increment it is updated (see GetSystemTimeAdjustment function on MSDN).

From this I follow that if I query the system time for example using GetSystemTimeAsFileTime repeatingly I should either get no change (the system clock has not been updated), or a change which is a multiple of the increment retrieved by GetSystemTimeAdjustment. Question one: Is this assumption correct?

Now consider the following testing code:

#include <windows.h>
#include <iostream>
#include <iomanip>

int main()
{
    FILETIME fileStart;
    GetSystemTimeAsFileTime(&fileStart);
    ULARGE_INTEGER start;
    start.HighPart = fileStart.dwHighDateTime;
    start.LowPart = fileStart.dwLowDateTime;

    for (int i=20; i>0; --i)
    {
        FILETIME timeStamp1;
        ULARGE_INTEGER ts1;

        GetSystemTimeAsFileTime(&timeStamp1);

        ts1.HighPart = timeStamp1.dwHighDateTime;
        ts1.LowPart  = timeStamp1.dwLowDateTime;

        std::cout << "Timestamp: " << std::setprecision(20) << (double)(ts1.QuadPart - start.QuadPart) / 10000000 << std::endl;

    }

    DWORD dwTimeAdjustment = 0, dwTimeIncrement = 0, dwClockTick;
    BOOL fAdjustmentDisabled = TRUE;
    GetSystemTimeAdjustment(&dwTimeAdjustment, &dwTimeIncrement, &fAdjustmentDisabled);

    std::cout << "
Time Adjustment disabled: " << fAdjustmentDisabled
        << "
Time Adjustment: " << (double)dwTimeAdjustment/10000000
        << "
Time Increment: " << (double)dwTimeIncrement/10000000 << std::endl;

}

It takes 20 timestamps in a loop and prints them to the console. In the end it prints the increment with which the system clock is updated. I would expect the differences between the timestamps printed in the loop to be either 0 or multiples of this increment. However, I get results like this:

Timestamp: 0
Timestamp: 0.0025000000000000001
Timestamp: 0.0074999999999999997
Timestamp: 0.01
Timestamp: 0.012500000000000001
Timestamp: 0.014999999999999999
Timestamp: 0.017500000000000002
Timestamp: 0.022499999999999999
Timestamp: 0.025000000000000001
Timestamp: 0.0275
Timestamp: 0.029999999999999999
Timestamp: 0.032500000000000001
Timestamp: 0.035000000000000003
Timestamp: 0.040000000000000001
Timestamp: 0.042500000000000003
Timestamp: 0.044999999999999998
Timestamp: 0.050000000000000003
Timestamp: 0.052499999999999998
Timestamp: 0.055
Timestamp: 0.057500000000000002

Time Adjustment disabled: 0
Time Adjustment: 0.0156001
Time Increment: 0.0156001

So it appears that the system time is updated using an interval of about 0.0025 seconds and not 0.0156 seconds as return by GetSystemTimeAdjustment.

Question two: What is the reason for this?

The GetSystemTimeAsFileTimeAPI provides access to the system's wall clock in file time format.

A 64-bit FILETIME structure receives the system time as FILETIME in 100ns units, which have been expired since Jan 1, 1601. The call to GetSystemTimeAsFileTime typically requires 10 ns to 15 ns.

In order to investigate the real accuracy of the system time provided by this API, the granularity that comes along with the time values needs to be discussed. In other words: How often is the system time updated? A first estimate is provided by the hidden API call:

NTSTATUS NtQueryTimerResolution(OUT PULONG MinimumResolution, 
                                OUT PULONG MaximumResolution, 
                                OUT PULONG ActualResolution);

NtQueryTimerResolution is exported by the native Windows NT library NTDLL.DLL. The ActualResolution reported by this call represents the update period of the system time in 100 ns units, which does not necessarily match the interrupt period. The value depends on the hardware platform. Common hardware platforms report 156,250 or 100,144 for ActualResolution; older platforms may report even larger numbers; newer systems, particulary when HPET (High Precision Event Timer) or constant/invariant TSC are supported, may return 156,001 for ActualResolution.

This is one of the heartbeats controlling the system. The MinimumResolution and the ActualResolution are relevant for the multimedia timer configuration.

The ActualResolution can be set by using the API call

NTSTATUS NtSetTimerResolution(IN ULONG RequestedResolution,
                              IN BOOLEAN Set,
                              OUT PULONG ActualResolution);

or via the multimedia timer interface

MMRESULT timeBeginPeriod(UINT uPeriod);

with the value of uPeriod derived from the range allowed by

MMRESULT timeGetDevCaps(LPTIMECAPS ptc, UINT cbtc );

which fills the structure

typedef struct {
  UINT wPeriodMin;
  UINT wPeriodMax;
} TIMECAPS;

Typical values are 1 ms for wPeriodMin and 1,000,000 ms for wPeriodMax.

There is an unfortunate misinterpretation when looking an the min/max values here:

• wPeriodMin defines the minimum period, which is clear in this context.
• MinimumResolution returned by NtQueryTimerResolution on the other hand specifies a resolution. The lowest obtainable resolution (MinimumResolution) is in the range of up to about 20 ms, while the highest obtainable resolution (MaximumResolution) can be 0.5 ms. However, the 0.5 ms resulution is not accessable through a of timeBeginPeriod.

The multimedia timer interface handles periods and NtQueryTimerResolution() handles resolutions (reciprocal value of period).

Summary: GetSystemTimeAdjustment is not the function to look at. This function only tells how and if time-changes are done. Depending on the setting of the multimedia timer interface timeBeginPeriod, the progress of time may be done more often and in smaller portions. Use NtQueryTimerResolution to receive the actual time increment. And be aware that the setting of the multimedia timer API does influence the values. (Example: When the media player is showing a video, the times are getting short.)

I diagnosed windows time matters to a large extent. Some of the results can be found here.

Note: Time Adjustment: 0.0156001 clearly identifies windows VISTA or higher with HPET and/or constant/invariant TSC on your system.

Implementation: If you want to catch the time transition:

FILETIME FileTime,LastFileTime;
long long DueTime,LastTime;
long FileTimeTransitionPeriod; 

GetSystemTimeAsFileTime(&FileTime);
for (int i = 0; i < 20; i++) {
  LastFileTime.dwLowDateTime = FileTime.dwLowDateTime;
  while (FileTime.dwLowDateTime == LastFileTime.dwLowDateTime) GetSystemTimeAsFileTime(&FileTime); 
  // enough to just look at the low part to catch the transition
  CopyMemory(&DueTime,&FileTime,sizeof(FILETIME));
  CopyMemory(&LastTime,&LastFileTime,sizeof(FILETIME));
  FileTimeTransitionPeriod = (long)(DueTime-LastTime);
  fprintf(stdout,"transition period: % 7.4lf ms)
",(double)(FileTimeTransitionPeriod)/10000);
}   

// WARNING: This code consumes 100% of the cpu for 20 file time increments.
// At the standard file time increment of 15.625 ms this corresponds to 312.5ms!

But: When the filetime transition is very short (e.g. set by timeBeginPeriod(wPeriodMin)) any output like fprintf or std::cout might destroy the result because it delays the loop. In such cases I'd recommend to store the 20 results in a data structure and do the output afterwards.

And: The filetime transition may not always be the same. It may well be that the file time increment does not match the update period. See the link above to get more details and examples for this bahavior.

Edit: Use caution when calling timeBeginPeriod, as frequent calls can significantly affect the system clock MSDN. This behavior applies up to Windows version 7.

Calls to timeBeginPeriod/timeEndPeriod or NtSetTimerResolution may change the system time by as much as ActualResolution. Doing it very often results in considerable changes of the system time. However, when the calls are made at or near the transition of the system time, deviations are much less. Polling for a system time transition/increment ahead of calls to the above function is advised for demanding applications like NTP clients. Synchronizing to an NTP server is difficult when unwanted jumps in the systemtime progess occurs.

这篇关于Windows 7 计时功能 - 如何正确使用 GetSystemTimeAdjustment?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程学习网！