Struct StatsBump 

pub struct StatsBump { /* private fields */ }

Bump arena with instrumentation. Auto-grows like GrowableBump.

Implementations

impl StatsBump

pub fn new() -> Self

New arena with a 4 KiB initial chunk.

Examples found in repository

examples/perf_features.rs (line 139)

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 with_capacity(initial: usize) -> Self

New arena with the requested initial chunk size.

Examples found in repository

examples/sample_app.rs (line 180)

fn stats_sizing() {
    use subms_arena_allocator::StatsBump;
    println!("\n== stats: size the arena from real load ==");
    let mut scratch = StatsBump::with_capacity(4096);
    for _tick in 0..1_000 {
        for i in 0..8u64 {
            scratch.alloc_copy(Level {
                price_ticks: 10_000 + i,
                qty: 1,
            });
        }
        scratch.reset();
    }
    let s = scratch.stats();
    println!(
        "  {} allocs over 1000 ticks, peak {}B, wasted {}B",
        s.allocations, s.peak_bytes, s.bytes_wasted,
    );
    assert_eq!(s.allocations, 8_000, "counters survive reset");
    assert!(s.peak_bytes > 0, "peak recorded");
}

pub fn alloc_copy<T: Copy>(&mut self, value: T) -> &mut T

Allocate a Copy value. Updates the counters.

Examples found in repository

examples/sample_app.rs (lines 183-186)

fn stats_sizing() {
    use subms_arena_allocator::StatsBump;
    println!("\n== stats: size the arena from real load ==");
    let mut scratch = StatsBump::with_capacity(4096);
    for _tick in 0..1_000 {
        for i in 0..8u64 {
            scratch.alloc_copy(Level {
                price_ticks: 10_000 + i,
                qty: 1,
            });
        }
        scratch.reset();
    }
    let s = scratch.stats();
    println!(
        "  {} allocs over 1000 ticks, peak {}B, wasted {}B",
        s.allocations, s.peak_bytes, s.bytes_wasted,
    );
    assert_eq!(s.allocations, 8_000, "counters survive reset");
    assert!(s.peak_bytes > 0, "peak recorded");
}

examples/perf_features.rs (line 141)

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_raw(&mut self, layout: Layout) -> *mut u8

Allocate layout.size() bytes aligned to layout.align(). Updates the counters.

pub fn reset(&mut self)

Rewind. Keeps the largest chunk. Stats are preserved.

Examples found in repository

examples/sample_app.rs (line 188)

fn stats_sizing() {
    use subms_arena_allocator::StatsBump;
    println!("\n== stats: size the arena from real load ==");
    let mut scratch = StatsBump::with_capacity(4096);
    for _tick in 0..1_000 {
        for i in 0..8u64 {
            scratch.alloc_copy(Level {
                price_ticks: 10_000 + i,
                qty: 1,
            });
        }
        scratch.reset();
    }
    let s = scratch.stats();
    println!(
        "  {} allocs over 1000 ticks, peak {}B, wasted {}B",
        s.allocations, s.peak_bytes, s.bytes_wasted,
    );
    assert_eq!(s.allocations, 8_000, "counters survive reset");
    assert!(s.peak_bytes > 0, "peak recorded");
}

pub fn stats(&self) -> BumpStats

Snapshot the live counters.

Examples found in repository

examples/sample_app.rs (line 190)

fn stats_sizing() {
    use subms_arena_allocator::StatsBump;
    println!("\n== stats: size the arena from real load ==");
    let mut scratch = StatsBump::with_capacity(4096);
    for _tick in 0..1_000 {
        for i in 0..8u64 {
            scratch.alloc_copy(Level {
                price_ticks: 10_000 + i,
                qty: 1,
            });
        }
        scratch.reset();
    }
    let s = scratch.stats();
    println!(
        "  {} allocs over 1000 ticks, peak {}B, wasted {}B",
        s.allocations, s.peak_bytes, s.bytes_wasted,
    );
    assert_eq!(s.allocations, 8_000, "counters survive reset");
    assert!(s.peak_bytes > 0, "peak recorded");
}

examples/perf_features.rs (line 153)

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 clear_stats(&mut self)

Zero the counters. The chunk_count is restored to the current retained chunk count rather than zero, so the snapshot remains meaningful immediately after.

Trait Implementations

impl Default for StatsBump

fn default() -> Self

Returns the “default value” for a type.