[Windows] One TimeTicks clock: efficient/reliable high-res, with low-res fallback.

base/time/time.h

 // 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.
 
 // Time represents an absolute point in coordinated universal time (UTC),
 // internally represented as microseconds (s/1,000,000) since the Windows epoch
 // (1601-01-01 00:00:00 UTC) (See http://crbug.com/14734).  System-dependent
 // clock interface routines are defined in time_PLATFORM.cc.
 //
 // TimeDelta represents a duration of time, internally represented in
@@ skipping 11 matching lines @@
 //
 // Definitions of operator<< are provided to make these types work with
 // DCHECK_EQ() and other log macros. For human-readable formatting, see
 // "base/i18n/time_formatting.h".
 
 #ifndef BASE_TIME_TIME_H_
 #define BASE_TIME_TIME_H_
 
 #include <time.h>
 
+#include <cstdlib>
 #include <iosfwd>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
 // Avoid Mac system header macro leak.
 #undef TYPE_BOOL
@@ skipping 51 matching lines @@
   static TimeDelta Max();
 
   // Returns the internal numeric value of the TimeDelta object. Please don't
   // use this and do arithmetic on it, as it is more error prone than using the
   // provided operators.
   // For serializing, use FromInternalValue to reconstitute.
   int64 ToInternalValue() const {
     return delta_;
   }
 
+  // Returns true if this TimeDelta is negative.
+  bool is_negative() const {

[brianderson, 2015/01/07 00:53:43]

This is not used and appears unrelated. If the intention is to make calling code
more readable, maybe make a separate patch?

[miu, 2015/01/07 05:22:45]

Ah.  Yes, it was used in an earlier iteration of this change (before magnitude()
used std::abs()).

I'll remove for this change, and follow-up with a clean-up change since this
functionality is being used all over the place (especially in media code):

  $ git grep ' < base::TimeDelta()' | wc -l
  29

+    return delta_ < 0;
+  }
+
+  // Returns the magnitude (absolute value) of this TimeDelta.
+  TimeDelta magnitude() const {

[brianderson, 2015/01/07 00:53:43]

This is only used for testing. Do you plan to use this in production code too?

[miu, 2015/01/07 05:22:45]

Yes.  I've personally written a lot of code in src/media that would really
benefit from having this.  Like is_negative(), I'll follow up with a clean-up
change.

+    return TimeDelta(std::abs(delta_));
+  }
+
   // Returns true if the time delta is the maximum time delta.
   bool is_max() const {
     return delta_ == std::numeric_limits<int64>::max();
   }
 
 #if defined(OS_POSIX)
   struct timespec ToTimeSpec() const;
 #endif
 
   // Returns the time delta in some unit. The F versions return a floating
@@ skipping 468 matching lines @@
 #if defined(OS_LINUX)
   // Force definition of the system trace clock; it is a chromeos-only api
   // at the moment and surfacing it in the right place requires mucking
   // with glibc et al.
   static const clockid_t kClockSystemTrace = 11;
 #endif
 
   TimeTicks() : ticks_(0) {
   }
 
-  // Platform-dependent tick count representing "right now."
-  // The resolution of this clock is ~1-15ms.  Resolution varies depending
-  // on hardware/operating system configuration.
+  // Platform-dependent tick count representing "right now." When
+  // IsHighResolution() returns false, the resolution of the clock could be
+  // as coarse as ~15.6ms. Otherwise, the resolution should be no worse than one
+  // microsecond.
   static TimeTicks Now();
 
-  // Returns a platform-dependent high-resolution tick count. Implementation
-  // is hardware dependent and may or may not return sub-millisecond
-  // resolution.  THIS CALL IS GENERALLY MUCH MORE EXPENSIVE THAN Now() AND
-  // SHOULD ONLY BE USED WHEN IT IS REALLY NEEDED.
-  static TimeTicks HighResNow();
+  // DEPRECATED
+  // TODO(miu): Remove this function, and all callpoints should call Now().
+  static TimeTicks HighResNow() { return TimeTicks::Now(); }
 
