Struct BumpPool 

pub struct BumpPool<A = Global, const MIN_ALIGN: usize = 1, const UP: bool = true>
where
    MinimumAlignment<MIN_ALIGN>: SupportedMinimumAlignment,
    A: Allocator,
{ /* 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 strings: Vec<&str> = (0..1000)
    .into_par_iter()
    .map_init(|| pool.get(), |bump, i| {
        // do some expensive work
        bump.alloc_fmt(format_args!("{i}")).into_ref()
    })
    .collect();

dbg!(&strings);

pool.reset();

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

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: Allocator + Default,

pub fn new() -> Self

Constructs a new BumpPool.

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

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

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, true, true>>

Returns the vector of Bumps.

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

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

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.

If this needs to create a new Bump, it will be constructed by calling Bump::new().

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.

If this needs to create a new Bump, it will be constructed by calling Bump::try_new().

Errors

Errors if the allocation fails.

pub fn get_with_size(&self, size: usize) -> 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.

If this needs to create a new Bump, it will be constructed by calling Bump::with_size(size).

Panics

Panics if the allocation fails.

pub fn try_get_with_size( &self, size: usize, ) -> 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.

If this needs to create a new Bump, it will be constructed by calling Bump::try_with_size(size).

Errors

Errors if the allocation fails.

pub fn get_with_capacity( &self, layout: Layout, ) -> 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.

If this needs to create a new Bump, it will be constructed by calling Bump::with_capacity(layout).

Panics

Panics if the allocation fails.

pub fn try_get_with_capacity( &self, layout: Layout, ) -> 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.

If this needs to create a new Bump, it will be constructed by calling Bump::try_with_capacity(layout).

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 MinimumAlignment<MIN_ALIGN>: SupportedMinimumAlignment, A: Allocator + Debug,

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 MinimumAlignment<MIN_ALIGN>: SupportedMinimumAlignment, A: Allocator + Default,

fn default() -> Self

Returns the “default value” for a type.