Use rtc::time for all your timing needs!

webrtc/base/timeutils.cc

 /*
  *  Copyright 2004 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.
  */
 
@@ skipping 28 matching lines @@
 #if 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.
     if (mach_timebase_info(&timebase) != KERN_SUCCESS) {
       RTC_DCHECK(false);
     }
   }
   // Use timebase to convert absolute time tick units into nanoseconds.
   ticks = mach_absolute_time() * timebase.numer / timebase.denom;

[tommi, 2016/01/26 23:23:46]

since we're here - can we do something about this so that it behaves more like
the implementations on other operating systems?  At the moment it always returns
a very low value on first call, regardless of when it's called.

It also looks like we're using static initialization but could use atomics
instead.

No action required in this CL but curious to hear what you think.  I realized
this btw when I saw that we're using the return value from this function as a
seed to Random() (via the Clock class).

[sprang_webrtc, 2016/01/27 08:48:47]

Are your sure "low initial value" applies here? The root cause for doing this
refactoring is that the mac implementation of TickTime::QueryOsForTicks()
behaves differently from this one; it used a static variable as offset and
initialized it so that the first call would always return 0...

Agreed we should do something about static initialization here.

[noahric, 2016/04/05 04:48:28]

FYI, the reason it was different was: https://codereview.webrtc.org/1452843003

Which was for a 2% overall cpu usage reduction on iOS.

The other issues are definitely real (it purposefully picked low values so the
double would maintain precision for awhile, but that meant things that used raw
tick values for random seeding were broken, as tommi discovered), so I wouldn't
just put it back in without fixing that. But it'd be sad to lose the 2% cpu
improvement for nothing. Not too many other things are so simple to fix :)

 #elif defined(WEBRTC_POSIX)
   struct timespec ts;
   // TODO: Do we need to handle the case when CLOCK_MONOTONIC
   // is not supported?
   clock_gettime(CLOCK_MONOTONIC, &ts);
   ticks = kNumNanosecsPerSec * static_cast<int64_t>(ts.tv_sec) +
           static_cast<int64_t>(ts.tv_nsec);
 #elif defined(WEBRTC_WIN)
   static volatile LONG last_timegettime = 0;
   static volatile int64_t num_wrap_timegettime = 0;
   volatile LONG* last_timegettime_ptr = &last_timegettime;
   DWORD now = timeGetTime();
   // Atomically update the last gotten time
   DWORD old = InterlockedExchange(last_timegettime_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) {
       num_wrap_timegettime++;
     }
   }
   ticks = now + (num_wrap_timegettime << 32);
   // TODO: Calculate with nanosecond precision.  Otherwise, we're just
   // wasting a multiply and divide when doing Time() on Windows.
   ticks = ticks * kNumNanosecsPerMillisec;
+#else

[pbos-webrtc, 2016/01/26 15:00:22]

#else #error? Do we ever build with none of these set?

[sprang_webrtc, 2016/01/27 08:48:47]

Agreed it makes more sense to have #error here instead. 

+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  ticks =
+      (kNumNanosecsPerSec * tv.tv_sec) + (kNumNanosecsPerMicrosec * tv.tv_usec);
 #endif
   return ticks;
 }
 
 uint32_t Time() {
   return static_cast<uint32_t>(TimeNanos() / kNumNanosecsPerMillisec);
 }
 
 uint64_t TimeMicros() {
   return static_cast<uint64_t>(TimeNanos() / kNumNanosecsPerMicrosec);
@@ skipping 155 matching lines @@
   if (expiry_in_leap_year && month <= 2 - 1) // |month| is zero based.
     day -= 1;
 
   // Combine all variables into seconds from 1970-01-01 00:00 (except |month|
   // which was accumulated into |day| above).
   return (((static_cast<int64_t>
             (year - 1970) * 365 + day) * 24 + hour) * 60 + min) * 60 + sec;
 }
 
 } // namespace rtc