1/*
2 * libjingle
3 * Copyright 2004--2005, Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 *  1. Redistributions of source code must retain the above copyright notice,
9 *     this list of conditions and the following disclaimer.
10 *  2. Redistributions in binary form must reproduce the above copyright notice,
11 *     this list of conditions and the following disclaimer in the documentation
12 *     and/or other materials provided with the distribution.
13 *  3. The name of the author may not be used to endorse or promote products
14 *     derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#ifdef POSIX
29#include <sys/time.h>
30#if defined(OSX) || defined(IOS)
31#include <mach/mach_time.h>
32#endif
33#endif
34
35#ifdef WIN32
36#define WIN32_LEAN_AND_MEAN
37#include <windows.h>
38#include <mmsystem.h>
39#endif
40
41#include "talk/base/common.h"
42#include "talk/base/timeutils.h"
43
44#define EFFICIENT_IMPLEMENTATION 1
45
46namespace talk_base {
47
48const uint32 LAST = 0xFFFFFFFF;
49const uint32 HALF = 0x80000000;
50
51uint64 TimeNanos() {
52  int64 ticks = 0;
53#if defined(OSX) || defined(IOS)
54  static mach_timebase_info_data_t timebase;
55  if (timebase.denom == 0) {
56    // Get the timebase if this is the first time we run.
57    // Recommended by Apple's QA1398.
58    VERIFY(KERN_SUCCESS == mach_timebase_info(&timebase));
59  }
60  // Use timebase to convert absolute time tick units into nanoseconds.
61  ticks = mach_absolute_time() * timebase.numer / timebase.denom;
62#elif defined(POSIX)
63  struct timespec ts;
64  // TODO: Do we need to handle the case when CLOCK_MONOTONIC
65  // is not supported?
66  clock_gettime(CLOCK_MONOTONIC, &ts);
67  ticks = kNumNanosecsPerSec * static_cast<int64>(ts.tv_sec) +
68      static_cast<int64>(ts.tv_nsec);
69#elif defined(WIN32)
70  static volatile LONG last_timegettime = 0;
71  static volatile int64 num_wrap_timegettime = 0;
72  volatile LONG* last_timegettime_ptr = &last_timegettime;
73  DWORD now = timeGetTime();
74  // Atomically update the last gotten time
75  DWORD old = InterlockedExchange(last_timegettime_ptr, now);
76  if (now < old) {
77    // If now is earlier than old, there may have been a race between
78    // threads.
79    // 0x0fffffff ~3.1 days, the code will not take that long to execute
80    // so it must have been a wrap around.
81    if (old > 0xf0000000 && now < 0x0fffffff) {
82      num_wrap_timegettime++;
83    }
84  }
85  ticks = now + (num_wrap_timegettime << 32);
86  // TODO: Calculate with nanosecond precision.  Otherwise, we're just
87  // wasting a multiply and divide when doing Time() on Windows.
88  ticks = ticks * kNumNanosecsPerMillisec;
89#endif
90  return ticks;
91}
92
93uint32 Time() {
94  return static_cast<uint32>(TimeNanos() / kNumNanosecsPerMillisec);
95}
96
97#if defined(WIN32)
98static const uint64 kFileTimeToUnixTimeEpochOffset = 116444736000000000ULL;
99
100struct timeval {
101  long tv_sec, tv_usec;  // NOLINT
102};
103
104// Emulate POSIX gettimeofday().
105// Based on breakpad/src/third_party/glog/src/utilities.cc
106static int gettimeofday(struct timeval *tv, void *tz) {
107  // FILETIME is measured in tens of microseconds since 1601-01-01 UTC.
108  FILETIME ft;
109  GetSystemTimeAsFileTime(&ft);
110
111  LARGE_INTEGER li;
112  li.LowPart = ft.dwLowDateTime;
113  li.HighPart = ft.dwHighDateTime;
114
115  // Convert to seconds and microseconds since Unix time Epoch.
116  int64 micros = (li.QuadPart - kFileTimeToUnixTimeEpochOffset) / 10;
117  tv->tv_sec = static_cast<long>(micros / kNumMicrosecsPerSec);  // NOLINT
118  tv->tv_usec = static_cast<long>(micros % kNumMicrosecsPerSec); // NOLINT
119
120  return 0;
121}
122
123// Emulate POSIX gmtime_r().
124static struct tm *gmtime_r(const time_t *timep, struct tm *result) {
125  // On Windows, gmtime is thread safe.
126  struct tm *tm = gmtime(timep);  // NOLINT
127  if (tm == NULL) {
128    return NULL;
129  }
130  *result = *tm;
131  return result;
132}
133#endif  // WIN32
134
135void CurrentTmTime(struct tm *tm, int *microseconds) {
136  struct timeval timeval;
137  if (gettimeofday(&timeval, NULL) < 0) {
138    // Incredibly unlikely code path.
139    timeval.tv_sec = timeval.tv_usec = 0;
140  }
141  time_t secs = timeval.tv_sec;
142  gmtime_r(&secs, tm);
143  *microseconds = timeval.tv_usec;
144}
145
146uint32 TimeAfter(int32 elapsed) {
147  ASSERT(elapsed >= 0);
148  ASSERT(static_cast<uint32>(elapsed) < HALF);
149  return Time() + elapsed;
150}
151
152bool TimeIsBetween(uint32 earlier, uint32 middle, uint32 later) {
153  if (earlier <= later) {
154    return ((earlier <= middle) && (middle <= later));
155  } else {
156    return !((later < middle) && (middle < earlier));
157  }
158}
159
160bool TimeIsLaterOrEqual(uint32 earlier, uint32 later) {
161#if EFFICIENT_IMPLEMENTATION
162  int32 diff = later - earlier;
163  return (diff >= 0 && static_cast<uint32>(diff) < HALF);
164#else
165  const bool later_or_equal = TimeIsBetween(earlier, later, earlier + HALF);
166  return later_or_equal;
167#endif
168}
169
170bool TimeIsLater(uint32 earlier, uint32 later) {
171#if EFFICIENT_IMPLEMENTATION
172  int32 diff = later - earlier;
173  return (diff > 0 && static_cast<uint32>(diff) < HALF);
174#else
175  const bool earlier_or_equal = TimeIsBetween(later, earlier, later + HALF);
176  return !earlier_or_equal;
177#endif
178}
179
180int32 TimeDiff(uint32 later, uint32 earlier) {
181#if EFFICIENT_IMPLEMENTATION
182  return later - earlier;
183#else
184  const bool later_or_equal = TimeIsBetween(earlier, later, earlier + HALF);
185  if (later_or_equal) {
186    if (earlier <= later) {
187      return static_cast<long>(later - earlier);
188    } else {
189      return static_cast<long>(later + (LAST - earlier) + 1);
190    }
191  } else {
192    if (later <= earlier) {
193      return -static_cast<long>(earlier - later);
194    } else {
195      return -static_cast<long>(earlier + (LAST - later) + 1);
196    }
197  }
198#endif
199}
200
201} // namespace talk_base
202