use std::sync::{Arc, Mutex};
use std::sync::atomic::{AtomicBool, Ordering};
use crate::sched::io_pool::global_io_pool;
pub struct Handle {
inner: Arc<HandleInner>,
}
struct HandleInner {
buffer: Mutex<Option<Vec<u8>>>,
ready: AtomicBool,
}
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();
}
self.inner.buffer.lock().ok()?.take()
}
}
pub fn prepare(n_bytes: usize) -> Handle {
let inner = Arc::new(HandleInner {
buffer: Mutex::new(None),
ready: AtomicBool::new(false),
});
let inner_for_worker = Arc::clone(&inner);
let work = move || {
let buf = allocate_and_first_touch(n_bytes);
if let Ok(mut slot) = inner_for_worker.buffer.lock() {
*slot = Some(buf);
}
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 _ = handle.wait();
let second = inner.buffer.lock().unwrap();
assert!(second.is_none(), "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}");
}
}
}