use core::ptr;
#[repr(C)]
pub struct ClosureHeader {
pub run: unsafe fn(*mut u8),
pub data_off: usize,
}
pub const HEADER_SIZE: usize = core::mem::size_of::<ClosureHeader>();
#[inline]
pub const fn block_align_for<F>() -> usize {
let a = core::mem::align_of::<F>();
let base = core::mem::align_of::<ClosureHeader>();
if a > base {
a
} else {
base
}
}
#[inline]
pub const fn block_size_for<F>() -> usize {
align_up(
HEADER_SIZE + core::mem::align_of::<F>(),
block_align_for::<F>(),
) + core::mem::size_of::<F>()
}
pub unsafe fn place<F: FnOnce()>(base: *mut u8, f: F) -> *mut u8 {
let align = block_align_for::<F>();
let data_off = align_up_usize(HEADER_SIZE, align);
let hdr = base as *mut ClosureHeader;
(*hdr).run = run_closure::<F>;
(*hdr).data_off = data_off;
ptr::write(base.add(data_off) as *mut F, f);
base
}
pub unsafe fn run(base: *mut u8) {
debug_assert!(!base.is_null(), "task trampoline got a null closure block");
let hdr = &*(base as *const ClosureHeader);
let data = base.add(hdr.data_off);
(hdr.run)(data);
}
unsafe fn run_closure<F: FnOnce()>(data: *mut u8) {
let f: F = ptr::read(data as *const F);
f();
}
pub unsafe fn drop_blob<F>(base: *mut u8) {
let data_off = align_up_usize(HEADER_SIZE, block_align_for::<F>());
ptr::drop_in_place(base.add(data_off) as *mut F);
}
#[inline]
const fn align_up(v: usize, align: usize) -> usize {
(v + (align - 1)) & !(align - 1)
}
#[inline]
const fn align_up_usize(v: usize, align: usize) -> usize {
align_up(v, align)
}