TimerThreadMonitor_windows.cpp

Enable keyboard shortcuts

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include <windows.h>

#include <algorithm>

#include <cmath>

#include <limits>

#include "TimerThreadMonitor.h"

#include "mozilla/Assertions.h"

#include "mozilla/ProfilerThreadSleep.h"

namespace mozilla {

TimerThreadMonitor::TimerThreadMonitor(const char* aName)

    : mMutex(aName),

      mHiResTimer(CreateWaitableTimerEx(nullptr, nullptr,

                                        CREATE_WAITABLE_TIMER_HIGH_RESOLUTION,

                                        TIMER_ALL_ACCESS)),

      mLoResTimer(CreateWaitableTimerEx(nullptr, nullptr, 0, TIMER_ALL_ACCESS)),

      mEvent(CreateEvent(nullptr, FALSE, FALSE, nullptr)) {

  // Release assertions because we cannot continue without these. mHiResTimer

  // is allowed to be null; timed waits fall back to mLoResTimer.

  MOZ_RELEASE_ASSERT(mLoResTimer);

  MOZ_RELEASE_ASSERT(mEvent);

TimerThreadMonitor::~TimerThreadMonitor() { AssertNoWaiter(); }

void TimerThreadMonitor::Wait() {

  BeginWait();

    AUTO_PROFILER_THREAD_SLEEP;

    Unlock();

    WaitForSingleObject(mEvent.get(), INFINITE);

    Lock();

  EndWait();

void TimerThreadMonitor::Wait(TimeDuration aDuration, TimeDuration aTolerance) {

  if (aDuration == TimeDuration::Forever()) {

    Wait();

    return;

  BeginWait();

  // Negative means relative rather than absolute, in hundreds of nanoseconds.

  const LARGE_INTEGER dueTime{.QuadPart = -ToWaitMicroseconds(aDuration) * 10};

  // SetWaitableTimerEx takes whole milliseconds, so this is the one place that

  // gives up sub-millisecond resolution. Rounding stays closer than truncating.

  const ULONG toleranceMs = static_cast<ULONG>(

      std::clamp(std::round(aTolerance.ToMilliseconds()), 0.0,

                 static_cast<double>(std::numeric_limits<ULONG>::max())));

  const bool canBePrecise = IsPreciseTolerance(aTolerance) && mHiResTimer;

  const HANDLE timer = canBePrecise ? mHiResTimer.get() : mLoResTimer.get();

  // High-resolution timers do not accept a tolerance, so a tolerant wait uses

  // the low-resolution one and its precision.

  const ULONG timerTolerance = canBePrecise ? 0 : toleranceMs;

  [[maybe_unused]] const BOOL ok = SetWaitableTimerEx(

      timer, &dueTime, 0, nullptr, nullptr, nullptr, timerTolerance);

  MOZ_RELEASE_ASSERT(ok);

    AUTO_PROFILER_THREAD_SLEEP;

    Unlock();

    // The event first: when both are signalled only the first is reset, and a

    // timer left signalled is reset when the next wait re-arms it.

    const HANDLE handles[2] = {mEvent.get(), timer};

    WaitForMultipleObjects(2, handles, FALSE, INFINITE);

    Lock();

  EndWait();

void TimerThreadMonitor::Notify() {

  [[maybe_unused]] const BOOL ok = SetEvent(mEvent.get());

  MOZ_RELEASE_ASSERT(ok);

}  // namespace mozilla