use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicPtr, Ordering};
use crate::sched::io_pool::global_io_pool;
pub struct Handle {
inner: Arc<HandleInner>,
}
struct HandleInner {
buffer: AtomicPtr<Vec<u8>>,
ready: AtomicBool,
}
impl Drop for HandleInner {
fn drop(&mut self) {
let p = *self.buffer.get_mut();
if !p.is_null() {
drop(unsafe { Box::from_raw(p) });
}
}
}
impl Handle {
pub fn is_ready(&self) -> bool {
self.inner.ready.load(Ordering::Acquire)
}
pub fn wait(self) -> Option<Vec<u8>> {
while !self.inner.ready.load(Ordering::Acquire) {
std::thread::yield_now();
}
let taken = self.inner.buffer.swap(core::ptr::null_mut(), Ordering::AcqRel);
if taken.is_null() {
return None;
}
Some(*unsafe { Box::from_raw(taken) })
}
}
pub fn prepare(n_bytes: usize) -> Handle {
let inner = Arc::new(HandleInner {
buffer: AtomicPtr::new(core::ptr::null_mut()),
ready: AtomicBool::new(false),
});
let inner_for_worker = Arc::clone(&inner);
let work = move || {
let buf = allocate_and_first_touch(n_bytes);
inner_for_worker
.buffer
.store(Box::into_raw(Box::new(buf)), Ordering::Release);
inner_for_worker.ready.store(true, Ordering::Release);
};
match global_io_pool() {
Some(pool) => {
pool.submit(work);
}
None => {
work();
}
}
Handle { inner }
}
fn allocate_and_first_touch(n_bytes: usize) -> Vec<u8> {
let mut buf = vec![0u8; n_bytes];
let page_size = page_size_bytes();
let mut offset = 0;
while offset < buf.len() {
let ptr = buf.as_mut_ptr();
unsafe {
std::ptr::write_volatile(ptr.add(offset), 0u8);
}
offset = offset.saturating_add(page_size);
}
buf
}
fn page_size_bytes() -> usize {
4096
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn prepare_returns_zero_filled_buffer_inline() {
let handle = prepare(8192);
assert!(handle.is_ready(), "inline path must be ready immediately");
let buf = handle.wait().expect("buffer must be present");
assert_eq!(buf.len(), 8192);
assert!(buf.iter().all(|&b| b == 0), "buffer must be zero-filled");
}
#[test]
fn prepare_zero_size_succeeds() {
let handle = prepare(0);
let buf = handle.wait().expect("zero-size buffer is still a buffer");
assert!(buf.is_empty());
}
#[test]
fn prepare_small_buffer_below_page_size() {
let handle = prepare(128);
let buf = handle.wait().unwrap();
assert_eq!(buf.len(), 128);
assert!(buf.iter().all(|&b| b == 0));
}
#[test]
fn prepare_large_multi_page_buffer() {
let handle = prepare(10 * 1024 * 1024);
let buf = handle.wait().unwrap();
assert_eq!(buf.len(), 10 * 1024 * 1024);
for &offset in &[0usize, 4096, 1_048_576, 9_999_999] {
assert_eq!(buf[offset], 0, "byte at offset {} must be zero", offset);
}
}
#[test]
fn handle_wait_returns_none_on_double_wait() {
let handle = prepare(1024);
let inner = Arc::clone(&handle.inner);
let first = handle.wait();
assert!(first.is_some(), "the first wait must get the buffer");
let second = inner.buffer.load(Ordering::Acquire);
assert!(second.is_null(), "buffer must be taken by the first wait");
}
#[test]
fn page_size_estimate_is_reasonable() {
let p = page_size_bytes();
assert!(p.is_power_of_two());
assert!((4096..=65536).contains(&p));
}
#[test]
fn first_touch_does_not_corrupt_buffer() {
let buf = allocate_and_first_touch(16 * 4096);
for (i, &b) in buf.iter().enumerate() {
assert_eq!(b, 0, "first-touch must not corrupt byte {i}");
}
}
}