typedef struct _KSYSTEM_TIME {
  ULONG LowPart;
  LONG High1Time;
  LONG High2Time;
} KSYSTEM_TIME;
#define KUSER_SHARED_DATA 0x7ffe0000
#define InterruptTime ((KSYSTEM_TIME volatile*)(KUSER_SHARED_DATA + 0x08))
#define InterruptTimeBias ((ULONGLONG volatile*)(KUSER_SHARED_DATA + 0x3b0))

static LONGLONG readInterruptTime() {
  // Reading the InterruptTime from KUSER_SHARED_DATA is much better than
  // using GetTickCount() because it doesn't wrap, and is even a little quicker.
  // This works on all Windows NT versions (NT4 and up).
  LONG timeHigh;
  ULONG timeLow;
  do {
    timeHigh = InterruptTime->High1Time;
    timeLow = InterruptTime->LowPart;
  } while (timeHigh != InterruptTime->High2Time);
  LONGLONG now = ((LONGLONG)timeHigh << 32) + timeLow;
  static LONGLONG d = now;
  return now - d;
}

static LONGLONG scaleQpc(LONGLONG qpc) {
  // We do the actual scaling in fixed-point rather than floating, to make sure
  // that we don't violate monotonicity due to rounding errors.  There's no
  // need to cache QueryPerformanceFrequency().
  LARGE_INTEGER frequency;
  QueryPerformanceFrequency(&frequency);
  double fraction = 10000000/double(frequency.QuadPart);
  LONGLONG denom = 1024;
  LONGLONG numer = std::max(1LL, (LONGLONG)(fraction*denom + 0.5));
  return qpc * numer / denom;
}

static ULONGLONG readUnbiasedQpc() {
  // We remove the suspend bias added to QueryPerformanceCounter results by
  // subtracting the interrupt time bias, which is not strictly speaking legal,
  // but the units are correct and I think it's impossible for the resulting
  // "unbiased QPC" value to go backwards.
  LONGLONG interruptTimeBias, qpc;
  do {
    interruptTimeBias = *InterruptTimeBias;
    LARGE_INTEGER counter;
    QueryPerformanceCounter(&counter);
    qpc = counter.QuadPart;
  } while (interruptTimeBias != *InterruptTimeBias);
  static std::pair<LONGLONG,LONGLONG> d(qpc, interruptTimeBias);
  return scaleQpc(qpc - d.first) - (interruptTimeBias - d.second);
}

/// getMonotonicTime() returns the time elapsed since the application's first
/// call to getMonotonicTime(), in 100ns units.  The values returned are
/// guaranteed to be monotonic.  The time ticks in 15ms resolution and advances
/// during suspend on XP and Vista, but we manage to avoid this on Windows 7
/// and 8, which also use a high-precision timer.  The time does not wrap after
/// 49 days.
uint64_t getMonotonicTime()
{
  OSVERSIONINFOEX ver = { sizeof(OSVERSIONINFOEX), };
  GetVersionEx(&ver);
  bool win7OrLater = (ver.dwMajorVersion > 6 ||
      (ver.dwMajorVersion == 6 && ver.dwMinorVersion >= 1));
  // On Windows XP and earlier, QueryPerformanceCounter is not monotonic so we
  // steer well clear of it; on Vista, it's just a bit slow.
  return win7OrLater ? readUnbiasedQpc() : readInterruptTime();
}