Struct bump_scope::BumpPool

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

Available on crate feature std only.

A pool of bump allocators.

This type allows bump allocations in parallel, with the allocations’ lifetimes 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<A, const MIN_ALIGN: usize, const UP: bool> BumpPool<A, MIN_ALIGN, UP>

where MinimumAlignment<MIN_ALIGN>: SupportedMinimumAlignment, A: BaseAllocator + Default,

pub fn new() -> Self

Constructs a new BumpPool.

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

where A: BaseAllocator, MinimumAlignment<MIN_ALIGN>: SupportedMinimumAlignment,

pub const 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>>

Returns the vector of Bumps.

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

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>, 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> Debug for BumpPool<A, MIN_ALIGN, UP>

where A: BaseAllocator + 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> Default for BumpPool<A, MIN_ALIGN, UP>

where A: BaseAllocator + Default, MinimumAlignment<MIN_ALIGN>: SupportedMinimumAlignment,

fn default() -> Self

Returns the “default value” for a type.