time: Add a static TimeTicks method that returns the underlying clock

base/time/time_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 // Windows Timer Primer
 //
 // A good article:  http://www.ddj.com/windows/184416651
 // A good mozilla bug:  http://bugzilla.mozilla.org/show_bug.cgi?id=363258
 //
@@ skipping 68 matching lines @@
 const int kMaxMillisecondsToAvoidDrift = 60 * Time::kMillisecondsPerSecond;
 
 int64_t initial_time = 0;
 TimeTicks initial_ticks;
 
 void InitializeClock() {
   initial_ticks = TimeTicks::Now();
   initial_time = CurrentWallclockMicroseconds();
 }
 
+const char* kTimeGetTimeClockId = "WIN_ROLLOVER_PROTECTED_TIME_GET_TIME_MICROS";
+const char* kQPCClockId = "WIN_QPC_MICROS";
+
 // The two values that ActivateHighResolutionTimer uses to set the systemwide
 // timer interrupt frequency on Windows. It controls how precise timers are
 // but also has a big impact on battery life.
 const int kMinTimerIntervalHighResMs = 1;
 const int kMinTimerIntervalLowResMs = 4;
 // Track if kMinTimerIntervalHighResMs or kMinTimerIntervalLowResMs is active.
 bool g_high_res_timer_enabled = false;
 // How many times the high resolution timer has been called.
 uint32_t g_high_res_timer_count = 0;
 // The lock to control access to the above two variables.
@@ skipping 297 matching lines @@
 // this timer; and also other Windows applications can alter it, affecting this
 // one.
 
 using NowFunction = TimeDelta (*)(void);
 
 TimeDelta InitialNowFunction();
 
 // See "threading notes" in InitializeNowFunctionPointer() for details on how
 // concurrent reads/writes to these globals has been made safe.
 NowFunction g_now_function = &InitialNowFunction;
+const char* g_now_clock_id = "";
+
 int64_t g_qpc_ticks_per_second = 0;
 
 // As of January 2015, use of <atomic> is forbidden in Chromium code. This is
 // what std::atomic_thread_fence does on Windows on all Intel architectures when
 // the memory_order argument is anything but std::memory_order_seq_cst:
 #define ATOMIC_THREAD_FENCE(memory_order) _ReadWriteBarrier();
 
 TimeDelta QPCValueToTimeDelta(LONGLONG qpc_value) {
   // Ensure that the assignment to |g_qpc_ticks_per_second|, made in
   // InitializeNowFunctionPointer(), has happened by this point.
@@ skipping 36 matching lines @@
   //
   // If the QPC implementation is expensive and/or unreliable, TimeTicks::Now()
   // will still use the low-resolution clock. A CPU lacking a non-stop time
   // counter will cause Windows to provide an alternate QPC implementation that
   // works, but is expensive to use. Certain Athlon CPUs are known to make the
   // QPC implementation unreliable.
   //
   // Otherwise, Now uses the high-resolution QPC clock. As of 21 August 2015,
   // ~72% of users fall within this category.
   NowFunction now_function;
+  const char* now_clock_id;
   base::CPU cpu;
   if (ticks_per_sec.QuadPart <= 0 ||
       !cpu.has_non_stop_time_stamp_counter() || IsBuggyAthlon(cpu)) {
     now_function = &RolloverProtectedNow;
+    now_clock_id = kTimeGetTimeClockId;
   } else {
     now_function = &QPCNow;
+    now_clock_id = kQPCClockId;
   }
 
   // Threading note 1: In an unlikely race condition, it's possible for two or
   // more threads to enter InitializeNowFunctionPointer() in parallel. This is
   // not a problem since all threads should end up writing out the same values
   // to the global variables.
   //
   // Threading note 2: A release fence is placed here to ensure, from the
   // perspective of other threads using the function pointers, that the
   // assignment to |g_qpc_ticks_per_second| happens before the function pointers
   // are changed.
   g_qpc_ticks_per_second = ticks_per_sec.QuadPart;
   ATOMIC_THREAD_FENCE(memory_order_release);
   g_now_function = now_function;
+  g_now_clock_id = now_clock_id;

[danakj, 2016/03/26 00:40:33]

Why is this after the fence?

[charliea (OOO until 10-5), 2016/03/28 15:40:51]

I'm not sure, but if the above comment is any indicator, it looks like it has to
do with making sure g_qpc_ticks_per_second is changed before the function
pointers. Naively, I'd expect that things should be okay as long as we change
g_now_function and g_now_clock_id in the same block.

[danakj, 2016/03/28 17:53:50]

Yeah, I stared at this for a while, and AFAICT the reason is because the now
function can use g_qpc_ticks_p_s, so if the pointer is updated we want the
g_qpc.. to be updated as well.

However, the function does not use the clock id. The fence is magical, so
putting things below makes them now depend on magic. So I'd prefer this was
added above then. Maybe just above g_qpc_t_p_s?

[charliea (OOO until 10-5), 2016/03/28 21:07:36]

Done.

 }
 
 TimeDelta InitialNowFunction() {
   InitializeNowFunctionPointer();
   return g_now_function();
 }
 
 }  // namespace
 
 // static
@@ skipping 13 matching lines @@
 }
 
 // static
 bool TimeTicks::IsHighResolution() {
   if (g_now_function == &InitialNowFunction)
     InitializeNowFunctionPointer();
   return g_now_function == &QPCNow;
 }
 
 // static
+std::string TimeTicks::ClockId() {
+  if (g_now_function == &InitialNowFunction)
+    InitializeNowFunctionPointer();
+  return g_now_clock_id;
+}
+
+// static
 ThreadTicks ThreadTicks::Now() {
   DCHECK(IsSupported());
 
   // Get the number of TSC ticks used by the current thread.
   ULONG64 thread_cycle_time = 0;
   GetQueryThreadCycleTimeFunction()(::GetCurrentThread(), &thread_cycle_time);
 
   // Get the frequency of the TSC.
   double tsc_ticks_per_second = TSCTicksPerSecond();
   if (tsc_ticks_per_second == 0)
@@ skipping 82 matching lines @@
 TimeTicks TimeTicks::FromQPCValue(LONGLONG qpc_value) {
   return TimeTicks() + QPCValueToTimeDelta(qpc_value);
 }
 
 // TimeDelta ------------------------------------------------------------------
 
 // static
 TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) {
   return QPCValueToTimeDelta(qpc_value);
 }