[base] Implement CPU time on Windows.

test/unittests/base/platform/time-unittest.cc

 // Copyright 2014 the V8 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.
 
 #include "src/base/platform/time.h"
 
 #if V8_OS_MACOSX
 #include <mach/mach_time.h>
 #endif
 #if V8_OS_POSIX
 #include <sys/time.h>
 #endif
 
 #if V8_OS_WIN
 #include "src/base/win32-headers.h"
 #endif
 
+#include <vector>
+
 #include "src/base/platform/elapsed-timer.h"
 #include "src/base/platform/platform.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace v8 {
 namespace base {
 
 TEST(TimeDelta, FromAndIn) {
   EXPECT_EQ(TimeDelta::FromDays(2), TimeDelta::FromHours(48));
   EXPECT_EQ(TimeDelta::FromHours(3), TimeDelta::FromMinutes(180));
@@ skipping 150 matching lines @@
     EXPECT_GE((normal_ticks - previous_normal_ticks).InMicroseconds(), 0);
     EXPECT_GE(highres_ticks, previous_highres_ticks);
     EXPECT_GE((highres_ticks - previous_highres_ticks).InMicroseconds(), 0);
     previous_normal_ticks = normal_ticks;
     previous_highres_ticks = highres_ticks;
   }
 }
 
 
 // Disable on windows until it is implemented.
-#if V8_OS_ANDROID || V8_OS_WIN
+#if V8_OS_ANDROID
 #define MAYBE_ThreadNow DISABLED_ThreadNow
 #else
 #define MAYBE_ThreadNow ThreadNow
 #endif
 TEST(ThreadTicks, MAYBE_ThreadNow) {
   if (ThreadTicks::IsSupported()) {
     TimeTicks begin = TimeTicks::Now();
     ThreadTicks begin_thread = ThreadTicks::Now();
     // Make sure that ThreadNow value is non-zero.
     EXPECT_GT(begin_thread, ThreadTicks());
     // Sleep for 10 milliseconds to get the thread de-scheduled.
     OS::Sleep(base::TimeDelta::FromMilliseconds(10));
     ThreadTicks end_thread = ThreadTicks::Now();
     TimeTicks end = TimeTicks::Now();
     TimeDelta delta = end - begin;
     TimeDelta delta_thread = end_thread - begin_thread;
     // Make sure that some thread time have elapsed.
     EXPECT_GT(delta_thread.InMicroseconds(), 0);
     // But the thread time is at least 9ms less than clock time.
     TimeDelta difference = delta - delta_thread;
     EXPECT_GE(difference.InMicroseconds(), 9000);
   }
 }
 
+
+#if V8_OS_WIN
+TEST(TimeTicks, TimerPerformance) {
+  // Verify that various timer mechanisms can always complete quickly.
+  // Note:  This is a somewhat arbitrary test.
+  const int kLoops = 10000;
+
+  typedef TimeTicks (*TestFunc)();
+  struct TestCase {
+    TestFunc func;
+    const char *description;
+  };
+  // Cheating a bit here:  assumes sizeof(TimeTicks) == sizeof(Time)
+  // in order to create a single test case list.
+  static_assert(sizeof(TimeTicks) == sizeof(Time),
+                "TimeTicks and Time must be the same size");
+  std::vector<TestCase> cases;
+  cases.push_back({reinterpret_cast<TestFunc>(&Time::Now), "Time::Now"});
+  cases.push_back({&TimeTicks::Now, "TimeTicks::Now"});
+
+  if (ThreadTicks::IsSupported()) {
+    ThreadTicks::WaitUntilInitialized();
+    cases.push_back(
+        {reinterpret_cast<TestFunc>(&ThreadTicks::Now), "ThreadTicks::Now"});
+  }
+
+  for (const auto& test_case : cases) {
+    TimeTicks start = TimeTicks::Now();
+    for (int index = 0; index < kLoops; index++)
+      test_case.func();
+    TimeTicks stop = TimeTicks::Now();
+    // Turning off the check for acceptible delays.  Without this check,
+    // the test really doesn't do much other than measure.  But the
+    // measurements are still useful for testing timers on various platforms.
+    // The reason to remove the check is because the tests run on many
+    // buildbots, some of which are VMs.  These machines can run horribly
+    // slow, and there is really no value for checking against a max timer.
+    // const int kMaxTime = 35;  // Maximum acceptible milliseconds for test.
+    // EXPECT_LT((stop - start).InMilliseconds(), kMaxTime);
+    printf("%s: %1.2fus per call\n", test_case.description,
+           (stop - start).InMillisecondsF() * 1000 / kLoops);
+  }
+}
+#endif  // V8_OS_WIN
+
 }  // namespace base
 }  // namespace v8