win: clock implementation

util/misc/clock_win.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/misc/clock.h"
 
-#include <time.h>
-
-#include "base/logging.h"
-#include "base/posix/eintr_wrapper.h"
-#include "build/build_config.h"
-
-namespace {
-
-const uint64_t kNanosecondsPerSecond = 1E9;
-
-}  // namespace
+#include <windows.h>
 
 namespace crashpad {
 
-#if !defined(OS_MACOSX)
+uint64_t ClockMonotonicNanoseconds() {
+  LARGE_INTEGER frequency;
+  LARGE_INTEGER time;
 
-uint64_t ClockMonotonicNanoseconds() {
-  timespec now;
-  int rv = clock_gettime(CLOCK_MONOTONIC, &now);
-  DPCHECK(rv == 0) << "clock_gettime";
+  QueryPerformanceFrequency(&frequency);

[Mark Mentovai, 2014/12/16 23:06:54]

Cache this like we do in clock_mac.cc? (TimebaseInternal() and Timebase().) The
documentation says it’s cacheable.

[Mark Mentovai, 2014/12/16 23:06:54]

PCHECK() or DPCHECK() this and QueryPerformanceCounter()?

[scottmg, 2014/12/17 01:01:28]

Done.

[scottmg, 2014/12/17 01:01:28]

They can't fail on XP or later, so I prefer not to.

+  QueryPerformanceCounter(&time);
 
-  return now.tv_sec * kNanosecondsPerSecond + now.tv_nsec;
+  // |time| is the elapsed number of ticks, and we have the number of
+  // ticks-per-second. Use this to convert to the number of nanoseconds.
+  time.QuadPart *= 1000000000;

[Mark Mentovai, 2014/12/16 23:06:54]

Fear of overflow: what kind of number is frequency.QuadPart normally? Even if
it’s on the order of 1M (I’d consider that reasonable), overflow becomes a
concern at only 2.5 hours (2.5 * 60 * 60 * 1E6 * 1E9 ≅ 2^63).

In Chrome, base/time_win.cc does a little dance to deal with the potential for
overflow, and I suspect that the same is necessary here.

Actually, if overflow is likely at as little as 2.5 hours of uptime, I wouldn’t
even bother with time_win.cc’s fast path. I’d stick with the simplicity of the
pessimistic but safe approach each time.

[Mark Mentovai, 2014/12/16 23:06:54]

1E9 or kNanosecondsPerSecond = 1E9?

[scottmg, 2014/12/17 01:01:28]

Done.

[scottmg, 2014/12/17 01:01:28]

Done.

+  time.QuadPart /= frequency.QuadPart;
+
+  return time.QuadPart;
 }
 
-#endif
-
 void SleepNanoseconds(uint64_t nanoseconds) {
-  timespec sleep_time;
-  sleep_time.tv_sec = nanoseconds / kNanosecondsPerSecond;
-  sleep_time.tv_nsec = nanoseconds % kNanosecondsPerSecond;
-  int rv = HANDLE_EINTR(nanosleep(&sleep_time, &sleep_time));
-  DPCHECK(rv == 0) << "nanosleep";
+  // This is both inaccurate (will be way too long for short sleeps) and
+  // incorrect (can sleep for less than requested). But it's what's available
+  // without implementing a busy loop.
+  const uint64_t kNanosecondsPerMillisecond = 1000000;

[Mark Mentovai, 2014/12/16 23:06:54]

1E6? Counting more than four identical characters in a row is hard.

[scottmg, 2014/12/17 01:01:28]

Done.

+  ::Sleep(static_cast<DWORD>(nanoseconds / kNanosecondsPerMillisecond));

[Mark Mentovai, 2014/12/16 23:06:54]

The :: isn’t necessary, unless they’re so strongly ingrained in Windows
programming that you wouldn’t recognize Sleep() as a win32 call without them.

[scottmg, 2014/12/17 01:01:28]

Done.

 }
 
 }  // namespace crashpad