Struct AlignedBump 

pub struct AlignedBump { /* private fields */ }

Bump arena exposing explicit per-allocation alignment.

Implementations

impl AlignedBump

pub fn with_capacity(capacity: usize) -> Self

New arena with the given capacity. The backing buffer itself is allocated 64-byte aligned so cache-line requests within capacity always succeed.

Examples found in repository

examples/sample_app.rs (line 206)

fn aligned_price_scan() {
    use subms_arena_allocator::AlignedBump;
    println!("\n== aligned: cache-line scratch for a price scan ==");
    let mut scratch = AlignedBump::with_capacity(1024);
    let region = scratch.alloc_aligned(64, 64);
    assert_eq!(region.as_ptr() as usize % 64, 0, "cache-line aligned");
    for (i, b) in region.iter_mut().enumerate() {
        *b = i as u8;
    }
    let checksum: u32 = region.iter().map(|&b| b as u32).sum();
    println!(
        "  64B aligned scratch, checksum {checksum}, used {}B",
        scratch.used()
    );
    assert_eq!(checksum, (0..64u32).sum::<u32>());
    scratch.reset();
    assert_eq!(scratch.used(), 0);
}

examples/perf_features.rs (line 168)

fn main() -> io::Result<()> {
    let canon = SIZES[SIZES.len() - 1];

    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("..")
        .join(".subms")
        .join("features")
        .join("rust.json");
    let existing = std::fs::read_to_string(&path).unwrap_or_default();
    let mut manifest = SubMsFeatureManifest::load_str("rust", &existing);
    // Stamp the box these numbers came from. The bench runs wherever it is
    // invoked, so an unstamped manifest is indistinguishable from a fleet
    // capture; the renderer will not publish one it cannot attribute.
    let (source, instance) = SubMsP99Source::from_env();
    manifest.set_p99_source(source, instance.as_deref());

    // ---------- typed: one Copy type, slot handles, reuse on free ----------
    #[cfg(feature = "typed")]
    {
        use subms_arena_allocator::TypedArena;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut arena: TypedArena<u64> = TypedArena::with_capacity(n);
                let (p50, _) = run_p50_p99(n, |i| {
                    std::hint::black_box(arena.alloc(i as u64));
                });
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, None, None);

        let mut arena: TypedArena<u64> = TypedArena::with_capacity(canon);
        let (_, alloc99) = run_p50_p99(canon, |i| {
            std::hint::black_box(arena.alloc(i as u64));
        });
        // Every timed op here takes the slot the previous one freed, so the
        // reuse path is what is measured rather than the append path.
        let mut churn: TypedArena<u64> = TypedArena::with_capacity(2);
        let (_, free99) = run_p50_p99(canon, |i| {
            let slot = churn.alloc(i as u64);
            churn.free(slot);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("alloc".to_string(), alloc99);
        p99.insert("free".to_string(), free99);
        manifest.set_feature("typed", cat, &p99, &reason);
    }

    // ---------- growable: a new chunk when the active one runs out ----------
    #[cfg(feature = "growable")]
    {
        use subms_arena_allocator::GrowableBump;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut a = GrowableBump::new();
                let (p50, _) = run_p50_p99(n, |i| {
                    std::hint::black_box(a.alloc_copy(i as u64));
                });
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, None, None);

        let mut a = GrowableBump::new();
        let (_, alloc99) = run_p50_p99(canon, |i| {
            std::hint::black_box(a.alloc_copy(i as u64));
        });
        let mut filled = GrowableBump::new();
        for i in 0..canon {
            filled.alloc_copy(i as u64);
        }
        let (_, reset99) = run_p50_p99(1, |_| filled.reset());
        let mut p99 = BTreeMap::new();
        p99.insert("alloc".to_string(), alloc99);
        p99.insert("reset".to_string(), reset99);
        manifest.set_feature("growable", cat, &p99, &reason);
    }

    // ---------- stats: live counters on the alloc path ----------
    #[cfg(feature = "stats")]
    {
        use subms_arena_allocator::StatsBump;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut a = StatsBump::new();
                let (p50, _) = run_p50_p99(n, |i| {
                    std::hint::black_box(a.alloc_copy(i as u64));
                });
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, None, None);

        let mut a = StatsBump::new();
        let (_, alloc99) = run_p50_p99(canon, |i| {
            std::hint::black_box(a.alloc_copy(i as u64));
        });
        let (_, snap99) = run_p50_p99(canon, |_| {
            std::hint::black_box(a.stats());
        });
        let mut p99 = BTreeMap::new();
        p99.insert("alloc".to_string(), alloc99);
        p99.insert("stats".to_string(), snap99);
        manifest.set_feature("stats", cat, &p99, &reason);
    }

    // ---------- aligned: explicit per-allocation alignment ----------
    #[cfg(feature = "aligned")]
    {
        use subms_arena_allocator::AlignedBump;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut a = AlignedBump::with_capacity(n * 16 + 4096);
                let (p50, _) = run_p50_p99(n, |_| {
                    std::hint::black_box(a.alloc_aligned(8, 8).len());
                });
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, None, None);

        let mut a = AlignedBump::with_capacity(canon * 16 + 4096);
        let (_, alloc99) = run_p50_p99(canon, |_| {
            std::hint::black_box(a.alloc_aligned(8, 8).len());
        });
        let mut p99 = BTreeMap::new();
        p99.insert("alloc_aligned".to_string(), alloc99);
        manifest.set_feature("aligned", cat, &p99, &reason);
    }

    std::fs::create_dir_all(path.parent().unwrap())?;
    std::fs::write(&path, manifest.to_json())?;
    io::stdout().write_all(manifest.to_json().as_bytes())?;
    Ok(())
}

