Method sleep

kernel/cellos/src/lv2.cpp:1612–1660

}

bool lv2_obj::sleep(cpu_thread &cpu, const u64 timeout) {
  // Should already be performed when using this flag
  if (!g_postpone_notify_barrier) {
    prepare_for_sleep(cpu);
  }

  if (cpu.get_class() == thread_class::ppu) {
    if (u32 addr = static_cast<ppu_thread &>(cpu).res_notify) {
      static_cast<ppu_thread &>(cpu).res_notify = 0;

      if (static_cast<ppu_thread &>(cpu).res_notify_time !=
          vm::reservation_notifier_count_index(addr).second) {
        // Ignore outdated notification request
      } else if (auto it = std::find(g_to_notify, std::end(g_to_notify),
                                     std::add_pointer_t<const void>{});
                 it != std::end(g_to_notify)) {
        *it++ = vm::reservation_notifier_notify(addr, true);

        if (it < std::end(g_to_notify)) {
          // Null-terminate the list if it ends before last slot
          *it = nullptr;
        }
      } else {
        vm::reservation_notifier_notify(addr);
      }
    }
  }

  bool result = false;
  const u64 current_time = get_guest_system_time();
  {
    std::lock_guard lock{g_mutex};
    result = sleep_unlocked(cpu, timeout, current_time);

    if (!g_to_awake.empty()) {
      // Schedule pending entries
      awake_unlocked({});
    }

    schedule_all(current_time);
  }

  if (!g_postpone_notify_barrier) {
    notify_all();
  }

  g_to_awake.clear();
  return result;
}

bool lv2_obj::awake(cpu_thread *thread, s32 prio) {
  if (ppu_thread *ppu = cpu_thread::get_current<ppu_thread>()) {