A single lifetime parameter in BumpVec

[CeleritasCelery]

I have not delved into it too deeply, but it seems like it should be possible to only have one lifetime parameter for BumpVec (and by extension BumpString). This is similar to bumpalo Vec. The lifetime is there to ensure that it either does not outlive the Bump or the BumpScopeGuard, depending on if the scope is present. It seems like a single lifetime could serve both purposes. However just changing BumpVec to this:

    fixed: FixedBumpVec<'a, T>,
    pub(crate) bump: &'a mut BumpScope<'a, A, MIN_ALIGN, UP>,

Would make it invariant over 'a, which is probably not desirable.

[bluurryy]

I think this would prevent code like this:

let slice = bump_vec![in bump; 1, 2, 3].into_slice();
let foo = bump.alloc_str("whatever");

I we had just the one lifetime, slice would mutably borrow the bump and as such not allow allocations while it is live.

[bluurryy]

BumpVec is a bit more special than a Vec in the sense that it mutably borrows the BumpScope. This makes it so it can use the entire remaining chunk capacity as its own and not touch the bump pointer unless it is turned to a slice.

The idea is that you can push items to a BumpVec and then turn it to a slice and continue doing other bump allocations. If BumpVec were just immutably borrowed the two lifetimes would not be as useful, but would still mean that the returned slice lives as long as the BumpScopeGuard instead of just as long as the BumpScope.

[CeleritasCelery]

Interesting. So if BumpVec mutably borrows the Bump is it possible to create a Vector of Strings allocated in the Bump (using this crates types that would be BumpBox<[BumpBox<str>]>)?

[bluurryy]

Generally not with BumpVec. You can use Vec for that.

use bump_scope::{ Bump, allocator_api2::vec::Vec };

let bump: Bump = Bump::new();
let mut vec: Vec<&str, _> = Vec::new_in(&bump);

for _ in 0..10 {
    let string = bump.alloc_str("hello").into_ref();
    vec.push(string);
}

dbg!(&vec);

BumpVec is more like a niche tool when you happen to have a &mut Bump.
I feel like it should probably be named MutBumpVec or something and we should have a new type BumpVec that immutably borrows the bump (#3). A plain Vec can't be turned into a BumpBox<[T]> or &[T]. With that new type we could do so.

Edit: code example works now

[CeleritasCelery]

What advantage does BumpVec provide that you wouldn’t get from just using the realloc trick? That would still let you grow to use the entire chunk capacity without copying, but doesn’t require exclusive access.

[bluurryy]

Its just that the capacity is initialized with the space left in the chunk. So you get less realloc calls.

[CeleritasCelery]

Interesting. I wonder if the difference would be observable in benchmarks. I didn't realize that BumpVec and BumpString were intended to be so niche.

[CeleritasCelery]

Another thing to consider is that you could get the exact same property (capacity is initialized with the space left in the chunk) like this:

use bump_scope::allocator_api2::Vec;
Vec::with_capacity_in(bump.stats().remaining()/size_of::<T>(), bump)

But without the need of a separate type that requires exclusive access.