pub fn alloc_aligned(&mut self, size: usize, align: usize) -> &mut [u8]

Allocate size bytes aligned to align (must be a power of two). Panics if the request doesn’t fit.

Examples found in repository

examples/sample_app.rs (line 207)

fn aligned_price_scan() {
    use subms_arena_allocator::AlignedBump;
    println!("\n== aligned: cache-line scratch for a price scan ==");
    let mut scratch = AlignedBump::with_capacity(1024);
    let region = scratch.alloc_aligned(64, 64);
    assert_eq!(region.as_ptr() as usize % 64, 0, "cache-line aligned");
    for (i, b) in region.iter_mut().enumerate() {
        *b = i as u8;
    }
    let checksum: u32 = region.iter().map(|&b| b as u32).sum();
    println!(
        "  64B aligned scratch, checksum {checksum}, used {}B",
        scratch.used()
    );
    assert_eq!(checksum, (0..64u32).sum::<u32>());
    scratch.reset();
    assert_eq!(scratch.used(), 0);
}

examples/perf_features.rs (line 170)

fn main() -> io::Result<()> {
    let canon = SIZES[SIZES.len() - 1];

    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("..")
        .join(".subms")
        .join("features")
        .join("rust.json");
    let existing = std::fs::read_to_string(&path).unwrap_or_default();
    let mut manifest = SubMsFeatureManifest::load_str("rust", &existing);
    // Stamp the box these numbers came from. The bench runs wherever it is
    // invoked, so an unstamped manifest is indistinguishable from a fleet
    // capture; the renderer will not publish one it cannot attribute.
    let (source, instance) = SubMsP99Source::from_env();
    manifest.set_p99_source(source, instance.as_deref());

    // ---------- typed: one Copy type, slot handles, reuse on free ----------
    #[cfg(feature = "typed")]
    {
        use subms_arena_allocator::TypedArena;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut arena: TypedArena<u64> = TypedArena::with_capacity(n);
                let (p50, _) = run_p50_p99(n, |i| {
                    std::hint::black_box(arena.alloc(i as u64));
                });
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, None, None);

        let mut arena: TypedArena<u64> = TypedArena::with_capacity(canon);
        let (_, alloc99) = run_p50_p99(canon, |i| {
            std::hint::black_box(arena.alloc(i as u64));
        });
        // Every timed op here takes the slot the previous one freed, so the
        // reuse path is what is measured rather than the append path.
        let mut churn: TypedArena<u64> = TypedArena::with_capacity(2);
        let (_, free99) = run_p50_p99(canon, |i| {
            let slot = churn.alloc(i as u64);
            churn.free(slot);
        });
        let mut p99 = BTreeMap::new();
        p99.insert("alloc".to_string(), alloc99);
        p99.insert("free".to_string(), free99);
        manifest.set_feature("typed", cat, &p99, &reason);
    }

    // ---------- growable: a new chunk when the active one runs out ----------
    #[cfg(feature = "growable")]
    {
        use subms_arena_allocator::GrowableBump;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut a = GrowableBump::new();
                let (p50, _) = run_p50_p99(n, |i| {
                    std::hint::black_box(a.alloc_copy(i as u64));
                });
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, None, None);

        let mut a = GrowableBump::new();
        let (_, alloc99) = run_p50_p99(canon, |i| {
            std::hint::black_box(a.alloc_copy(i as u64));
        });
        let mut filled = GrowableBump::new();
        for i in 0..canon {
            filled.alloc_copy(i as u64);
        }
        let (_, reset99) = run_p50_p99(1, |_| filled.reset());
        let mut p99 = BTreeMap::new();
        p99.insert("alloc".to_string(), alloc99);
        p99.insert("reset".to_string(), reset99);
        manifest.set_feature("growable", cat, &p99, &reason);
    }

    // ---------- stats: live counters on the alloc path ----------
    #[cfg(feature = "stats")]
    {
        use subms_arena_allocator::StatsBump;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut a = StatsBump::new();
                let (p50, _) = run_p50_p99(n, |i| {
                    std::hint::black_box(a.alloc_copy(i as u64));
                });
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, None, None);

        let mut a = StatsBump::new();
        let (_, alloc99) = run_p50_p99(canon, |i| {
            std::hint::black_box(a.alloc_copy(i as u64));
        });
        let (_, snap99) = run_p50_p99(canon, |_| {
            std::hint::black_box(a.stats());
        });
        let mut p99 = BTreeMap::new();
        p99.insert("alloc".to_string(), alloc99);
        p99.insert("stats".to_string(), snap99);
        manifest.set_feature("stats", cat, &p99, &reason);
    }

    // ---------- aligned: explicit per-allocation alignment ----------
    #[cfg(feature = "aligned")]
    {
        use subms_arena_allocator::AlignedBump;
        let sweep: Vec<(usize, u64)> = SIZES
            .iter()
            .map(|&n| {
                let mut a = AlignedBump::with_capacity(n * 16 + 4096);
                let (p50, _) = run_p50_p99(n, |_| {
                    std::hint::black_box(a.alloc_aligned(8, 8).len());
                });
                (n, p50)
            })
            .collect();
        let (cat, reason) = classify_feature(&sweep, None, None);

        let mut a = AlignedBump::with_capacity(canon * 16 + 4096);
        let (_, alloc99) = run_p50_p99(canon, |_| {
            std::hint::black_box(a.alloc_aligned(8, 8).len());
        });
        let mut p99 = BTreeMap::new();
        p99.insert("alloc_aligned".to_string(), alloc99);
        manifest.set_feature("aligned", cat, &p99, &reason);
    }

    std::fs::create_dir_all(path.parent().unwrap())?;
    std::fs::write(&path, manifest.to_json())?;
    io::stdout().write_all(manifest.to_json().as_bytes())?;
    Ok(())
}

