blob: bc8fcfe91b3f90b22fa9283ab77c79893cbf1528 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
/*
* 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;
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);
}
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) {
num_wrap_time_get_time++;
}
}
result.ticks_ = now + (num_wrap_time_get_time << 32);
#endif
#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);
#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
}
}
// Use timebase to convert absolute time tick units into nanoseconds.
result.ticks_ = mach_absolute_time() * timebase.numer / timebase.denom;
#else
struct timeval tv;
gettimeofday(&tv, NULL);
result.ticks_ = 1000000LL * static_cast<int64_t>(tv.tv_sec) +
static_cast<int64_t>(tv.tv_usec);
#endif
return result.ticks_;
}
} // namespace webrtc
|
