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 49 using base::Time; 50 using base::TimeDelta; 51 using base::TimeTicks; 52 53 namespace { 54 55 // From MSDN, FILETIME "Contains a 64-bit value representing the number of 56 // 100-nanosecond intervals since January 1, 1601 (UTC)." 57 int64 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 64 void 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 73 int64 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. 80 const int kMaxMillisecondsToAvoidDrift = 60 * Time::kMillisecondsPerSecond; 81 82 int64 initial_time = 0; 83 TimeTicks initial_ticks; 84 85 void 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 99 const int64 Time::kTimeTToMicrosecondsOffset = GG_INT64_C(11644473600000000); 100 101 bool Time::high_resolution_timer_enabled_ = false; 102 int Time::high_resolution_timer_activated_ = 0; 103 104 // static 105 Time 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 136 Time Time::NowFromSystemTime() { 137 // Force resync. 138 InitializeClock(); 139 return Time(initial_time); 140 } 141 142 // static 143 Time 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 152 FILETIME 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 167 void 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 179 bool 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 198 bool 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 209 Time 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 240 void 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 ------------------------------------------------------------------ 284 namespace { 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. 289 DWORD timeGetTimeWrapper() { 290 return timeGetTime(); 291 } 292 293 DWORD (*tick_function)(void) = &timeGetTimeWrapper; 294 295 // Accumulation of time lost due to rollover (in milliseconds). 296 int64 rollover_ms = 0; 297 298 // The last timeGetTime value we saw, to detect rollover. 299 DWORD 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. 307 base::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. 314 TimeDelta 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. 353 class 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 439 TimeTicks::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 450 TimeTicks TimeTicks::Now() { 451 return TimeTicks() + RolloverProtectedNow(); 452 } 453 454 // static 455 TimeTicks TimeTicks::HighResNow() { 456 return TimeTicks() + HighResNowSingleton::GetInstance()->Now(); 457 } 458 459 // static 460 TimeTicks TimeTicks::ThreadNow() { 461 NOTREACHED(); 462 return TimeTicks(); 463 } 464 465 // static 466 TimeTicks TimeTicks::NowFromSystemTraceTime() { 467 return HighResNow(); 468 } 469 470 // static 471 int64 TimeTicks::GetQPCDriftMicroseconds() { 472 return HighResNowSingleton::GetInstance()->GetQPCDriftMicroseconds(); 473 } 474 475 // static 476 TimeTicks TimeTicks::FromQPCValue(LONGLONG qpc_value) { 477 return TimeTicks( 478 HighResNowSingleton::GetInstance()->QPCValueToMicroseconds(qpc_value)); 479 } 480 481 // static 482 bool TimeTicks::IsHighResClockWorking() { 483 return HighResNowSingleton::GetInstance()->IsUsingHighResClock(); 484 } 485 486 // TimeDelta ------------------------------------------------------------------ 487 488 // static 489 TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) { 490 return TimeDelta( 491 HighResNowSingleton::GetInstance()->QPCValueToMicroseconds(qpc_value)); 492 } 493