Several Tick counter improvements.

webrtc/system_wrappers/source/tick_util.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/system_wrappers/include/tick_util.h"
 
 #include <assert.h>
 
 namespace webrtc {
 
 bool TickTime::use_fake_clock_ = false;
 int64_t TickTime::fake_ticks_ = 0;
 
+int64_t TickTime::MillisecondTimestamp() {
+  return TicksToMilliseconds(TickTime::Now().Ticks());
+}
+
+int64_t TickTime::MicrosecondTimestamp() {
+  return TicksToMicroseconds(TickTime::Now().Ticks());
+}
+
+int64_t TickTime::MillisecondsToTicks(const int64_t ms) {
+#if _WIN32
+  return ms;
+#elif defined(WEBRTC_LINUX)
+  return ms * 1000000LL;
+#elif defined(WEBRTC_MAC)
+  // TODO(pbos): Fix unsafe use of static locals.
+  static double timebase_from_millisecond_fract = 0.0;
+  if (timebase_from_millisecond_fract == 0.0) {
+    mach_timebase_info_data_t timebase;
+    (void)mach_timebase_info(&timebase);
+    timebase_from_millisecond_fract = (timebase.denom * 1e6) / timebase.numer;
+  }
+  return ms * timebase_from_millisecond_fract;
+#else
+  return ms * 1000LL;
+#endif
+}
+
+int64_t TickTime::TicksToMilliseconds(const int64_t ticks) {
+#if _WIN32
+  return ticks;
+#elif defined(WEBRTC_LINUX)
+  return ticks / 1000000LL;
+#elif defined(WEBRTC_MAC)
+  // TODO(pbos): Fix unsafe use of static locals.
+  static double timebase_microsecond_fract = 0.0;
+  if (timebase_microsecond_fract == 0.0) {
+    mach_timebase_info_data_t timebase;
+    (void)mach_timebase_info(&timebase);
+    timebase_microsecond_fract = timebase.numer / (timebase.denom * 1e6);
+  }
+  return ticks * timebase_microsecond_fract;
+#else
+  return ticks;
+#endif
+}
+
+int64_t TickTime::TicksToMicroseconds(const int64_t ticks) {
+#if _WIN32
+  return ticks * 1000LL;
+#elif defined(WEBRTC_LINUX)
+  return ticks / 1000LL;
+#elif defined(WEBRTC_MAC)
+  // TODO(pbos): Fix unsafe use of static locals.
+  static double timebase_microsecond_fract = 0.0;
+  if (timebase_microsecond_fract == 0.0) {
+    mach_timebase_info_data_t timebase;
+    (void)mach_timebase_info(&timebase);
+    timebase_microsecond_fract = timebase.numer / (timebase.denom * 1e3);
+  }
+  return ticks * timebase_microsecond_fract;
+#else
+  return ticks;
+#endif
+}
+
 void TickTime::UseFakeClock(int64_t start_millisecond) {
   use_fake_clock_ = true;
   fake_ticks_ = MillisecondsToTicks(start_millisecond);
 }
 
 void TickTime::AdvanceFakeClock(int64_t milliseconds) {
   assert(use_fake_clock_);
   fake_ticks_ += MillisecondsToTicks(milliseconds);
 }
 
+// Gets the native system tick count. The actual unit, resolution, and epoch
+// varies by platform:
+// Windows: Milliseconds of uptime with rollover count in the upper 32-bits.
+// Linux/Android: Nanoseconds since the Unix epoch.
+// Mach (Mac/iOS): "absolute" time since first call.
+// Unknown POSIX: Microseconds since the Unix epoch.
 int64_t TickTime::QueryOsForTicks() {
-  TickTime result;
 #if _WIN32
-  // TODO(wu): Remove QueryPerformanceCounter implementation.
-#ifdef USE_QUERY_PERFORMANCE_COUNTER
-  // QueryPerformanceCounter returns the value from the TSC which is
-  // incremented at the CPU frequency. The algorithm used requires
-  // the CPU frequency to be constant. Technology like speed stepping
-  // which has variable CPU frequency will therefore yield unpredictable,
-  // incorrect time estimations.
-  LARGE_INTEGER qpcnt;
-  QueryPerformanceCounter(&qpcnt);
-  result.ticks_ = qpcnt.QuadPart;
-#else
   static volatile LONG last_time_get_time = 0;
   static volatile int64_t num_wrap_time_get_time = 0;
   volatile LONG* last_time_get_time_ptr = &last_time_get_time;
   DWORD now = timeGetTime();
   // Atomically update the last gotten time
   DWORD old = InterlockedExchange(last_time_get_time_ptr, now);
   if (now < old) {
     // If now is earlier than old, there may have been a race between
     // threads.
     // 0x0fffffff ~3.1 days, the code will not take that long to execute
     // so it must have been a wrap around.
     if (old > 0xf0000000 && now < 0x0fffffff) {
+      // TODO(pbos): Fix unsafe use of static locals.
       num_wrap_time_get_time++;
     }
   }
-  result.ticks_ = now + (num_wrap_time_get_time << 32);
-#endif
+  return now + (num_wrap_time_get_time << 32);
 #elif defined(WEBRTC_LINUX)
   struct timespec ts;
   // TODO(wu): Remove CLOCK_REALTIME implementation.
 #ifdef WEBRTC_CLOCK_TYPE_REALTIME
   clock_gettime(CLOCK_REALTIME, &ts);
 #else
   clock_gettime(CLOCK_MONOTONIC, &ts);
 #endif
-  result.ticks_ = 1000000000LL * static_cast<int64_t>(ts.tv_sec) +
-      static_cast<int64_t>(ts.tv_nsec);
+  return 1000000000LL * ts.tv_sec + ts.tv_nsec;
 #elif defined(WEBRTC_MAC)
-  static mach_timebase_info_data_t timebase;
-  if (timebase.denom == 0) {
-    // Get the timebase if this is the first time we run.
-    // Recommended by Apple's QA1398.
-    kern_return_t retval = mach_timebase_info(&timebase);
-    if (retval != KERN_SUCCESS) {
-      // TODO(wu): Implement RTC_CHECK for all the platforms. Then replace this
-      // with a RTC_CHECK_EQ(retval, KERN_SUCCESS);
-#ifndef WEBRTC_IOS
-      asm("int3");
-#else
-      __builtin_trap();
-#endif  // WEBRTC_IOS
-    }
+  // Return absolute time as an offset from the first call to this function, so
+  // that we can do floating-point (double) operations on it without losing
+  // precision. This holds true until the elapsed time is ~11 days,
+  // at which point we'll start to lose some precision, though not enough to
+  // matter for millisecond accuracy for another couple years after that.
+  // TODO(pbos): Fix unsafe use of static locals.
+  static uint64_t timebase_start = 0;
+  if (timebase_start == 0) {
+    timebase_start = mach_absolute_time();
   }
-  // Use timebase to convert absolute time tick units into nanoseconds.
-  result.ticks_ = mach_absolute_time() * timebase.numer / timebase.denom;
+  return mach_absolute_time() - timebase_start;
 #else
   struct timeval tv;
   gettimeofday(&tv, NULL);
-  result.ticks_ = 1000000LL * static_cast<int64_t>(tv.tv_sec) +
-      static_cast<int64_t>(tv.tv_usec);
+  return 1000000LL * tv.tv_sec + tv.tv_usec;
 #endif
-  return result.ticks_;
 }
 
 }  // namespace webrtc