Struct bump_scope::BumpPool

pub struct BumpPool<A = Global, const MIN_ALIGN: usize = 1, const UP: bool = true, const INIT: bool = true>
where
    A: Allocator + Clone,
    MinimumAlignment<MIN_ALIGN>: SupportedMinimumAlignment,
{ /* private fields */ }

Available on crate feature std only.

A pool of bump allocators.

This type allows you to do bump allocations from different threads that have their lifetime tied to the pool.

Examples

Using BumpPool with parallel iterators from rayon:

let mut pool: BumpPool = BumpPool::new();

let ints: Vec<&mut usize> = (0..1000)
    .into_par_iter()
    .map_init(|| pool.get(), |bump, i| {
        // do some expensive work
        bump.alloc(i).into_mut()
    })
    .collect();

dbg!(&ints);

pool.reset();

// memory of the int references is freed, trying to access ints will result in a lifetime error
// dbg!(&ints);

Using BumpPool with std::thread::scope:

let pool: BumpPool = BumpPool::new();
let (sender, receiver) = std::sync::mpsc::sync_channel(10);

std::thread::scope(|s| {
    s.spawn(|| {
        let bump = pool.get();
        let string = bump.alloc_str("Hello");
        sender.send(string).unwrap();
        drop(sender);
    });

    s.spawn(|| {
        for string in receiver {
            assert_eq!(string, "Hello");
        }
    });
});

Implementations

impl<const MIN_ALIGN: usize, const UP: bool, const INIT: bool> BumpPool<Global, MIN_ALIGN, UP, INIT>

where MinimumAlignment<MIN_ALIGN>: SupportedMinimumAlignment,

pub fn new() -> Self

Available on crate feature alloc only.

Constructs a new BumpPool.

impl<A, const MIN_ALIGN: usize, const UP: bool, const INIT: bool> BumpPool<A, MIN_ALIGN, UP, INIT>

where A: Allocator + Clone, MinimumAlignment<MIN_ALIGN>: SupportedMinimumAlignment,

pub fn new_in(allocator: A) -> Self

Constructs a new BumpPool with the provided allocator.

pub fn reset(&mut self)

Resets all Bumps in this pool.

pub fn bumps(&mut self) -> &mut Vec<Bump<A, MIN_ALIGN, UP, INIT>>

Returns the vector of Bumps.

pub fn get(&self) -> BumpPoolGuard<'_, A, MIN_ALIGN, UP, INIT>

Borrows a bump allocator from the pool. With this BumpPoolGuard you can make allocations that live for as long as the pool lives.

Panics

Panics if the allocation fails.

pub fn try_get( &self ) -> Result<BumpPoolGuard<'_, A, MIN_ALIGN, UP, INIT>, AllocError>

Borrows a bump allocator from the pool. With this BumpPoolGuard you can make allocations that live for as long as the pool lives.

Errors

Errors if the allocation fails.

Trait Implementations

impl<A, const MIN_ALIGN: usize, const UP: bool, const INIT: bool> Debug for BumpPool<A, MIN_ALIGN, UP, INIT>

where A: Allocator + Clone + Debug, MinimumAlignment<MIN_ALIGN>: SupportedMinimumAlignment,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A, const MIN_ALIGN: usize, const UP: bool, const INIT: bool> Default for BumpPool<A, MIN_ALIGN, UP, INIT>

where A: Allocator + Clone + Default, MinimumAlignment<MIN_ALIGN>: SupportedMinimumAlignment,

fn default() -> Self

Returns the “default value” for a type.