-  static bool IsHighResNowFastAndReliable();
+  // Returns true if the high resolution clock is working on this system and
+  // Now() will return high resolution values. Note that, on systems where the
+  // high resolution clock works but is deemed inefficient, the low resolution
+  // clock will be used instead.
+  static bool IsHighResolution();
+
+  // DEPRECATED
+  // TODO(miu): Remove this function, and all callpoints should call
+  // IsHighResolution().
+  static bool IsHighResNowFastAndReliable() { return IsHighResolution(); }
 
   // Returns true if ThreadNow() is supported on this system.
   static bool IsThreadNowSupported() {
 #if (defined(_POSIX_THREAD_CPUTIME) && (_POSIX_THREAD_CPUTIME >= 0)) || \
     (defined(OS_MACOSX) && !defined(OS_IOS)) || defined(OS_ANDROID)
     return true;
 #else
     return false;
 #endif
   }
 
   // Returns thread-specific CPU-time on systems that support this feature.
   // Needs to be guarded with a call to IsThreadNowSupported(). Use this timer
   // to (approximately) measure how much time the calling thread spent doing
   // actual work vs. being de-scheduled. May return bogus results if the thread
   // migrates to another CPU between two calls.
+  //
+  // WARNING: The returned value might NOT have the same origin as Now(). Do not
+  // perform math with TimeTicks values returned by Now() and expect meaningful
+  // results.
+  // TODO(miu): Since the timeline of these values is different, the values
+  // should be of a different type.
   static TimeTicks ThreadNow();
 
-  // Returns the current system trace time or, if none is defined, the current
-  // high-res time (i.e. HighResNow()). On systems where a global trace clock
-  // is defined, timestamping TraceEvents's with this value guarantees
-  // synchronization between events collected inside chrome and events
-  // collected outside (e.g. kernel, X server).
+  // Returns the current system trace time or, if not available on this
+  // platform, a high-resolution time value; or a low-resolution time value if
+  // neither are avalable. On systems where a global trace clock is defined,
+  // timestamping TraceEvents's with this value guarantees synchronization
+  // between events collected inside chrome and events collected outside
+  // (e.g. kernel, X server).
+  //
+  // WARNING: The returned value might NOT have the same origin as Now(). Do not
+  // perform math with TimeTicks values returned by Now() and expect meaningful
+  // results.
+  // TODO(miu): Since the timeline of these values is different, the values
+  // should be of a different type.
   static TimeTicks NowFromSystemTraceTime();
 
 #if defined(OS_WIN)
-  // Get the absolute value of QPC time drift. For testing.
-  static int64 GetQPCDriftMicroseconds();
-
+  // Translates an absolute QPC timestamp into a TimeTicks value. The returned
+  // value has the same origin as Now(). Do NOT attempt to use this if
+  // IsHighResolution() returns false.
   static TimeTicks FromQPCValue(LONGLONG qpc_value);
-
-  // Returns true if the high resolution clock is working on this system.
-  // This is only for testing.
-  static bool IsHighResClockWorking();
 #endif
 
   // Returns true if this object has not been initialized.
   bool is_null() const {
     return ticks_ == 0;
   }
 
   // Converts an integer value representing TimeTicks to a class. This is used
   // when deserializing a |TimeTicks| structure, using a value known to be
   // compatible. It is not provided as a constructor because the integer type
@@ skipping 84 matching lines @@
 inline TimeTicks TimeDelta::operator+(TimeTicks t) const {
   return TimeTicks(t.ticks_ + delta_);
 }
 
 // For logging use only.
 BASE_EXPORT std::ostream& operator<<(std::ostream& os, TimeTicks time_ticks);
 
 }  // namespace base
 
 #endif  // BASE_TIME_TIME_H_