Changeset 36578 in webkit for trunk/JavaScriptCore/kjs/DateMath.cpp

Timestamp:

Sep 17, 2008, 4:54:31 PM (17 years ago)

Author:

[email protected]

Message:

Improve timer accuracy for JavaScript Date object on Windows.

Use a combination of ftime and QueryPerformanceCounter.
ftime returns the information we want, but doesn't have sufficient resolution.
QueryPerformanceCounter has high resolution, but is only usable to measure time intervals.
To combine them, we call ftime and QueryPerformanceCounter initially. Later calls will use
QueryPerformanceCounter by itself, adding the delta to the saved ftime. We re-sync to
correct for drift if the low-res and high-res elapsed time between calls differs by more
than twice the low-resolution timer resolution.

QueryPerformanceCounter may be inaccurate due to a problems with:

• some PCI bridge chipsets (​http://support.microsoft.com/kb/274323)
• BIOS bugs (​http://support.microsoft.com/kb/895980/)
• BIOS/HAL bugs on multiprocessor/multicore systems (​http://msdn.microsoft.com/en-us/library/ms644904.aspx)

Reviewed by Darin Adler.

• kjs/DateMath.cpp: (JSC::highResUpTime): (JSC::lowResUTCTime): (JSC::qpcAvailable): (JSC::getCurrentUTCTimeWithMicroseconds):

File:

• trunk/JavaScriptCore/kjs/DateMath.cpp (modified) (1 diff)

trunk/JavaScriptCore/kjs/DateMath.cpp

@@ -288 +288 @@
 }
 
-double getCurrentUTCTimeWithMicroseconds()
-{
 #if PLATFORM(WIN_OS)
-    // FIXME: the implementation for Windows is only millisecond resolution.
-#if COMPILER(BORLAND)
-    struct timeb timebuffer;
-    ftime(&timebuffer);
-#else
+
+static LARGE_INTEGER qpcFrequency;
+static bool syncedTime;
+
+static double highResUpTime()
+{
+    // We use QPC, but only after sanity checking its result, due to bugs:
+    // http://support.microsoft.com/kb/274323
+    // http://support.microsoft.com/kb/895980
+    // http://msdn.microsoft.com/en-us/library/ms644904.aspx ("...you can get different results on different processors due to bugs in the basic input/output system (BIOS) or the hardware abstraction layer (HAL)."
+
+    static LARGE_INTEGER qpcLast;
+    static DWORD tickCountLast;
+    static bool inited;
+
+    LARGE_INTEGER qpc;
+    QueryPerformanceCounter(&qpc);
+    DWORD tickCount = GetTickCount();
+
+    if (inited) {
+        __int64 qpcElapsed = ((qpc.QuadPart - qpcLast.QuadPart) * 1000) / qpcFrequency.QuadPart;
+        __int64 tickCountElapsed;
+        if (tickCount >= tickCountLast)
+            tickCountElapsed = (tickCount - tickCountLast);
+        else {
+            __int64 tickCountLarge = tickCount + 0x100000000I64;
+            tickCountElapsed = tickCountLarge - tickCountLast;
+        }
+
+        // force a re-sync if QueryPerformanceCounter differs from GetTickCount by more than 500ms.
+        // (500ms value is from http://support.microsoft.com/kb/274323)
+        __int64 diff = tickCountElapsed - qpcElapsed;
+        if (diff > 500 || diff < -500)
+            syncedTime = false;
+    } else
+        inited = true;
+
+    qpcLast = qpc;
+    tickCountLast = tickCount;
+
+    return (1000.0 * qpc.QuadPart) / static_cast<double>(qpcFrequency.QuadPart);;
+}
+
+static double lowResUTCTime()
+{
     struct _timeb timebuffer;
     _ftime(&timebuffer);
-#endif
-    double utc = timebuffer.time * msPerSecond + timebuffer.millitm;
+    return timebuffer.time * msPerSecond + timebuffer.millitm;
+}
+
+static bool qpcAvailable()
+{
+    static bool available;
+    static bool checked;
+
+    if (checked)
+        return available;
+
+    available = QueryPerformanceFrequency(&qpcFrequency);
+    checked = true;
+    return available;
+}
+
+#endif
+
+double getCurrentUTCTimeWithMicroseconds()
+{
+#if PLATFORM(WIN_OS)
+    // Use a combination of ftime and QueryPerformanceCounter.
+    // ftime returns the information we want, but doesn't have sufficient resolution.
+    // QueryPerformanceCounter has high resolution, but is only usable to measure time intervals.
+    // To combine them, we call ftime and QueryPerformanceCounter initially. Later calls will use QueryPerformanceCounter
+    // by itself, adding the delta to the saved ftime.  We periodically re-sync to correct for drift.
+    static bool started;
+    static double syncLowResUTCTime;
+    static double syncHighResUpTime;
+    static double lastUTCTime;
+
+    double lowResTime = lowResUTCTime();
+
+    if (!qpcAvailable())
+        return lowResTime;
+
+    double highResTime = highResUpTime();
+
+    if (!syncedTime) {
+        timeBeginPeriod(1); // increase time resolution around low-res time getter
+        syncLowResUTCTime = lowResTime = lowResUTCTime();
+        timeEndPeriod(1); // restore time resolution
+        syncHighResUpTime = highResTime;
+        syncedTime = true;
+    }
+
+    double highResElapsed = highResTime - syncHighResUpTime;
+    double utc = syncLowResUTCTime + highResElapsed;
+
+    // force a clock re-sync if we've drifted
+    double lowResElapsed = lowResTime - syncLowResUTCTime;
+    const double maximumAllowedDriftMsec = 15.625 * 2.0; // 2x the typical low-res accuracy
+    if (fabs(highResElapsed - lowResElapsed) > maximumAllowedDriftMsec)
+        syncedTime = false;
+
+    // make sure time doesn't run backwards (only correct if difference is < 2 seconds, since DST or clock changes could occur)
+    const double backwardTimeLimit = 2000.0;
+    if (utc < lastUTCTime && (lastUTCTime - utc) < backwardTimeLimit)
+        return lastUTCTime;
+    lastUTCTime = utc;
 #else
     struct timeval tv;