use core::cell::UnsafeCell;
use core::ptr;
pub const DEFAULT_ARENA_SIZE: usize = 16 * 1024;
#[repr(C)]
struct Block {
total: usize,
payload_size: usize,
next: *mut Block,
}
const HDR_SIZE: usize = {
let a = core::mem::align_of::<Block>();
let s = core::mem::size_of::<Block>();
(s + a - 1) & !(a - 1)
};
const PTR_SLOT: usize = core::mem::size_of::<*mut Block>();
#[repr(C, align(16))]
pub struct ArenaCell(UnsafeCell<[u8; DEFAULT_ARENA_SIZE]>);
unsafe impl Sync for ArenaCell {}
impl ArenaCell {
pub const fn new() -> Self {
ArenaCell(UnsafeCell::new([0u8; DEFAULT_ARENA_SIZE]))
}
#[inline]
pub fn as_ptr(&self) -> *mut u8 {
self.0.get() as *mut u8
}
pub const LEN: usize = DEFAULT_ARENA_SIZE;
}
impl Default for ArenaCell {
fn default() -> Self {
Self::new()
}
}
pub static DEFAULT_ARENA: ArenaCell = ArenaCell::new();
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct ArenaStats {
pub bytes_total: usize,
pub bytes_bump: usize,
pub live_bytes: usize,
pub allocations: u64,
pub frees: u64,
pub free_blocks: u32,
pub peak_live_bytes: usize,
}
#[derive(Clone, Copy)]
pub struct Arena {
base: *mut u8,
len: usize,
bump: usize,
free: *mut Block,
live: usize,
peak: usize,
allocations: u64,
frees: u64,
}
impl Arena {
pub const fn empty() -> Self {
Arena {
base: ptr::null_mut(),
len: 0,
bump: 0,
free: ptr::null_mut(),
live: 0,
peak: 0,
allocations: 0,
frees: 0,
}
}
pub unsafe fn init(&mut self, base: *mut u8, len: usize) {
self.base = base;
self.len = len;
self.bump = 0;
self.free = ptr::null_mut();
self.live = 0;
self.peak = 0;
self.allocations = 0;
self.frees = 0;
}
#[inline]
pub fn is_ready(&self) -> bool {
!self.base.is_null()
}
#[inline]
pub unsafe fn alloc(&mut self, size: usize, align: usize) -> Option<*mut u8> {
if !self.is_ready() || size == 0 {
return None;
}
let align = align.max(PTR_SLOT);
let mut prev: *mut Block = ptr::null_mut();
let mut cur = self.free;
while !cur.is_null() {
let next = (*cur).next;
let payload = payload_of(cur, align);
if payload.add(size) <= (cur as *mut u8).add((*cur).total) {
if prev.is_null() {
self.free = next;
} else {
(*prev).next = next;
}
(*cur).next = ptr::null_mut();
*((payload.sub(PTR_SLOT)) as *mut *mut Block) = cur;
self.account_alloc(size);
return Some(payload);
}
prev = cur;
cur = next;
}
let start = self.base.add(self.bump);
let payload = align_up(start.add(HDR_SIZE + PTR_SLOT), align);
let end = payload.add(size);
let used = end.offset_from(self.base) as usize;
if used > self.len {
return None; }
let hdr = payload.sub(PTR_SLOT + HDR_SIZE) as *mut Block;
(*hdr).total = used - (hdr as usize - self.base as usize);
(*hdr).payload_size = size;
(*hdr).next = ptr::null_mut();
*((payload.sub(PTR_SLOT)) as *mut *mut Block) = hdr;
self.bump = used;
self.account_alloc(size);
Some(payload)
}
pub unsafe fn alloc_zeroed(&mut self, size: usize, align: usize) -> Option<*mut u8> {
let p = self.alloc(size, align)?;
ptr::write_bytes(p, 0, size);
Some(p)
}
pub unsafe fn free(&mut self, payload: *mut u8) {
if payload.is_null() || !self.is_ready() {
return;
}
let hdr = *((payload.sub(PTR_SLOT)) as *mut *mut Block);
if hdr.is_null() {
debug_assert!(false, "rrkernel: double free of arena block");
return;
}
let size = (*hdr).payload_size;
(*hdr).next = self.free;
self.free = hdr;
*((payload.sub(PTR_SLOT)) as *mut *mut Block) = ptr::null_mut();
self.live = self.live.saturating_sub(size);
self.frees += 1;
}
#[inline]
unsafe fn account_alloc(&mut self, size: usize) {
self.live += size;
if self.live > self.peak {
self.peak = self.live;
}
self.allocations += 1;
}
pub unsafe fn stats(&self) -> ArenaStats {
let mut n = 0u32;
let mut p = self.free;
while !p.is_null() {
n += 1;
p = (*p).next;
if n > 1_000_000 {
break; }
}
ArenaStats {
bytes_total: self.len,
bytes_bump: self.bump,
live_bytes: self.live,
allocations: self.allocations,
frees: self.frees,
free_blocks: n,
peak_live_bytes: self.peak,
}
}
}
#[inline]
fn payload_of(hdr: *mut Block, align: usize) -> *mut u8 {
unsafe { align_up((hdr as *mut u8).add(HDR_SIZE + PTR_SLOT), align) }
}
#[inline]
fn align_up(v: *mut u8, align: usize) -> *mut u8 {
let mask = align - 1;
((v as usize + mask) & !mask) as *mut u8
}
const _: () = assert!(HDR_SIZE.is_multiple_of(core::mem::align_of::<Block>()));
const _: () = assert!(HDR_SIZE >= core::mem::size_of::<Block>());