use std::io;
use std::sync::atomic::{AtomicU32, Ordering};
pub(super) struct Doorbell {
#[cfg(windows)]
pub(super) event: std::os::windows::io::OwnedHandle,
}
impl Doorbell {
pub fn new() -> io::Result<Doorbell> {
Ok(Doorbell {
#[cfg(windows)]
event: platform::event()?,
})
}
#[inline]
pub fn ring(&self, counter: &AtomicU32) {
counter.fetch_add(1, Ordering::Release);
self.wake(counter);
}
#[inline]
pub fn wait(&self, counter: &AtomicU32, last: u32) {
if counter.load(Ordering::Acquire) == last {
self.sleep(counter, last);
}
}
#[cfg(target_os = "macos")]
fn wake(&self, counter: &AtomicU32) {
unsafe { platform::wake(counter) };
}
#[cfg(target_os = "macos")]
fn sleep(&self, counter: &AtomicU32, last: u32) {
unsafe { platform::wait(counter, last) };
}
#[cfg(windows)]
fn wake(&self, _counter: &AtomicU32) {
platform::set(&self.event);
}
#[cfg(windows)]
fn sleep(&self, _counter: &AtomicU32, _last: u32) {
platform::wait(&self.event);
}
}
#[cfg(target_os = "macos")]
mod platform {
use std::ffi::c_void;
use std::sync::atomic::AtomicU32;
const SHARED: u32 = 1;
unsafe extern "C" {
fn os_sync_wait_on_address(addr: *mut c_void, value: u64, size: usize, flags: u32) -> i32;
fn os_sync_wake_by_address_any(addr: *mut c_void, size: usize, flags: u32) -> i32;
}
pub unsafe fn wake(counter: &AtomicU32) {
unsafe { os_sync_wake_by_address_any(counter.as_ptr().cast(), 4, SHARED) };
}
pub unsafe fn wait(counter: &AtomicU32, last: u32) {
unsafe { os_sync_wait_on_address(counter.as_ptr().cast(), u64::from(last), 4, SHARED) };
}
}
#[cfg(windows)]
mod platform {
use std::io;
use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle};
use windows_sys::Win32::System::Threading::{
CreateEventW, INFINITE, SetEvent, WaitForSingleObject,
};
pub fn event() -> io::Result<OwnedHandle> {
let handle = unsafe { CreateEventW(std::ptr::null(), 0, 0, std::ptr::null()) };
if handle.is_null() {
return Err(io::Error::last_os_error());
}
Ok(unsafe { OwnedHandle::from_raw_handle(handle) })
}
pub fn set(event: &OwnedHandle) {
unsafe { SetEvent(event.as_raw_handle()) };
}
pub fn wait(event: &OwnedHandle) {
unsafe { WaitForSingleObject(event.as_raw_handle(), INFINITE) };
}
}