1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5 6// Windows Timer Primer 7// 8// A good article: http://www.ddj.com/windows/184416651 9// A good mozilla bug: http://bugzilla.mozilla.org/show_bug.cgi?id=363258 10// 11// The default windows timer, GetSystemTimeAsFileTime is not very precise. 12// It is only good to ~15.5ms. 13// 14// QueryPerformanceCounter is the logical choice for a high-precision timer. 15// However, it is known to be buggy on some hardware. Specifically, it can 16// sometimes "jump". On laptops, QPC can also be very expensive to call. 17// It's 3-4x slower than timeGetTime() on desktops, but can be 10x slower 18// on laptops. A unittest exists which will show the relative cost of various 19// timers on any system. 20// 21// The next logical choice is timeGetTime(). timeGetTime has a precision of 22// 1ms, but only if you call APIs (timeBeginPeriod()) which affect all other 23// applications on the system. By default, precision is only 15.5ms. 24// Unfortunately, we don't want to call timeBeginPeriod because we don't 25// want to affect other applications. Further, on mobile platforms, use of 26// faster multimedia timers can hurt battery life. See the intel 27// article about this here: 28// http://softwarecommunity.intel.com/articles/eng/1086.htm 29// 30// To work around all this, we're going to generally use timeGetTime(). We 31// will only increase the system-wide timer if we're not running on battery 32// power. Using timeBeginPeriod(1) is a requirement in order to make our 33// message loop waits have the same resolution that our time measurements 34// do. Otherwise, WaitForSingleObject(..., 1) will no less than 15ms when 35// there is nothing else to waken the Wait. 36 37#include "base/time/time.h" 38 39#pragma comment(lib, "winmm.lib") 40#include <windows.h> 41#include <mmsystem.h> 42 43#include "base/basictypes.h" 44#include "base/cpu.h" 45#include "base/logging.h" 46#include "base/memory/singleton.h" 47#include "base/synchronization/lock.h" 48 49using base::Time; 50using base::TimeDelta; 51using base::TimeTicks; 52 53namespace { 54 55// From MSDN, FILETIME "Contains a 64-bit value representing the number of 56// 100-nanosecond intervals since January 1, 1601 (UTC)." 57int64 FileTimeToMicroseconds(const FILETIME& ft) { 58 // Need to bit_cast to fix alignment, then divide by 10 to convert 59 // 100-nanoseconds to milliseconds. This only works on little-endian 60 // machines. 61 return bit_cast<int64, FILETIME>(ft) / 10; 62} 63 64void MicrosecondsToFileTime(int64 us, FILETIME* ft) { 65 DCHECK_GE(us, 0LL) << "Time is less than 0, negative values are not " 66 "representable in FILETIME"; 67 68 // Multiply by 10 to convert milliseconds to 100-nanoseconds. Bit_cast will 69 // handle alignment problems. This only works on little-endian machines. 70 *ft = bit_cast<FILETIME, int64>(us * 10); 71} 72 73int64 CurrentWallclockMicroseconds() { 74 FILETIME ft; 75 ::GetSystemTimeAsFileTime(&ft); 76 return FileTimeToMicroseconds(ft); 77} 78 79// Time between resampling the un-granular clock for this API. 60 seconds. 80const int kMaxMillisecondsToAvoidDrift = 60 * Time::kMillisecondsPerSecond; 81 82int64 initial_time = 0; 83TimeTicks initial_ticks; 84 85void InitializeClock() { 86 initial_ticks = TimeTicks::Now(); 87 initial_time = CurrentWallclockMicroseconds(); 88} 89 90} // namespace 91 92// Time ----------------------------------------------------------------------- 93 94// The internal representation of Time uses FILETIME, whose epoch is 1601-01-01 95// 00:00:00 UTC. ((1970-1601)*365+89)*24*60*60*1000*1000, where 89 is the 96// number of leap year days between 1601 and 1970: (1970-1601)/4 excluding 97// 1700, 1800, and 1900. 98// static 99const int64 Time::kTimeTToMicrosecondsOffset = GG_INT64_C(11644473600000000); 100 101bool Time::high_resolution_timer_enabled_ = false; 102int Time::high_resolution_timer_activated_ = 0; 103 104// static 105Time Time::Now() { 106 if (initial_time == 0) 107 InitializeClock(); 108 109 // We implement time using the high-resolution timers so that we can get 110 // timeouts which are smaller than 10-15ms. If we just used 111 // CurrentWallclockMicroseconds(), we'd have the less-granular timer. 112 // 113 // To make this work, we initialize the clock (initial_time) and the 114 // counter (initial_ctr). To compute the initial time, we can check 115 // the number of ticks that have elapsed, and compute the delta. 116 // 117 // To avoid any drift, we periodically resync the counters to the system 118 // clock. 119 while (true) { 120 TimeTicks ticks = TimeTicks::Now(); 121 122 // Calculate the time elapsed since we started our timer 123 TimeDelta elapsed = ticks - initial_ticks; 124 125 // Check if enough time has elapsed that we need to resync the clock. 126 if (elapsed.InMilliseconds() > kMaxMillisecondsToAvoidDrift) { 127 InitializeClock(); 128 continue; 129 } 130 131 return Time(elapsed + Time(initial_time)); 132 } 133} 134 135// static 136Time Time::NowFromSystemTime() { 137 // Force resync. 138 InitializeClock(); 139 return Time(initial_time); 140} 141 142// static 143Time Time::FromFileTime(FILETIME ft) { 144 if (bit_cast<int64, FILETIME>(ft) == 0) 145 return Time(); 146 if (ft.dwHighDateTime == std::numeric_limits<DWORD>::max() && 147 ft.dwLowDateTime == std::numeric_limits<DWORD>::max()) 148 return Max(); 149 return Time(FileTimeToMicroseconds(ft)); 150} 151 152FILETIME Time::ToFileTime() const { 153 if (is_null()) 154 return bit_cast<FILETIME, int64>(0); 155 if (is_max()) { 156 FILETIME result; 157 result.dwHighDateTime = std::numeric_limits<DWORD>::max(); 158 result.dwLowDateTime = std::numeric_limits<DWORD>::max(); 159 return result; 160 } 161 FILETIME utc_ft; 162 MicrosecondsToFileTime(us_, &utc_ft); 163 return utc_ft; 164} 165 166// static 167void Time::EnableHighResolutionTimer(bool enable) { 168 // Test for single-threaded access. 169 static PlatformThreadId my_thread = PlatformThread::CurrentId(); 170 DCHECK(PlatformThread::CurrentId() == my_thread); 171 172 if (high_resolution_timer_enabled_ == enable) 173 return; 174 175 high_resolution_timer_enabled_ = enable; 176} 177 178// static 179bool Time::ActivateHighResolutionTimer(bool activating) { 180 if (!high_resolution_timer_enabled_ && activating) 181 return false; 182 183 // Using anything other than 1ms makes timers granular 184 // to that interval. 185 const int kMinTimerIntervalMs = 1; 186 MMRESULT result; 187 if (activating) { 188 result = timeBeginPeriod(kMinTimerIntervalMs); 189 high_resolution_timer_activated_++; 190 } else { 191 result = timeEndPeriod(kMinTimerIntervalMs); 192 high_resolution_timer_activated_--; 193 } 194 return result == TIMERR_NOERROR; 195} 196 197// static 198bool Time::IsHighResolutionTimerInUse() { 199 // Note: we should track the high_resolution_timer_activated_ value 200 // under a lock if we want it to be accurate in a system with multiple 201 // message loops. We don't do that - because we don't want to take the 202 // expense of a lock for this. We *only* track this value so that unit 203 // tests can see if the high resolution timer is on or off. 204 return high_resolution_timer_enabled_ && 205 high_resolution_timer_activated_ > 0; 206} 207 208// static 209Time Time::FromExploded(bool is_local, const Exploded& exploded) { 210 // Create the system struct representing our exploded time. It will either be 211 // in local time or UTC. 212 SYSTEMTIME st; 213 st.wYear = exploded.year; 214 st.wMonth = exploded.month; 215 st.wDayOfWeek = exploded.day_of_week; 216 st.wDay = exploded.day_of_month; 217 st.wHour = exploded.hour; 218 st.wMinute = exploded.minute; 219 st.wSecond = exploded.second; 220 st.wMilliseconds = exploded.millisecond; 221 222 FILETIME ft; 223 bool success = true; 224 // Ensure that it's in UTC. 225 if (is_local) { 226 SYSTEMTIME utc_st; 227 success = TzSpecificLocalTimeToSystemTime(NULL, &st, &utc_st) && 228 SystemTimeToFileTime(&utc_st, &ft); 229 } else { 230 success = !!SystemTimeToFileTime(&st, &ft); 231 } 232 233 if (!success) { 234 NOTREACHED() << "Unable to convert time"; 235 return Time(0); 236 } 237 return Time(FileTimeToMicroseconds(ft)); 238} 239 240void Time::Explode(bool is_local, Exploded* exploded) const { 241 if (us_ < 0LL) { 242 // We are not able to convert it to FILETIME. 243 ZeroMemory(exploded, sizeof(*exploded)); 244 return; 245 } 246 247 // FILETIME in UTC. 248 FILETIME utc_ft; 249 MicrosecondsToFileTime(us_, &utc_ft); 250 251 // FILETIME in local time if necessary. 252 bool success = true; 253 // FILETIME in SYSTEMTIME (exploded). 254 SYSTEMTIME st; 255 if (is_local) { 256 SYSTEMTIME utc_st; 257 // We don't use FileTimeToLocalFileTime here, since it uses the current 258 // settings for the time zone and daylight saving time. Therefore, if it is 259 // daylight saving time, it will take daylight saving time into account, 260 // even if the time you are converting is in standard time. 261 success = FileTimeToSystemTime(&utc_ft, &utc_st) && 262 SystemTimeToTzSpecificLocalTime(NULL, &utc_st, &st); 263 } else { 264 success = !!FileTimeToSystemTime(&utc_ft, &st); 265 } 266 267 if (!success) { 268 NOTREACHED() << "Unable to convert time, don't know why"; 269 ZeroMemory(exploded, sizeof(*exploded)); 270 return; 271 } 272 273 exploded->year = st.wYear; 274 exploded->month = st.wMonth; 275 exploded->day_of_week = st.wDayOfWeek; 276 exploded->day_of_month = st.wDay; 277 exploded->hour = st.wHour; 278 exploded->minute = st.wMinute; 279 exploded->second = st.wSecond; 280 exploded->millisecond = st.wMilliseconds; 281} 282 283// TimeTicks ------------------------------------------------------------------ 284namespace { 285 286// We define a wrapper to adapt between the __stdcall and __cdecl call of the 287// mock function, and to avoid a static constructor. Assigning an import to a 288// function pointer directly would require setup code to fetch from the IAT. 289DWORD timeGetTimeWrapper() { 290 return timeGetTime(); 291} 292 293DWORD (*tick_function)(void) = &timeGetTimeWrapper; 294 295// Accumulation of time lost due to rollover (in milliseconds). 296int64 rollover_ms = 0; 297 298// The last timeGetTime value we saw, to detect rollover. 299DWORD last_seen_now = 0; 300 301// Lock protecting rollover_ms and last_seen_now. 302// Note: this is a global object, and we usually avoid these. However, the time 303// code is low-level, and we don't want to use Singletons here (it would be too 304// easy to use a Singleton without even knowing it, and that may lead to many 305// gotchas). Its impact on startup time should be negligible due to low-level 306// nature of time code. 307base::Lock rollover_lock; 308 309// We use timeGetTime() to implement TimeTicks::Now(). This can be problematic 310// because it returns the number of milliseconds since Windows has started, 311// which will roll over the 32-bit value every ~49 days. We try to track 312// rollover ourselves, which works if TimeTicks::Now() is called at least every 313// 49 days. 314TimeDelta RolloverProtectedNow() { 315 base::AutoLock locked(rollover_lock); 316 // We should hold the lock while calling tick_function to make sure that 317 // we keep last_seen_now stay correctly in sync. 318 DWORD now = tick_function(); 319 if (now < last_seen_now) 320 rollover_ms += 0x100000000I64; // ~49.7 days. 321 last_seen_now = now; 322 return TimeDelta::FromMilliseconds(now + rollover_ms); 323} 324 325// Overview of time counters: 326// (1) CPU cycle counter. (Retrieved via RDTSC) 327// The CPU counter provides the highest resolution time stamp and is the least 328// expensive to retrieve. However, the CPU counter is unreliable and should not 329// be used in production. Its biggest issue is that it is per processor and it 330// is not synchronized between processors. Also, on some computers, the counters 331// will change frequency due to thermal and power changes, and stop in some 332// states. 333// 334// (2) QueryPerformanceCounter (QPC). The QPC counter provides a high- 335// resolution (100 nanoseconds) time stamp but is comparatively more expensive 336// to retrieve. What QueryPerformanceCounter actually does is up to the HAL. 337// (with some help from ACPI). 338// According to http://blogs.msdn.com/oldnewthing/archive/2005/09/02/459952.aspx 339// in the worst case, it gets the counter from the rollover interrupt on the 340// programmable interrupt timer. In best cases, the HAL may conclude that the 341// RDTSC counter runs at a constant frequency, then it uses that instead. On 342// multiprocessor machines, it will try to verify the values returned from 343// RDTSC on each processor are consistent with each other, and apply a handful 344// of workarounds for known buggy hardware. In other words, QPC is supposed to 345// give consistent result on a multiprocessor computer, but it is unreliable in 346// reality due to bugs in BIOS or HAL on some, especially old computers. 347// With recent updates on HAL and newer BIOS, QPC is getting more reliable but 348// it should be used with caution. 349// 350// (3) System time. The system time provides a low-resolution (typically 10ms 351// to 55 milliseconds) time stamp but is comparatively less expensive to 352// retrieve and more reliable. 353class HighResNowSingleton { 354 public: 355 static HighResNowSingleton* GetInstance() { 356 return Singleton<HighResNowSingleton>::get(); 357 } 358 359 bool IsUsingHighResClock() { 360 return ticks_per_second_ != 0.0; 361 } 362 363 void DisableHighResClock() { 364 ticks_per_second_ = 0.0; 365 } 366 367 TimeDelta Now() { 368 if (IsUsingHighResClock()) 369 return TimeDelta::FromMicroseconds(UnreliableNow()); 370 371 // Just fallback to the slower clock. 372 return RolloverProtectedNow(); 373 } 374 375 int64 GetQPCDriftMicroseconds() { 376 if (!IsUsingHighResClock()) 377 return 0; 378 return abs((UnreliableNow() - ReliableNow()) - skew_); 379 } 380 381 int64 QPCValueToMicroseconds(LONGLONG qpc_value) { 382 if (!ticks_per_second_) 383 return 0; 384 385 // Intentionally calculate microseconds in a round about manner to avoid 386 // overflow and precision issues. Think twice before simplifying! 387 int64 whole_seconds = qpc_value / ticks_per_second_; 388 int64 leftover_ticks = qpc_value % ticks_per_second_; 389 int64 microseconds = (whole_seconds * Time::kMicrosecondsPerSecond) + 390 ((leftover_ticks * Time::kMicrosecondsPerSecond) / 391 ticks_per_second_); 392 return microseconds; 393 } 394 395 private: 396 HighResNowSingleton() 397 : ticks_per_second_(0), 398 skew_(0) { 399 InitializeClock(); 400 401 // On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is 402 // unreliable. Fallback to low-res clock. 403 base::CPU cpu; 404 if (cpu.vendor_name() == "AuthenticAMD" && cpu.family() == 15) 405 DisableHighResClock(); 406 } 407 408 // Synchronize the QPC clock with GetSystemTimeAsFileTime. 409 void InitializeClock() { 410 LARGE_INTEGER ticks_per_sec = {0}; 411 if (!QueryPerformanceFrequency(&ticks_per_sec)) 412 return; // Broken, we don't guarantee this function works. 413 ticks_per_second_ = ticks_per_sec.QuadPart; 414 415 skew_ = UnreliableNow() - ReliableNow(); 416 } 417 418 // Get the number of microseconds since boot in an unreliable fashion. 419 int64 UnreliableNow() { 420 LARGE_INTEGER now; 421 QueryPerformanceCounter(&now); 422 return QPCValueToMicroseconds(now.QuadPart); 423 } 424 425 // Get the number of microseconds since boot in a reliable fashion. 426 int64 ReliableNow() { 427 return RolloverProtectedNow().InMicroseconds(); 428 } 429 430 int64 ticks_per_second_; // 0 indicates QPF failed and we're broken. 431 int64 skew_; // Skew between lo-res and hi-res clocks (for debugging). 432 433 friend struct DefaultSingletonTraits<HighResNowSingleton>; 434}; 435 436} // namespace 437 438// static 439TimeTicks::TickFunctionType TimeTicks::SetMockTickFunction( 440 TickFunctionType ticker) { 441 base::AutoLock locked(rollover_lock); 442 TickFunctionType old = tick_function; 443 tick_function = ticker; 444 rollover_ms = 0; 445 last_seen_now = 0; 446 return old; 447} 448 449// static 450TimeTicks TimeTicks::Now() { 451 return TimeTicks() + RolloverProtectedNow(); 452} 453 454// static 455TimeTicks TimeTicks::HighResNow() { 456 return TimeTicks() + HighResNowSingleton::GetInstance()->Now(); 457} 458 459// static 460TimeTicks TimeTicks::ThreadNow() { 461 NOTREACHED(); 462 return TimeTicks(); 463} 464 465// static 466TimeTicks TimeTicks::NowFromSystemTraceTime() { 467 return HighResNow(); 468} 469 470// static 471int64 TimeTicks::GetQPCDriftMicroseconds() { 472 return HighResNowSingleton::GetInstance()->GetQPCDriftMicroseconds(); 473} 474 475// static 476TimeTicks TimeTicks::FromQPCValue(LONGLONG qpc_value) { 477 return TimeTicks( 478 HighResNowSingleton::GetInstance()->QPCValueToMicroseconds(qpc_value)); 479} 480 481// static 482bool TimeTicks::IsHighResClockWorking() { 483 return HighResNowSingleton::GetInstance()->IsUsingHighResClock(); 484} 485 486// TimeDelta ------------------------------------------------------------------ 487 488// static 489TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) { 490 return TimeDelta( 491 HighResNowSingleton::GetInstance()->QPCValueToMicroseconds(qpc_value)); 492} 493