Released YYYY-MM-DD.
Released 2023-01-17.
bumpalo::boxed::Box::bump and bumpalo::collections::String::bump getters to get the underlying Bump that a string or box was allocated into.Box that MIRI did not previously consider as UB are now reported as UB, and bumpalo's internals have been adjusted to avoid the new UB.Released 2022-10-18.
std::vec::IntoIter was ported to bumpalo::collections::vec::IntoIter, it didn't get its underlying Bump's lifetime threaded through. This meant that rustc was not checking the borrows for bumpalo::collections::IntoIter and this could result in use-after-free bugs.Released 2022-08-17.
Bump allocation limits. These are enforced only in the slow path when allocating new chunks in the Bump, not in the bump allocation hot path, and therefore impose near zero overhead.bumpalo::boxed::Box::into_inner method.Released 2022-06-01.
bumpalo::collections::FromIteratorIn for Option and Result, just like core does for FromIterator.bumpalo::collections::FromIteratorIn for bumpalo::boxed::Box<'a, [T]>.bumpalo::collections::Vec::drain_filter since the corresponding std::vec::Vec method has stabilized.Bump::new will not allocate a backing chunk until the first allocation inside the bump arena now.Released 2022-01-06.
Released 2022-01-05.
The minimum supported Rust version (MSRV) has been raised to Rust 1.54.0.
bumpalo::collections::Vec<T> implements relevant traits for all arrays of any size N via const generics. Previously, it was just arrays up to length 32. Similar for bumpalo::boxed::Box<[T; N]>.
Released 2021-10-19.
Added the CollectIn and FromIteratorIn traits to make building a collection from an iterator easier. These new traits live in the bumpalo::collections module and are implemented by bumpalo::collections::{String,Vec}.
Added the Bump::iter_allocated_chunks_raw method, which is an unsafe, raw version of Bump::iter_allocated_chunks. The new method does not take an exclusive borrow of the Bump and yields raw pointer-and-length pairs for each chunk in the bump. It is the caller's responsibility to ensure that no allocation happens in the Bump while iterating over chunks and that there are no active borrows of allocated data if they want to turn any pointer-and-length pairs into slices.
Released 2021-09-17.
bumpalo is published is now smaller, thanks to excluding unnecessary files.Released 2020-05-28.
Borrow and BorrowMut trait implementations for bumpalo::collections::Vec and bumpalo::collections::String. #108Released 2020-02-18.
Bump's Allocator::grow_zeroed trait method implementation. #99Released 2020-01-29.
Added a few new flavors of allocation:
try_alloc for fallible, by-value allocation
try_alloc_with for fallible allocation with an infallible initializer function
alloc_try_with for infallible allocation with a fallible initializer function
try_alloc_try_with method for fallible allocation with a fallible initializer function
We already have infallible, by-value allocation (alloc) and infallible allocation with an infallible initializer (alloc_with). With these new methods, we now have every combination covered.
Thanks to Tamme Schichler for contributing these methods!
Released 2020-01-22.
Added experimental, unstable support for the unstable, nightly Rust allocator_api feature.
The allocator_api feature defines an Allocator trait and exposes custom allocators for std types. Bumpalo has a matching allocator_api cargo feature to enable implementing Allocator and using Bump with std collections.
First, enable the allocator_api feature in your Cargo.toml:
[dependencies] bumpalo = { version = "3.5", features = ["allocator_api"] }
Next, enable the allocator_api nightly Rust feature in your src/lib.rs or src/main.rs:
# #[cfg(feature = "allocator_api")] # { #![feature(allocator_api)] # }
Finally, use std collections with Bump, so that their internal heap allocations are made within the given bump arena:
# #![cfg_attr(feature = "allocator_api", feature(allocator_api))]
# #[cfg(feature = "allocator_api")]
# {
#![feature(allocator_api)]
use bumpalo::Bump;
// Create a new bump arena.
let bump = Bump::new();
// Create a `Vec` whose elements are allocated within the bump arena.
let mut v = Vec::new_in(&bump);
v.push(0);
v.push(1);
v.push(2);
# }
I'm very excited to see custom allocators in std coming along! Thanks to Arthur Gautier for implementing support for the allocator_api feature for Bumpalo.
Released 2020-06-01.
bumpalo::boxed::Box<T> type. It is an owned pointer referencing a bump-allocated value, and it runs T's Drop implementation on the referenced value when dropped. This type can be used by enabling the "boxed" cargo feature flag.Released 2020-05-13.
Added fallible allocation methods to Bump: try_new, try_with_capacity, and try_alloc_layout.
Added Bump::chunk_capacity
Added bumpalo::collections::Vec::try_reserve[_exact]
Released 2020-03-24.
When reallocing, if we allocate new space, we need to copy the old allocation‘s bytes into the new space. There are old_size number of bytes in the old allocation, but we were accidentally copying new_size number of bytes, which could lead to copying bytes into the realloc’d space from past the chunk that we're bump allocating out of, from unknown memory.
If an attacker can cause reallocs, and can read the realoced data back, this could allow them to read things from other regions of memory that they shouldn't be able to. For example, if some crypto keys happened to live in memory right after a chunk we were bump allocating out of, this could allow the attacker to read the crypto keys.
Beyond just fixing the bug and adding a regression test, I've also taken two additional steps:
While we were already running the testsuite under valgrind in CI, because valgrind exits with the same code that the program did, if there are invalid reads/writes that happen not to trigger a segfault, the program can still exit OK and we will be none the wiser. I've enabled the --error-exitcode=1 flag for valgrind in CI so that tests eagerly fail in these scenarios.
I‘ve written a quickcheck test to exercise realloc. Without the bug fix in this patch, this quickcheck immediately triggers invalid reads when run under valgrind. We didn’t previously have quickchecks that exercised realloc because realloc isn't publicly exposed directly, and instead can only be indirectly called. This new quickcheck test exercises realloc via bumpalo::collections::Vec::resize and bumpalo::collections::Vec::shrink_to_fit calls.
This bug was introduced in version 3.0.0.
See #69 for details.
Released 2020-02-07.
bumpalo::collections::Vec::into_bump_slice_mut method to turn a bumpalo::collections::Vec<'bump, T> into a &'bump mut [T].Released 2020-01-07.
bumpalo::collections::format! macro did not used to accept a trailing comma like format!(in bump; "{}", 1,), but it does now.Released 2020-01-03.
bumpalo::collections::vec! macro did not used to accept a trailing comma like vec![in bump; 1, 2,], but it does now.Released 2019-12-27.
Bump::allocated_bytes diagnostic method for counting the total number of bytes a Bump has allocated.Released 2019-12-20.
Added Bump::alloc_str for copying string slices into a Bump.
Added Bump::alloc_slice_copy and Bump::alloc_slice_clone for copying or cloning slices into a Bump.
Added Bump::alloc_slice_fill_iter for allocating a slice in the Bump from an iterator.
Added Bump::alloc_slice_fill_copy and Bump::alloc_slice_fill_clone for creating slices of length n that are filled with copies or clones of an initial element.
Added Bump::alloc_slice_fill_default for creating slices of length n with the element type's default instance.
Added Bump::alloc_slice_fill_with for creating slices of length n whose elements are initialized with a function or closure.
Added Bump::iter_allocated_chunks as a replacement for the old Bump::each_allocated_chunk. The iter_allocated_chunks version returns an iterator, which is more idiomatic than its old, callback-taking counterpart. Additionally, iter_allocated_chunks exposes the chunks as MaybeUninits instead of slices, which makes it usable in more situations without triggering undefined behavior. See also the note about bump direction in the “changed” section; if you‘re iterating chunks, you’re likely affected by that change!
Added Bump::with_capacity so that you can pre-allocate a chunk with the requested space.
BREAKING: The direction we allocate within a chunk has changed. It used to be “upwards”, from low addresses within a chunk towards high addresses. It is now “downwards”, from high addresses towards lower addresses.
Additionally, the order in which we iterate over allocated chunks has changed! We used to iterate over chunks from oldest chunk to youngest chunk, and now we do the opposite: the youngest chunks are iterated over first, and the oldest chunks are iterated over last.
If you were using Bump::each_allocated_chunk to iterate over data that you had previously allocated, and you want to iterate in order of oldest-to-youngest allocation, you need to reverse the chunks iterator and also reverse the order in which you loop through the data within a chunk!
For example, if you had this code:
unsafe { bump.each_allocated_chunk(|chunk| { for byte in chunk { // Touch each byte in oldest-to-youngest allocation order... } }); }
It should become this code:
let mut chunks: Vec<_> = bump.iter_allocated_chunks().collect(); chunks.reverse(); for chunk in chunks { for byte in chunk.iter().rev() { let byte = unsafe { byte.assume_init() }; // Touch each byte in oldest-to-youngest allocation order... } }
The good news is that this change yielded a speed up in allocation throughput of 3-19%!
See https://github.com/fitzgen/bumpalo/pull/37 and https://fitzgeraldnick.com/2019/11/01/always-bump-downwards.html for details.
BREAKING: The collections cargo feature is no longer on by default. You must explicitly turn it on if you intend to use the bumpalo::collections module.
Bump::reset will now retain only the last allocated chunk (the biggest), rather than only the first allocated chunk (the smallest). This should enable Bump to better adapt to workload sizes and quickly reach a steady state where new chunks are not requested from the global allocator.
The Bump::each_allocated_chunk method is removed in favor of Bump::iter_allocated_chunks. Note that its safety requirements for reading from the allocated chunks are slightly different from the old each_allocated_chunk: only up to 16-byte alignment is supported now. If you allocate anything with greater alignment than that into the bump arena, there might be uninitilized padding inserted in the chunks, and therefore it is no longer safe to read them via MaybeUninit::assume_init. See also the note about bump direction in the “changed” section; if you‘re iterating chunks, you’re likely affected by that change!
The std cargo feature has been removed, since this crate is now always no-std.
Released 2019-08-19.
Send for Bump.Released 2019-07-01.
alloc_slice_copy and alloc_slice_clone methods that allocate space for slices and either copy (with bound T: Copy) or clone (with bound T: Clone) the provided slice's data into the newly allocated space.Released 2019-05-20.
Released 2019-05-17.
Default for Bump.Released 2019-04-19.
Released 2019-04-19.
reallocing in-place when the pointer being realloced is the last allocation made from the bump arena. This should speed up various String, Vec, and format! operations in many cases.Released 2019-03-26.
alloc_with method, that (usually) avoids stack-allocating the allocated value and then moving it into the bump arena. This avoids potential stack overflows in release mode when allocating very large objects, and also some memcpy calls. This is similar to the copyless crate. Read the alloc_with doc comments and the original issue proposing this API for more.Released 2019-03-18.
Released 2019-03-18.
Released 2019-03-15.
Released 2019-02-12.
into_bump_slice method on bumpalo::collections::Vec<T>.Released 2019-02-11.
BumpAllocSafe trait.Released 2019-01-15.
debug_assert! that had false positives.Released 2018-11-28.
collections module, which contains ports of std's collection types that are compatible with backing their storage in Bump arenas.