1 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <windows.h>
6 #include <mmsystem.h>
7 #include <process.h>
8
9 #include "base/threading/platform_thread.h"
10 #include "base/time.h"
11 #include "testing/gtest/include/gtest/gtest.h"
12
13 using base::Time;
14 using base::TimeDelta;
15 using base::TimeTicks;
16
17 namespace {
18
19 class MockTimeTicks : public TimeTicks {
20 public:
Ticker()21 static DWORD Ticker() {
22 return static_cast<int>(InterlockedIncrement(&ticker_));
23 }
24
InstallTicker()25 static void InstallTicker() {
26 old_tick_function_ = SetMockTickFunction(&Ticker);
27 ticker_ = -5;
28 }
29
UninstallTicker()30 static void UninstallTicker() {
31 SetMockTickFunction(old_tick_function_);
32 }
33
34 private:
35 static volatile LONG ticker_;
36 static TickFunctionType old_tick_function_;
37 };
38
39 volatile LONG MockTimeTicks::ticker_;
40 MockTimeTicks::TickFunctionType MockTimeTicks::old_tick_function_;
41
42 HANDLE g_rollover_test_start;
43
RolloverTestThreadMain(void * param)44 unsigned __stdcall RolloverTestThreadMain(void* param) {
45 int64 counter = reinterpret_cast<int64>(param);
46 DWORD rv = WaitForSingleObject(g_rollover_test_start, INFINITE);
47 EXPECT_EQ(rv, WAIT_OBJECT_0);
48
49 TimeTicks last = TimeTicks::Now();
50 for (int index = 0; index < counter; index++) {
51 TimeTicks now = TimeTicks::Now();
52 int64 milliseconds = (now - last).InMilliseconds();
53 // This is a tight loop; we could have looped faster than our
54 // measurements, so the time might be 0 millis.
55 EXPECT_GE(milliseconds, 0);
56 EXPECT_LT(milliseconds, 250);
57 last = now;
58 }
59 return 0;
60 }
61
62 } // namespace
63
TEST(TimeTicks,WinRollover)64 TEST(TimeTicks, WinRollover) {
65 // The internal counter rolls over at ~49days. We'll use a mock
66 // timer to test this case.
67 // Basic test algorithm:
68 // 1) Set clock to rollover - N
69 // 2) Create N threads
70 // 3) Start the threads
71 // 4) Each thread loops through TimeTicks() N times
72 // 5) Each thread verifies integrity of result.
73
74 const int kThreads = 8;
75 // Use int64 so we can cast into a void* without a compiler warning.
76 const int64 kChecks = 10;
77
78 // It takes a lot of iterations to reproduce the bug!
79 // (See bug 1081395)
80 for (int loop = 0; loop < 4096; loop++) {
81 // Setup
82 MockTimeTicks::InstallTicker();
83 g_rollover_test_start = CreateEvent(0, TRUE, FALSE, 0);
84 HANDLE threads[kThreads];
85
86 for (int index = 0; index < kThreads; index++) {
87 void* argument = reinterpret_cast<void*>(kChecks);
88 unsigned thread_id;
89 threads[index] = reinterpret_cast<HANDLE>(
90 _beginthreadex(NULL, 0, RolloverTestThreadMain, argument, 0,
91 &thread_id));
92 EXPECT_NE((HANDLE)NULL, threads[index]);
93 }
94
95 // Start!
96 SetEvent(g_rollover_test_start);
97
98 // Wait for threads to finish
99 for (int index = 0; index < kThreads; index++) {
100 DWORD rv = WaitForSingleObject(threads[index], INFINITE);
101 EXPECT_EQ(rv, WAIT_OBJECT_0);
102 }
103
104 CloseHandle(g_rollover_test_start);
105
106 // Teardown
107 MockTimeTicks::UninstallTicker();
108 }
109 }
110
TEST(TimeTicks,SubMillisecondTimers)111 TEST(TimeTicks, SubMillisecondTimers) {
112 // HighResNow doesn't work on some systems. Since the product still works
113 // even if it doesn't work, it makes this entire test questionable.
114 if (!TimeTicks::IsHighResClockWorking())
115 return;
116
117 const int kRetries = 1000;
118 bool saw_submillisecond_timer = false;
119
120 // Run kRetries attempts to see a sub-millisecond timer.
121 for (int index = 0; index < 1000; index++) {
122 TimeTicks last_time = TimeTicks::HighResNow();
123 TimeDelta delta;
124 // Spin until the clock has detected a change.
125 do {
126 delta = TimeTicks::HighResNow() - last_time;
127 } while (delta.InMicroseconds() == 0);
128 if (delta.InMicroseconds() < 1000) {
129 saw_submillisecond_timer = true;
130 break;
131 }
132 }
133 EXPECT_TRUE(saw_submillisecond_timer);
134 }
135
TEST(TimeTicks,TimeGetTimeCaps)136 TEST(TimeTicks, TimeGetTimeCaps) {
137 // Test some basic assumptions that we expect about how timeGetDevCaps works.
138
139 TIMECAPS caps;
140 MMRESULT status = timeGetDevCaps(&caps, sizeof(caps));
141 EXPECT_EQ(TIMERR_NOERROR, status);
142 if (status != TIMERR_NOERROR) {
143 printf("Could not get timeGetDevCaps\n");
144 return;
145 }
146
147 EXPECT_GE(static_cast<int>(caps.wPeriodMin), 1);
148 EXPECT_GT(static_cast<int>(caps.wPeriodMax), 1);
149 EXPECT_GE(static_cast<int>(caps.wPeriodMin), 1);
150 EXPECT_GT(static_cast<int>(caps.wPeriodMax), 1);
151 printf("timeGetTime range is %d to %dms\n", caps.wPeriodMin,
152 caps.wPeriodMax);
153 }
154
TEST(TimeTicks,QueryPerformanceFrequency)155 TEST(TimeTicks, QueryPerformanceFrequency) {
156 // Test some basic assumptions that we expect about QPC.
157
158 LARGE_INTEGER frequency;
159 BOOL rv = QueryPerformanceFrequency(&frequency);
160 EXPECT_EQ(TRUE, rv);
161 EXPECT_GT(frequency.QuadPart, 1000000); // Expect at least 1MHz
162 printf("QueryPerformanceFrequency is %5.2fMHz\n",
163 frequency.QuadPart / 1000000.0);
164 }
165
TEST(TimeTicks,TimerPerformance)166 TEST(TimeTicks, TimerPerformance) {
167 // Verify that various timer mechanisms can always complete quickly.
168 // Note: This is a somewhat arbitrary test.
169 const int kLoops = 10000;
170 // Due to the fact that these run on bbots, which are horribly slow,
171 // we can't really make any guarantees about minimum runtime.
172 // Really, we want these to finish in ~10ms, and that is generous.
173 const int kMaxTime = 35; // Maximum acceptible milliseconds for test.
174
175 typedef TimeTicks (*TestFunc)();
176 struct TestCase {
177 TestFunc func;
178 char *description;
179 };
180 // Cheating a bit here: assumes sizeof(TimeTicks) == sizeof(Time)
181 // in order to create a single test case list.
182 COMPILE_ASSERT(sizeof(TimeTicks) == sizeof(Time),
183 test_only_works_with_same_sizes);
184 TestCase cases[] = {
185 { reinterpret_cast<TestFunc>(Time::Now), "Time::Now" },
186 { TimeTicks::Now, "TimeTicks::Now" },
187 { TimeTicks::HighResNow, "TimeTicks::HighResNow" },
188 { NULL, "" }
189 };
190
191 int test_case = 0;
192 while (cases[test_case].func) {
193 TimeTicks start = TimeTicks::HighResNow();
194 for (int index = 0; index < kLoops; index++)
195 cases[test_case].func();
196 TimeTicks stop = TimeTicks::HighResNow();
197 // Turning off the check for acceptible delays. Without this check,
198 // the test really doesn't do much other than measure. But the
199 // measurements are still useful for testing timers on various platforms.
200 // The reason to remove the check is because the tests run on many
201 // buildbots, some of which are VMs. These machines can run horribly
202 // slow, and there is really no value for checking against a max timer.
203 //EXPECT_LT((stop - start).InMilliseconds(), kMaxTime);
204 printf("%s: %1.2fus per call\n", cases[test_case].description,
205 (stop - start).InMillisecondsF() * 1000 / kLoops);
206 test_case++;
207 }
208 }
209
TEST(TimeTicks,Drift)210 TEST(TimeTicks, Drift) {
211 const int kIterations = 100;
212 int64 total_drift = 0;
213
214 for (int i = 0; i < kIterations; ++i) {
215 int64 drift_microseconds = TimeTicks::GetQPCDriftMicroseconds();
216
217 // Make sure the drift never exceeds our limit.
218 EXPECT_LT(drift_microseconds, 50000);
219
220 // Sleep for a few milliseconds (note that it means 1000 microseconds).
221 // If we check the drift too frequently, it's going to increase
222 // monotonically, making our measurement less realistic.
223 base::PlatformThread::Sleep((i % 2 == 0) ? 1 : 2);
224
225 total_drift += drift_microseconds;
226 }
227
228 // Sanity check. We expect some time drift to occur, especially across
229 // the number of iterations we do. However, if the QPC is disabled, this
230 // is not measuring anything (drift is zero in that case).
231 EXPECT_LT(0, total_drift);
232
233 printf("average time drift in microseconds: %lld\n",
234 total_drift / kIterations);
235 }
236