Method wait

kernel/orbis/src/evf.cpp:6–96

#include <atomic>

orbis::ErrorCode orbis::EventFlag::wait(Thread *thread, std::uint8_t waitMode,
                                        std::uint64_t bitPattern,
                                        std::uint32_t *timeout) {
  using namespace std::chrono;

  steady_clock::time_point start{};
  uint64_t elapsed = 0;
  uint64_t fullTimeout = -1;
  if (timeout) {
    start = steady_clock::now();
    fullTimeout = *timeout;
  }

  auto update_timeout = [&] {
    if (!timeout)
      return;
    auto now = steady_clock::now();
    elapsed = duration_cast<microseconds>(now - start).count();
    if (fullTimeout > elapsed) {
      *timeout = fullTimeout - elapsed;
      return;
    }
    *timeout = 0;
  };

  thread->evfResultPattern = 0;
  thread->evfIsCancelled = -1;

  std::unique_lock lock(queueMtx);
  orbis::ErrorCode result = {};
  while (true) {
    if (isDeleted) {
      if (thread->evfIsCancelled == UINT64_MAX)
        thread->evfResultPattern = value.load();
      return ErrorCode::ACCES;
    }
    if (thread->evfIsCancelled == 1) {
      return ErrorCode::CANCELED;
    }
    if (thread->evfIsCancelled == 0) {
      break;
    }

    thread->evfResultPattern = 0;
    thread->evfIsCancelled = -1;

    auto waitingThread = WaitingThread{
        .thread = thread, .bitPattern = bitPattern, .waitMode = waitMode};

    if (auto patValue = value.load(std::memory_order::relaxed);
        waitingThread.test(patValue)) {
      auto resultValue = waitingThread.applyClear(patValue);
      value.store(resultValue, std::memory_order::relaxed);
      thread->evfResultPattern = patValue;
      // Success
      break;
    } else if (timeout && *timeout == 0) {
      thread->evfResultPattern = patValue;