mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
Bug 676349 - Implement high-resolution platform timers for the Windows platform, r=robarnold
This commit is contained in:
Honza Bambas
parent
3a4c336190
commit
85f602de44
@ -79,6 +79,8 @@ ifdef HAVE_CLOCK_MONOTONIC
|
||||
CPPSRCS += TimeStamp_posix.cpp
|
||||
else ifeq ($(OS_ARCH),Darwin)
|
||||
CPPSRCS += TimeStamp_darwin.cpp
|
||||
else ifeq ($(OS_ARCH),WINNT)
|
||||
CPPSRCS += TimeStamp_windows.cpp
|
||||
else
|
||||
CPPSRCS += TimeStamp.cpp
|
||||
endif
|
||||
|
||||
651
xpcom/ds/TimeStamp_windows.cpp
Normal file
651
xpcom/ds/TimeStamp_windows.cpp
Normal file
@ -0,0 +1,651 @@
|
||||
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
||||
/* vim:set ts=2 sw=2 sts=2 et cindent: */
|
||||
/* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla Public License Version
|
||||
* 1.1 (the "License"); you may not use this file except in compliance with
|
||||
* the License. You may obtain a copy of the License at
|
||||
* http://www.mozilla.org/MPL/
|
||||
*
|
||||
* Software distributed under the License is distributed on an "AS IS" basis,
|
||||
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
||||
* for the specific language governing rights and limitations under the
|
||||
* License.
|
||||
*
|
||||
* The Original Code is Mozilla code.
|
||||
*
|
||||
* The Initial Developer of the Original Code is the Mozilla Foundation.
|
||||
* Portions created by the Initial Developer are Copyright (C) 2011
|
||||
* the Initial Developer. All Rights Reserved.
|
||||
*
|
||||
* Contributor(s):
|
||||
* Honza Bambas <honzab.moz@firemni.cz>
|
||||
*
|
||||
* Alternatively, the contents of this file may be used under the terms of
|
||||
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
||||
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
||||
* in which case the provisions of the GPL or the LGPL are applicable instead
|
||||
* of those above. If you wish to allow use of your version of this file only
|
||||
* under the terms of either the GPL or the LGPL, and not to allow others to
|
||||
* use your version of this file under the terms of the MPL, indicate your
|
||||
* decision by deleting the provisions above and replace them with the notice
|
||||
* and other provisions required by the GPL or the LGPL. If you do not delete
|
||||
* the provisions above, a recipient may use your version of this file under
|
||||
* the terms of any one of the MPL, the GPL or the LGPL.
|
||||
*
|
||||
* ***** END LICENSE BLOCK ***** */
|
||||
|
||||
// Implement TimeStamp::Now() with QueryPerformanceCounter() controlled with
|
||||
// values of GetTickCount().
|
||||
|
||||
// XXX Forcing log to be able to catch issues in the field. Should be removed
|
||||
// before this reaches the Release or even Beta channel.
|
||||
#define FORCE_PR_LOG
|
||||
|
||||
#include "mozilla/TimeStamp.h"
|
||||
#include "mozilla/Mutex.h"
|
||||
#include "mozilla/Services.h"
|
||||
#include "nsIObserver.h"
|
||||
#include "nsIObserverService.h"
|
||||
#include "nsThreadUtils.h"
|
||||
#include "nsAutoPtr.h"
|
||||
#include <pratom.h>
|
||||
#include <windows.h>
|
||||
|
||||
#include "prlog.h"
|
||||
#include <stdio.h>
|
||||
|
||||
#if defined(PR_LOGGING)
|
||||
// Log module for mozilla::TimeStamp for Windows logging...
|
||||
//
|
||||
// To enable logging (see prlog.h for full details):
|
||||
//
|
||||
// set NSPR_LOG_MODULES=TimeStampWindows:5
|
||||
// set NSPR_LOG_FILE=nspr.log
|
||||
//
|
||||
// this enables PR_LOG_DEBUG level information and places all output in
|
||||
// the file nspr.log
|
||||
PRLogModuleInfo* timeStampLog = PR_NewLogModule("TimeStampWindows");
|
||||
#define LOG(x) PR_LOG(timeStampLog, PR_LOG_DEBUG, x)
|
||||
#else
|
||||
#define LOG(x)
|
||||
#endif /* PR_LOGGING */
|
||||
|
||||
// Estimate of the smallest duration of time we can measure.
|
||||
static volatile ULONGLONG sResolution;
|
||||
static volatile ULONGLONG sResolutionSigDigs;
|
||||
static const double kNsPerSecd = 1000000000.0;
|
||||
static const LONGLONG kNsPerSec = 1000000000;
|
||||
static const LONGLONG kNsPerMillisec = 1000000;
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Global constants
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// After this time we always recalibrate the skew.
|
||||
//
|
||||
// On most platforms QPC and GTC have not quit the same slope, so after some
|
||||
// time the two values will disperse. The 4s calibration interval has been
|
||||
// chosen mostly arbitrarily based on tests.
|
||||
//
|
||||
// Mostly, 4 seconds has been chosen based on the sleep/wake issue - timers
|
||||
// shift after wakeup. I wanted to make the time as reasonably short as
|
||||
// possible to always recalibrate after even a very short standby time (quit
|
||||
// reasonable test case). So, there is a lot of space to prolong it
|
||||
// to say 20 seconds or even more, needs testing in the field, though.
|
||||
//
|
||||
// Value is number of [ms].
|
||||
static const ULONGLONG kCalibrationInterval = 4000;
|
||||
|
||||
// On every read of QPC we check the overflow of skew difference doesn't go
|
||||
// over this number of milliseconds. Both timer functions jitter so we have
|
||||
// to have some limit. The value is based on tests.
|
||||
//
|
||||
// Changing kCalibrationInterval influences this limit: prolonging
|
||||
// just kCalibrationInterval means to be more sensitive to threshold overflows.
|
||||
//
|
||||
// How this constant is used (also see CheckCalibration function):
|
||||
// First, adjust the limit linearly to the calibration interval:
|
||||
// LIMIT = (GTC_now - GTC_calib) / kCalibrationInterval
|
||||
// Then, check the skew difference overflow is in this adjusted limit:
|
||||
// ABS((QPC_now - GTC_now) - (QPC_calib - GTC_calib)) - THRESHOLD < LIMIT
|
||||
//
|
||||
// Thresholds are calculated dynamically, see sUnderrunThreshold and
|
||||
// sOverrunThreshold below.
|
||||
//
|
||||
// Value is number of [ms].
|
||||
static const ULONGLONG kOverflowLimit = 100;
|
||||
|
||||
// If we are not able to get the value of GTC time increment, use this value
|
||||
// which is the most usual increment.
|
||||
static const DWORD kDefaultTimeIncrement = 156001;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Global variables, not changing at runtime
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* The [mt] unit:
|
||||
*
|
||||
* Many values are kept in ticks of the Performance Coutner x 1000,
|
||||
* further just referred as [mt], meaning milli-ticks.
|
||||
*
|
||||
* This is needed to preserve maximum precision of the performance frequency
|
||||
* representation. GetTickCount values in milliseconds are multiplied with
|
||||
* frequency per second. Therefor we need to multiply QPC value by 1000 to
|
||||
* have the same units to allow simple arithmentic with both QPC and GTC.
|
||||
*/
|
||||
|
||||
#define ms2mt(x) ((x) * sFrequencyPerSec)
|
||||
#define mt2ms(x) ((x) / sFrequencyPerSec)
|
||||
#define mt2ms_d(x) (double(x) / sFrequencyPerSec)
|
||||
|
||||
// Result of QueryPerformanceFrequency
|
||||
static LONGLONG sFrequencyPerSec = 0;
|
||||
|
||||
// Lower and upper bound that QueryPerformanceCounter - GetTickCount must not
|
||||
// go under or over when compared to the calibrated QPC - GTC difference (skew)
|
||||
// Values are based on the GetTickCount update interval.
|
||||
//
|
||||
// Schematically, QPC works correctly if ((QPC_now - GTC_now) -
|
||||
// (QPC_calib - GTC_calib)) is in [sUnderrunThreshold, sOverrunThreshold]
|
||||
// interval every time we access them.
|
||||
//
|
||||
// Kept in [mt]
|
||||
static LONGLONG sUnderrunThreshold;
|
||||
static LONGLONG sOverrunThreshold;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Global lock
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// Thread spin count before entering the full wait state for sTimeStampLock.
|
||||
// Inspired by Rob Arnold's work on PRMJ_Now().
|
||||
static const DWORD kLockSpinCount = 4096;
|
||||
|
||||
// Common mutex (thanks the relative complexity of the logic, this is better
|
||||
// then using CMPXCHG8B.)
|
||||
// It is protecting the globals bellow.
|
||||
CRITICAL_SECTION sTimeStampLock;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Globals heavily chaning at runtime, protected with sTimeStampLock mutex
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// The calibrated difference between QPC and GTC.
|
||||
//
|
||||
// Kept in [mt]
|
||||
static LONGLONG sSkew = 0;
|
||||
|
||||
// Keeps the last result we have returned from TickCount64 (bellow). Protects
|
||||
// from roll over and going backward.
|
||||
//
|
||||
// Kept in [ms]
|
||||
static ULONGLONG sLastGTCResult = 0;
|
||||
|
||||
// Holder of the last result of our main hi-res function. Protects from going
|
||||
// backward.
|
||||
//
|
||||
// Kept in [mt]
|
||||
static ULONGLONG sLastResult = 0;
|
||||
|
||||
// Time of the last performed calibration.
|
||||
//
|
||||
// Kept in [ms]
|
||||
static ULONGLONG sLastCalibrated;
|
||||
|
||||
// After we have detected a run out of bounderies set this to true. This
|
||||
// then disallows use of QPC result for the hi-res timer.
|
||||
static bool sFallBackToGTC = false;
|
||||
|
||||
// Set to true to force recalibration on QPC read. This is generally set after
|
||||
// system wake up, during which skew can change a lot.
|
||||
static bool sForceRecalibrate = false;
|
||||
|
||||
|
||||
namespace mozilla {
|
||||
|
||||
|
||||
static ULONGLONG
|
||||
CalibratedPerformanceCounter();
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Critical Section helper class
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class AutoCriticalSection
|
||||
{
|
||||
public:
|
||||
AutoCriticalSection(LPCRITICAL_SECTION section)
|
||||
: mSection(section)
|
||||
{
|
||||
::EnterCriticalSection(mSection);
|
||||
}
|
||||
~AutoCriticalSection()
|
||||
{
|
||||
::LeaveCriticalSection(mSection);
|
||||
}
|
||||
private:
|
||||
LPCRITICAL_SECTION mSection;
|
||||
};
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// System standby and wakeup status observer. Needed to ignore skew jump after
|
||||
// the system has been woken up, happens mostly on XP.
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class StandbyObserver : public nsIObserver
|
||||
{
|
||||
NS_DECL_ISUPPORTS
|
||||
NS_DECL_NSIOBSERVER
|
||||
|
||||
public:
|
||||
StandbyObserver()
|
||||
{
|
||||
LOG(("TimeStamp: StandByObserver::StandByObserver()"));
|
||||
}
|
||||
|
||||
~StandbyObserver()
|
||||
{
|
||||
LOG(("TimeStamp: StandByObserver::~StandByObserver()"));
|
||||
}
|
||||
|
||||
static inline void Ensure()
|
||||
{
|
||||
if (sInitialized)
|
||||
return;
|
||||
|
||||
// Not available to init on other then the main thread since using
|
||||
// the ObserverService.
|
||||
if (!NS_IsMainThread())
|
||||
return;
|
||||
|
||||
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
|
||||
if (!obs)
|
||||
return; // Too soon...
|
||||
|
||||
sInitialized = true;
|
||||
|
||||
nsRefPtr<StandbyObserver> observer = new StandbyObserver();
|
||||
obs->AddObserver(observer, "wake_notification", false);
|
||||
|
||||
// There is no need to remove the observer, observer service is the only
|
||||
// referer and we don't hold reference back to the observer service.
|
||||
}
|
||||
|
||||
private:
|
||||
static bool sInitialized;
|
||||
};
|
||||
|
||||
NS_IMPL_THREADSAFE_ISUPPORTS1(StandbyObserver, nsIObserver)
|
||||
|
||||
bool
|
||||
StandbyObserver::sInitialized = false;
|
||||
|
||||
NS_IMETHODIMP
|
||||
StandbyObserver::Observe(nsISupports *subject,
|
||||
const char *topic,
|
||||
const PRUnichar *data)
|
||||
{
|
||||
AutoCriticalSection lock(&sTimeStampLock);
|
||||
|
||||
// Clear the potentiall fallback flag now and try using
|
||||
// QPC again after wake up.
|
||||
sFallBackToGTC = false;
|
||||
sForceRecalibrate = true;
|
||||
LOG(("TimeStamp: system has woken up, reset GTC fallback"));
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// The timer core implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static void
|
||||
InitThresholds()
|
||||
{
|
||||
DWORD timeAdjustment = 0, timeIncrement = 0;
|
||||
BOOL timeAdjustmentDisabled;
|
||||
GetSystemTimeAdjustment(&timeAdjustment,
|
||||
&timeIncrement,
|
||||
&timeAdjustmentDisabled);
|
||||
|
||||
if (!timeIncrement)
|
||||
timeIncrement = kDefaultTimeIncrement;
|
||||
|
||||
// Ceiling to a millisecond
|
||||
// Example values: 156001, 210000
|
||||
DWORD timeIncrementCeil = timeIncrement;
|
||||
// Don't want to round up if already rounded, values will be: 156000, 209999
|
||||
timeIncrementCeil -= 1;
|
||||
// Convert to ms, values will be: 15, 20
|
||||
timeIncrementCeil /= 10000;
|
||||
// Round up, values will be: 16, 21
|
||||
timeIncrementCeil += 1;
|
||||
// Convert back to 100ns, values will be: 160000, 210000
|
||||
timeIncrementCeil *= 10000;
|
||||
|
||||
// How many milli-ticks has the interval
|
||||
LONGLONG ticksPerGetTickCountResolution =
|
||||
(PRInt64(timeIncrement) * sFrequencyPerSec) / 10000LL;
|
||||
|
||||
// How many milli-ticks has the interval rounded up
|
||||
LONGLONG ticksPerGetTickCountResolutionCeiling =
|
||||
(PRInt64(timeIncrementCeil) * sFrequencyPerSec) / 10000LL;
|
||||
|
||||
|
||||
// I observed differences about 2 times of the GTC resolution. GTC may
|
||||
// jump by 32 ms in two steps, therefor use the ceiling value.
|
||||
sUnderrunThreshold =
|
||||
LONGLONG((-2) * ticksPerGetTickCountResolutionCeiling);
|
||||
|
||||
// QPC should go no further then 2 * GTC resolution
|
||||
sOverrunThreshold =
|
||||
LONGLONG((+2) * ticksPerGetTickCountResolution);
|
||||
}
|
||||
|
||||
static void
|
||||
InitResolution()
|
||||
{
|
||||
// 10 total trials is arbitrary: what we're trying to avoid by
|
||||
// looping is getting unlucky and being interrupted by a context
|
||||
// switch or signal, or being bitten by paging/cache effects
|
||||
|
||||
ULONGLONG minres = ~0ULL;
|
||||
int loops = 10;
|
||||
do {
|
||||
ULONGLONG start = CalibratedPerformanceCounter();
|
||||
ULONGLONG end = CalibratedPerformanceCounter();
|
||||
|
||||
ULONGLONG candidate = (end - start);
|
||||
if (candidate < minres)
|
||||
minres = candidate;
|
||||
} while (--loops && minres);
|
||||
|
||||
if (0 == minres) {
|
||||
minres = 1;
|
||||
}
|
||||
|
||||
// Converting minres that is in [mt] to nanosecods, multiplicating
|
||||
// the argument to preserve resolution.
|
||||
ULONGLONG result = mt2ms(minres * kNsPerMillisec);
|
||||
if (0 == result) {
|
||||
result = 1;
|
||||
}
|
||||
|
||||
sResolution = result;
|
||||
|
||||
// find the number of significant digits in mResolution, for the
|
||||
// sake of ToSecondsSigDigits()
|
||||
ULONGLONG sigDigs;
|
||||
for (sigDigs = 1;
|
||||
!(sigDigs == result
|
||||
|| 10*sigDigs > result);
|
||||
sigDigs *= 10);
|
||||
|
||||
sResolutionSigDigs = sigDigs;
|
||||
}
|
||||
|
||||
// Function protecting GetTickCount result from rolling over, result is in [ms]
|
||||
// @param gtc
|
||||
// Result of GetTickCount(). Passing it as an arg lets us call it out
|
||||
// of the common mutex.
|
||||
static inline ULONGLONG
|
||||
TickCount64(DWORD now)
|
||||
{
|
||||
ULONGLONG lastResultHiPart = sLastGTCResult & (~0ULL << 32);
|
||||
ULONGLONG result = lastResultHiPart | ULONGLONG(now);
|
||||
|
||||
// It may happen that when accessing GTC on multiple threads the results
|
||||
// may differ (GTC value may be lower due to running before the others
|
||||
// right around the overflow moment). That falsely shifts the high part.
|
||||
// Easiest solution is to check for a significant difference.
|
||||
|
||||
if (sLastGTCResult > result) {
|
||||
if ((sLastGTCResult - result) > (1ULL << 31))
|
||||
result += 1ULL << 32;
|
||||
else
|
||||
result = sLastGTCResult;
|
||||
}
|
||||
|
||||
sLastGTCResult = result;
|
||||
return result;
|
||||
}
|
||||
|
||||
// Result is in [mt]
|
||||
static inline ULONGLONG
|
||||
PerformanceCounter()
|
||||
{
|
||||
LARGE_INTEGER pc;
|
||||
::QueryPerformanceCounter(&pc);
|
||||
return pc.QuadPart * 1000ULL;
|
||||
}
|
||||
|
||||
// Called when we detect a larger deviation of QPC to disable it.
|
||||
static inline void
|
||||
RecordFlaw()
|
||||
{
|
||||
sFallBackToGTC = true;
|
||||
|
||||
LOG(("TimeStamp: falling back to GTC :("));
|
||||
|
||||
#if 0
|
||||
// This code has been disabled, because we:
|
||||
// 0. InitResolution must not be called under the lock (would reenter) while
|
||||
// we shouldn't release it here just to allow it
|
||||
// 1. may return back to using QPC after system wake up
|
||||
// 2. InitResolution for GTC will probably return 0 anyway (increments
|
||||
// only every 15 or 16 ms.)
|
||||
//
|
||||
// There is no need to drop sFrequencyPerSec to 1, result of TickCount64
|
||||
// is multiplied and later divided with sFrequencyPerSec. Changing it
|
||||
// here may introduce sync problems. Syncing access to sFrequencyPerSec
|
||||
// is overkill. Drawback is we loose some bits from the upper bound of
|
||||
// the 64 bits timer value, usualy up to 7, it means the app cannot run
|
||||
// more then some 4'000'000 years :)
|
||||
InitResolution();
|
||||
#endif
|
||||
}
|
||||
|
||||
// Check the current skew is in bounderies and occasionally recalculate it.
|
||||
// Return true if QPC is OK to use, return false to use GTC only.
|
||||
//
|
||||
// Arguments:
|
||||
// overflow - the calculated overflow out of the bounderies for skew difference
|
||||
// qpc - current value of QueryPerformanceCounter
|
||||
// gtc - current value of GetTickCount, more actual according possible system
|
||||
// sleep between read of QPC and GTC
|
||||
static inline bool
|
||||
CheckCalibration(LONGLONG overflow, ULONGLONG qpc, ULONGLONG gtc)
|
||||
{
|
||||
if (sFallBackToGTC) {
|
||||
// We are forbidden to use QPC
|
||||
return false;
|
||||
}
|
||||
|
||||
ULONGLONG sinceLastCalibration = gtc - sLastCalibrated;
|
||||
|
||||
if (overflow && !sForceRecalibrate) {
|
||||
// Calculate trend of the overflow to correspond to the calibration
|
||||
// interval, we may get here long after the last calibration because we
|
||||
// either didn't read the hi-res function or the system was suspended.
|
||||
ULONGLONG trend = LONGLONG(overflow *
|
||||
(double(kCalibrationInterval) / sinceLastCalibration));
|
||||
|
||||
LOG(("TimeStamp: calibration after %llus with overflow %1.4fms"
|
||||
", adjusted trend per calibration interval is %1.4fms",
|
||||
sinceLastCalibration / 1000,
|
||||
mt2ms_d(overflow),
|
||||
mt2ms_d(trend)));
|
||||
|
||||
if (trend > ms2mt(kOverflowLimit)) {
|
||||
// This sets sFallBackToGTC, we have detected
|
||||
// an unreliability of QPC, stop using it.
|
||||
RecordFlaw();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (sinceLastCalibration > kCalibrationInterval || sForceRecalibrate) {
|
||||
// Recalculate the skew now
|
||||
sSkew = qpc - ms2mt(gtc);
|
||||
sLastCalibrated = gtc;
|
||||
LOG(("TimeStamp: new skew is %1.2fms (force:%d)",
|
||||
mt2ms_d(sSkew), sForceRecalibrate));
|
||||
|
||||
sForceRecalibrate = false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// The main function. Result is in [mt] ensuring to not go back and be mostly
|
||||
// reliable with highest possible resolution.
|
||||
static ULONGLONG
|
||||
CalibratedPerformanceCounter()
|
||||
{
|
||||
// XXX This is using ObserverService, cannot instantiate in the static
|
||||
// startup, really needs a better initation code here.
|
||||
StandbyObserver::Ensure();
|
||||
|
||||
// Don't hold the lock over call to QueryPerformanceCounter, since it is
|
||||
// the largest bottleneck, let threads read the value concurently to have
|
||||
// possibly a better performance.
|
||||
|
||||
ULONGLONG qpc = PerformanceCounter();
|
||||
DWORD gtcw = GetTickCount();
|
||||
|
||||
AutoCriticalSection lock(&sTimeStampLock);
|
||||
|
||||
// Rollover protection
|
||||
ULONGLONG gtc = TickCount64(gtcw);
|
||||
|
||||
LONGLONG diff = qpc - ms2mt(gtc) - sSkew;
|
||||
LONGLONG overflow = 0;
|
||||
|
||||
if (diff < sUnderrunThreshold) {
|
||||
overflow = sUnderrunThreshold - diff;
|
||||
}
|
||||
else if (diff > sOverrunThreshold) {
|
||||
overflow = diff - sOverrunThreshold;
|
||||
}
|
||||
|
||||
ULONGLONG result = qpc;
|
||||
if (!CheckCalibration(overflow, qpc, gtc)) {
|
||||
// We are back on GTC, QPC has been observed unreliable
|
||||
result = ms2mt(gtc) + sSkew;
|
||||
}
|
||||
|
||||
#if 0
|
||||
LOG(("TimeStamp: result = %1.2fms, diff = %1.4fms",
|
||||
mt2ms_d(result), mt2ms_d(diff)));
|
||||
#endif
|
||||
|
||||
if (result > sLastResult)
|
||||
sLastResult = result;
|
||||
|
||||
return sLastResult;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// TimeDuration and TimeStamp implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
double
|
||||
TimeDuration::ToSeconds() const
|
||||
{
|
||||
return double(mValue) / (sFrequencyPerSec * 1000ULL);
|
||||
}
|
||||
|
||||
double
|
||||
TimeDuration::ToSecondsSigDigits() const
|
||||
{
|
||||
AutoCriticalSection lock(&sTimeStampLock);
|
||||
|
||||
// don't report a value < mResolution ...
|
||||
LONGLONG resolution = sResolution;
|
||||
LONGLONG resolutionSigDigs = sResolutionSigDigs;
|
||||
LONGLONG valueSigDigs = resolution * (mValue / resolution);
|
||||
// and chop off insignificant digits
|
||||
valueSigDigs = resolutionSigDigs * (valueSigDigs / resolutionSigDigs);
|
||||
return double(valueSigDigs) / kNsPerSecd;
|
||||
}
|
||||
|
||||
TimeDuration
|
||||
TimeDuration::FromMilliseconds(double aMilliseconds)
|
||||
{
|
||||
return TimeDuration::FromTicks(PRInt64(ms2mt(aMilliseconds)));
|
||||
}
|
||||
|
||||
TimeDuration
|
||||
TimeDuration::Resolution()
|
||||
{
|
||||
AutoCriticalSection lock(&sTimeStampLock);
|
||||
|
||||
return TimeDuration::FromTicks(PRInt64(sResolution));
|
||||
}
|
||||
|
||||
struct TimeStampInitialization
|
||||
{
|
||||
TimeStampInitialization() {
|
||||
TimeStamp::Startup();
|
||||
}
|
||||
~TimeStampInitialization() {
|
||||
TimeStamp::Shutdown();
|
||||
}
|
||||
};
|
||||
|
||||
static TimeStampInitialization initOnce;
|
||||
|
||||
nsresult
|
||||
TimeStamp::Startup()
|
||||
{
|
||||
// Decide which implementation to use for the high-performance timer.
|
||||
|
||||
InitializeCriticalSectionAndSpinCount(&sTimeStampLock, kLockSpinCount);
|
||||
|
||||
LARGE_INTEGER freq;
|
||||
BOOL QPCAvailable = ::QueryPerformanceFrequency(&freq);
|
||||
if (!QPCAvailable) {
|
||||
// No Performance Counter. Fall back to use GetTickCount.
|
||||
sFrequencyPerSec = 1;
|
||||
sFallBackToGTC = true;
|
||||
InitResolution();
|
||||
|
||||
LOG(("TimeStamp: using GetTickCount"));
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
sFrequencyPerSec = freq.QuadPart;
|
||||
|
||||
ULONGLONG qpc = PerformanceCounter();
|
||||
sLastCalibrated = TickCount64(::GetTickCount());
|
||||
sSkew = qpc - ms2mt(sLastCalibrated);
|
||||
|
||||
InitThresholds();
|
||||
InitResolution();
|
||||
|
||||
LOG(("TimeStamp: initial skew is %1.2fms", mt2ms_d(sSkew)));
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
void
|
||||
TimeStamp::Shutdown()
|
||||
{
|
||||
DeleteCriticalSection(&sTimeStampLock);
|
||||
}
|
||||
|
||||
TimeStamp
|
||||
TimeStamp::Now()
|
||||
{
|
||||
return TimeStamp(PRUint64(CalibratedPerformanceCounter()));
|
||||
}
|
||||
|
||||
} // namespace mozilla
|
||||
Loading…
Reference in New Issue
Block a user