Struct BumpPool 

pub struct BumpPool<A = Global, S = BumpSettings>
where
    A: Allocator,
    S: BumpAllocatorSettings,
{ /* 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, S> BumpPool<A, S>

where A: Allocator + Default, S: BumpAllocatorSettings,

pub fn new() -> Self

Constructs a new BumpPool.

impl<A, S> BumpPool<A, S>

where A: Allocator, S: BumpAllocatorSettings,

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

Returns the vector of Bumps.

impl<A, S> BumpPool<A, S>

where A: Allocator + Clone, S: BumpAllocatorSettings,

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

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().

pub fn get_with_size(&self, size: usize) -> BumpPoolGuard<'_, A, S>

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

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

where A: Allocator + Debug, S: BumpAllocatorSettings + Debug,

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

Formats the value using the given formatter.

impl<A, S> Default for BumpPool<A, S>

where A: Allocator + Default, S: BumpAllocatorSettings,

fn default() -> Self

Returns the “default value” for a type.