wait.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <x86intrin.h>
#include "attributes/common.hpp"
#include "attributes/performance_constraints.hpp"
#include "cpuid.hpp"
 
namespace ein {
 
template <typename T>
concept waiter = requires (volatile void * p, uint32_t t) {
  bool(T::supported);
  T::monitor(p);
  T::mwait(t);
};
 
template <waiter W> ein_flatten
void wait_until(volatile auto * p, auto f) noexcept ein_blocking {
  [[assume(W::supported)]];
  while (!f(p)) {
    W::monitor(p);
    if (!f(p))
      W::mwait(0);
  }
}
 
struct mwaitx {
  using timer_t = uint64_t;
  ein_inline ein_artificial static void monitor(volatile void * p) noexcept { _mm_monitorx(const_cast<void*>(p),0,0); }
  ein_inline ein_artificial static void mwait(uint32_t timer = 0) noexcept ein_blocking { _mm_mwaitx(0,0,timer); }
  static const bool supported;
};
 
 
struct umwait {
  using timer_t = uint64_t;
  ein_inline ein_artificial static void monitor(volatile void * p) noexcept { return _umonitor(const_cast<void*>(p)); }
  ein_inline ein_artificial static uint8_t mwait(uint32_t timer = 0) noexcept ein_blocking { return _umwait(1,timer); }
  static const bool supported;
};
 
struct spin {
  using timer_t = uint64_t;
  ein_inline ein_artificial static void monitor(volatile void *) noexcept {}
  ein_inline ein_artificial static void mwait(uint32_t = 0) noexcept ein_blocking { _mm_pause(); }
  inline static constinit bool supported = true;
};
 
auto with_waiter(auto k) noexcept {
  if (mwaitx::supported) return k.template operator()<mwaitx>();
  else if (umwait::supported) return k.template operator()<umwait>();
  else k.template operator()<spin>();
}
 
}
 
#if defined(EIN_TESTING) || defined(EIN_TESTING_WAIT)
#include <atomic>
#include <thread>
#include <chrono>
namespace {
  // Mock waiter that simulates waiting behavior
  struct mock_waiter {
    static inline bool supported = true;
    static inline std::atomic<bool> monitor_called = false;
    static inline std::atomic<bool> mwait_called = false;
 
    static void monitor(volatile void*) noexcept {
      monitor_called.store(true);
    }
 
    static void mwait(uint32_t timer = 0) noexcept {
      mwait_called.store(true);
      std::this_thread::sleep_for(std::chrono::milliseconds(timer));
    }
  };
}
 
TEST_CASE("wait","[wait]") {
 
  SECTION("wait_until with mock_waiter") {
    using namespace ein;
 
    volatile int data = 0;
    auto predicate = [](volatile int* p) { return *p == 42; };
 
    std::thread updater([&data]() {
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
      data = 42;
    });
 
    wait_until<mock_waiter>(&data, predicate);
 
    CHECK(mock_waiter::monitor_called.load());
    CHECK(mock_waiter::mwait_called.load());
    CHECK(data == 42);
 
    updater.join();
  }
 
  SECTION("wait_until with platform waiter") {
    using namespace ein;
 
    volatile int data = 0;
    auto predicate = [](volatile int* p) { return *p == 42; };
 
    std::thread updater([&data]() {
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
      data = 42;
    });
 
    with_waiter([&data,predicate] <waiter w> {
      wait_until<w>(&data, predicate);
    });
 
    CHECK(data == 42);
 
    updater.join();
  }
}
#endif