win: clock implementation

util/misc/clock_win.cc

Index: util/misc/clock_win.cc
diff --git a/util/misc/clock_win.cc b/util/misc/clock_win.cc
new file mode 100644
index 0000000000000000000000000000000000000000..255f3dc655d0dfafe1dbb0e01d199cca64b6f684
--- /dev/null
+++ b/util/misc/clock_win.cc
@@ -0,0 +1,62 @@
+// 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 <sys/types.h>
+#include <windows.h>
+
+namespace {
+
+LARGE_INTEGER QpcFrequencyInternal() {
+  LARGE_INTEGER frequency;
+  QueryPerformanceFrequency(&frequency);
+  return frequency;
+}
+
+int64_t QpcFrequency() {
+  static LARGE_INTEGER frequency = QpcFrequencyInternal();
+  return frequency.QuadPart;
+}
+
+}  // namespace
+
+namespace crashpad {
+
+uint64_t ClockMonotonicNanoseconds() {
+  LARGE_INTEGER time;
+  QueryPerformanceCounter(&time);
+  int64_t frequency = QpcFrequency();
+  int64_t whole_seconds = time.QuadPart / frequency;
+  int64_t leftover_ticks = time.QuadPart / (whole_seconds * frequency);
+  const int64_t kNanosecondsPerSecond = static_cast<const int64_t>(1E9);
+  return (whole_seconds * kNanosecondsPerSecond) +
+         ((leftover_ticks * kNanosecondsPerSecond) / frequency);
+}
+
+void SleepNanoseconds(uint64_t nanoseconds) {
+  // This can be quite inaccurate (way too long for short sleeps). But it's
+  // what's available without implementing a busy loop.
+  const uint64_t kNanosecondsPerMillisecond = static_cast<const uint64_t>(1E6);
+  uint64_t start = ClockMonotonicNanoseconds();
+  Sleep(static_cast<DWORD>(nanoseconds / kNanosecondsPerMillisecond));
+  // Sleep can sleep for less than requested, so try to ensure that we sleep for
+  // at least |nanoseconds|. As |Sleep()| and |QueryPerformanceCounter()| use
+  // different clocks, this could still be insufficient.
+  while (ClockMonotonicNanoseconds() - start < nanoseconds) {
+    Sleep(1);

[Mark Mentovai, 2014/12/17 05:15:56]

Hmm, I had something slightly different in mind, just one Sleep() call in the
function, inside the loop body, which would have looked like

  uint64_t remaining_ms = nanoseconds / kNanosecondsPerMillisecond;
  uint64_t now_ms = ClockMonotonicNanoseconds() / kNanosecondsPerMillisecond;
  const uint64_t deadline_ms = now_ms + remaining_ms;
  do {
    Sleep(static_cast<DWORD>(std::min(remaining_ms,
                                      std::numeric_limits<DWORD>::max()));
    now_ms = ClockMonotonicNanoseconds() / kNanosecondsPerMillisecond;
    remaining_ms = deadline_ms - now_ms;
  } while (now_ms < deadline_ms);

so that remainder sleeps try to make up as much of the remainder as possible. I
didn’t really care so much about sub-millisecond resolution, which would be
futile with this API.

But the way you wrote this now, it looks like maybe I misunderstood the comment
you had here before. I took “can sleep for less than requested” to mean that it
could be interrupted way earlier than the deadline, as in a POSIX EINTR
(“interrupted system call”).

If you were really just referring to truncation when converting nanoseconds to
milliseconds, then I don’t think that it’s worth trying to correct, and we
should just get rid of this loop and go back to the single Sleep().

Sorry if I misunderstood and it caused a little runaround. You can feel free to
push back if it sounds like I’m asking for anything weird.

+  }
+}
+
+}  // namespace crashpad