use std::ptr;
use std::sync::atomic::{AtomicPtr, Ordering};
const RETURNED: usize = 1;
pub(crate) struct Mailbox<T> {
slot: AtomicPtr<T>,
}
impl<T> Default for Mailbox<T> {
fn default() -> Mailbox<T> {
Mailbox {
slot: AtomicPtr::new(ptr::null_mut()),
}
}
}
fn returned<T>(pointer: *mut T) -> bool {
pointer.addr() & RETURNED != 0
}
unsafe fn free<T>(pointer: *mut T) {
let pointer = pointer.map_addr(|address| address & !RETURNED);
if !pointer.is_null() {
drop(unsafe { Box::from_raw(pointer) });
}
}
impl<T> Mailbox<T> {
pub fn send(&self, value: Box<T>) {
const { assert!(align_of::<T>() > RETURNED) };
let old = self.slot.swap(Box::into_raw(value), Ordering::AcqRel);
unsafe { free(old) };
}
pub fn reclaim(&self) {
let current = self.slot.load(Ordering::Acquire);
if returned(current)
&& self
.slot
.compare_exchange(
current,
ptr::null_mut(),
Ordering::AcqRel,
Ordering::Acquire,
)
.is_ok()
{
unsafe { free(current) };
}
}
pub fn receive(&self, current: &mut Box<T>) {
const { assert!(align_of::<T>() > RETURNED) };
let offered = self.slot.load(Ordering::Acquire);
if offered.is_null() || returned(offered) {
return;
}
let old = Box::into_raw(unsafe { ptr::read(current) });
let handed_back = old.map_addr(|address| address | RETURNED);
let taken = self
.slot
.compare_exchange(offered, handed_back, Ordering::AcqRel, Ordering::Acquire)
.is_ok();
let next = if taken { offered } else { old };
unsafe { ptr::write(current, Box::from_raw(next)) };
}
}
impl<T> Drop for Mailbox<T> {
fn drop(&mut self) {
let value = self.slot.swap(ptr::null_mut(), Ordering::AcqRel);
unsafe { free(value) };
}
}
unsafe impl<T: Send> Send for Mailbox<T> {}
unsafe impl<T: Send> Sync for Mailbox<T> {}