pub fn try_alloc_aligned( &mut self, size: usize, align: usize, ) -> Option<&mut [u8]>

Fallible aligned alloc. Returns None if the request doesn’t fit.

pub fn reset(&mut self)

Rewind. Buffer retained for reuse.

Examples found in repository

examples/sample_app.rs (line 218)

fn aligned_price_scan() {
    use subms_arena_allocator::AlignedBump;
    println!("\n== aligned: cache-line scratch for a price scan ==");
    let mut scratch = AlignedBump::with_capacity(1024);
    let region = scratch.alloc_aligned(64, 64);
    assert_eq!(region.as_ptr() as usize % 64, 0, "cache-line aligned");
    for (i, b) in region.iter_mut().enumerate() {
        *b = i as u8;
    }
    let checksum: u32 = region.iter().map(|&b| b as u32).sum();
    println!(
        "  64B aligned scratch, checksum {checksum}, used {}B",
        scratch.used()
    );
    assert_eq!(checksum, (0..64u32).sum::<u32>());
    scratch.reset();
    assert_eq!(scratch.used(), 0);
}

pub fn capacity(&self) -> usize

Total capacity.

pub fn used(&self) -> usize

Bytes used so far.

Examples found in repository

examples/sample_app.rs (line 215)

fn aligned_price_scan() {
    use subms_arena_allocator::AlignedBump;
    println!("\n== aligned: cache-line scratch for a price scan ==");
    let mut scratch = AlignedBump::with_capacity(1024);
    let region = scratch.alloc_aligned(64, 64);
    assert_eq!(region.as_ptr() as usize % 64, 0, "cache-line aligned");
    for (i, b) in region.iter_mut().enumerate() {
        *b = i as u8;
    }
    let checksum: u32 = region.iter().map(|&b| b as u32).sum();
    println!(
        "  64B aligned scratch, checksum {checksum}, used {}B",
        scratch.used()
    );
    assert_eq!(checksum, (0..64u32).sum::<u32>());
    scratch.reset();
    assert_eq!(scratch.used(), 0);
}

Trait Implementations

impl Drop for AlignedBump

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.