Home | History | Annotate | Download | only in time
      1 // Copyright (c) 2012 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/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:
     21   static DWORD Ticker() {
     22     return static_cast<int>(InterlockedIncrement(&ticker_));
     23   }
     24 
     25   static void InstallTicker() {
     26     old_tick_function_ = SetMockTickFunction(&Ticker);
     27     ticker_ = -5;
     28   }
     29 
     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 
     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 
     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 
    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 
    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 
    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 
    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 
    210 TEST(TimeTicks, Drift) {
    211   // If QPC is disabled, this isn't measuring anything.
    212   if (!TimeTicks::IsHighResClockWorking())
    213     return;
    214 
    215   const int kIterations = 100;
    216   int64 total_drift = 0;
    217 
    218   for (int i = 0; i < kIterations; ++i) {
    219     int64 drift_microseconds = TimeTicks::GetQPCDriftMicroseconds();
    220 
    221     // Make sure the drift never exceeds our limit.
    222     EXPECT_LT(drift_microseconds, 50000);
    223 
    224     // Sleep for a few milliseconds (note that it means 1000 microseconds).
    225     // If we check the drift too frequently, it's going to increase
    226     // monotonically, making our measurement less realistic.
    227     base::PlatformThread::Sleep(
    228         base::TimeDelta::FromMilliseconds((i % 2 == 0) ? 1 : 2));
    229 
    230     total_drift += drift_microseconds;
    231   }
    232 
    233   // Sanity check. We expect some time drift to occur, especially across
    234   // the number of iterations we do.
    235   EXPECT_LT(0, total_drift);
    236 
    237   printf("average time drift in microseconds: %lld\n",
    238          total_drift / kIterations);
    239 }
    240