use bytemuck::{Pod, Zeroable};
const _: () = assert!(usize::BITS >= 64);
pub const MAGIC: u64 = u64::from_le_bytes(*b"OUTCRY\x00\x01");
pub const VERSION: u32 = 2;
pub const CACHE_LINE: usize = 64;
pub const FRAME_ALIGN: usize = 8;
pub const FRAME_HEADER: usize = 8;
pub const PAD: u64 = u64::MAX;
pub const PUBLISHED_OFFSET: usize = CACHE_LINE;
pub const RESERVED_OFFSET: usize = 2 * CACHE_LINE;
pub const BUFFER_OFFSET: usize = 3 * CACHE_LINE;
pub const MIN_CAPACITY: u64 = 4096;
#[inline]
pub const fn reserve_block(capacity: u64) -> u64 {
let b = capacity / 16;
if b < FRAME_ALIGN as u64 {
FRAME_ALIGN as u64
} else {
b
}
}
#[repr(C)]
#[derive(Clone, Copy, Pod, Zeroable, Debug, PartialEq, Eq)]
pub struct RawHeader {
pub magic: u64,
pub version: u32,
pub frame_align: u32,
pub capacity: u64,
pub instance: u64,
pub _reserved: [u64; 4],
}
const _: () = assert!(std::mem::size_of::<RawHeader>() == CACHE_LINE);
#[inline]
pub const fn align_up(v: u64, align: u64) -> u64 {
(v + (align - 1)) & !(align - 1)
}
#[inline]
pub const fn frame_size(len: usize) -> u64 {
FRAME_HEADER as u64 + align_up(len as u64, FRAME_ALIGN as u64)
}
pub const fn capacity_ok(capacity: u64) -> bool {
capacity >= MIN_CAPACITY && capacity.is_power_of_two()
}
pub const fn max_payload(capacity: u64) -> usize {
(capacity / 2 - FRAME_HEADER as u64 - FRAME_HEADER as u64) as usize
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn header_is_one_cache_line() {
assert_eq!(std::mem::size_of::<RawHeader>(), 64);
assert_eq!(std::mem::align_of::<RawHeader>(), 8);
}
#[test]
fn align_up_rounds() {
assert_eq!(align_up(0, 8), 0);
assert_eq!(align_up(1, 8), 8);
assert_eq!(align_up(8, 8), 8);
assert_eq!(align_up(9, 8), 16);
assert_eq!(align_up(4097, 4096), 8192);
}
#[test]
fn frame_size_includes_header_and_padding() {
assert_eq!(frame_size(0), 8);
assert_eq!(frame_size(1), 16);
assert_eq!(frame_size(8), 16);
assert_eq!(frame_size(73), 8 + 80);
}
#[test]
fn reserve_block_is_a_fraction_of_the_ring() {
assert_eq!(reserve_block(4096), 256);
assert_eq!(reserve_block(8 << 20), 512 * 1024);
assert!(reserve_block(MIN_CAPACITY) < MIN_CAPACITY / 2);
}
#[test]
fn capacity_rules() {
assert!(capacity_ok(4096));
assert!(capacity_ok(1 << 23));
assert!(!capacity_ok(4095));
assert!(!capacity_ok(6000));
assert!(!capacity_ok(2048));
}
}