aixiao/denyhosts
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
315a368012
denyhosts/clamav/libclamav_rust/.cargo/vendor/bumpalo/CHANGELOG.md

19 KiB
Raw Blame History

Unreleased

Released YYYY-MM-DD.

Added

  • TODO (or remove section if none)

Changed

  • TODO (or remove section if none)

Deprecated

  • TODO (or remove section if none)

Removed

  • TODO (or remove section if none)

Fixed

  • TODO (or remove section if none)

Security

  • TODO (or remove section if none)

3.11.1

Released 2022-10-18.

Security

  • Fixed a bug where when 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.

3.11.0

Released 2022-08-17.

Added

  • Added support for per-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.
  • Added the bumpalo::boxed::Box::into_inner method.

Changed

  • Updated to Rust 2021 edition.
  • The minimum supported Rust version (MSRV) is now 1.56.0.

3.10.0

Released 2022-06-01.

Added

  • Implement bumpalo::collections::FromIteratorIn for Option and Result, just like core does for FromIterator.
  • Implement bumpalo::collections::FromIteratorIn for bumpalo::boxed::Box<'a, [T]>.
  • Added running tests under MIRI in CI for additional confidence in unsafe code.
  • Publicly exposed bumpalo::collections::Vec::drain_filter since the corresponding std::vec::Vec method has stabilized.

Changed

  • Bump::new will not allocate a backing chunk until the first allocation inside the bump arena now.

Fixed

  • Properly account for alignment changes when growing or shrinking an existing allocation.
  • Removed all internal integer-to-pointer casts, to play better with UB checkers like MIRI.

3.9.1

Released 2022-01-06.

Fixed

  • Fixed link to logo in docs and README.md

3.9.0

Released 2022-01-05.

Changed

  • 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]>.

3.8.0

Released 2021-10-19.

Added

  • 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.

3.7.1

Released 2021-09-17.

Changed

  • The packaged crate uploaded to crates.io when bumpalo is published is now smaller, thanks to excluding unnecessary files.

3.7.0

Released 2020-05-28.

Added

  • Added Borrow and BorrowMut trait implementations for bumpalo::collections::Vec and bumpalo::collections::String. #108

Changed

  • When allocating a new chunk fails, don't immediately give up. Instead, try allocating a chunk that is half that size, and if that fails, then try half of that size, etc until either we successfully allocate a chunk or we fail to allocate the minimum chunk size and then finally give up. #111

3.6.1

Released 2020-02-18.

Added

  • Improved performance of Bump's Allocator::grow_zeroed trait method implementation. #99

3.6.0

Released 2020-01-29.

Added

  • 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!

3.5.0

Released 2020-01-22.

Added

  • 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.

3.4.0

Released 2020-06-01.

Added

  • Added the 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.

3.3.0

Released 2020-05-13.

Added

  • 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]

3.2.1

Released 2020-03-24.

Security

  • 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:

    1. 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.

    2. 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.

3.2.0

Released 2020-02-07.

Added

  • Added the bumpalo::collections::Vec::into_bump_slice_mut method to turn a bumpalo::collections::Vec<'bump, T> into a &'bump mut [T].

3.1.2

Released 2020-01-07.

Fixed

  • The bumpalo::collections::format! macro did not used to accept a trailing comma like format!(in bump; "{}", 1,), but it does now.

3.1.1

Released 2020-01-03.

Fixed

  • The bumpalo::collections::vec! macro did not used to accept a trailing comma like vec![in bump; 1, 2,], but it does now.

3.1.0

Released 2019-12-27.

Added

  • Added the Bump::allocated_bytes diagnostic method for counting the total number of bytes a Bump has allocated.

3.0.0

Released 2019-12-20.

Added

  • 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.

Changed

  • 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.

Removed

  • 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.

Fixed

  • Fixed a bug involving potential integer overflows with large requested allocation sizes.

2.6.0

Released 2019-08-19.

  • Implement Send for Bump.

2.5.0

Released 2019-07-01.

  • Add 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.

2.4.3

Released 2019-05-20.

  • Fixed a bug where chunks were always deallocated with the default chunk layout, not the layout that the chunk was actually allocated with (i.e. if we started growing largers chunks with larger layouts, we would deallocate those chunks with an incorrect layout).

2.4.2

Released 2019-05-17.

  • Added an implementation Default for Bump.
  • Made it so that if bump allocation within a chunk overflows, we still try to allocate a new chunk to bump out of for the requested allocation. This can avoid some OOMs in scenarios where the chunk we are currently allocating out of is very near the high end of the address space, and there is still available address space lower down for new chunks.

2.4.1

Released 2019-04-19.

  • Added readme metadata to Cargo.toml so it shows up on crates.io

2.4.0

Released 2019-04-19.

  • Added support for 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.

2.3.0

Released 2019-03-26.

  • Add the 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.

2.2.2

Released 2019-03-18.

  • Fix a regression from 2.2.1 where chunks were not always aligned to the chunk footer's alignment.

2.2.1

Released 2019-03-18.

  • Fix a regression in 2.2.0 where newly allocated bump chunks could fail to have capacity for a large requested bump allocation in some corner cases.

2.2.0

Released 2019-03-15.

  • Chunks in an arena now start out small, and double in size as more chunks are requested.

2.1.0

Released 2019-02-12.

  • Added the into_bump_slice method on bumpalo::collections::Vec<T>.

2.0.0

Released 2019-02-11.

  • Removed the BumpAllocSafe trait.
  • Correctly detect overflows from large allocations and panic.

1.2.0

Released 2019-01-15.

  • Fixed an overly-aggressive debug_assert! that had false positives.
  • Ported to Rust 2018 edition.

1.1.0

Released 2018-11-28.

  • Added the collections module, which contains ports of std's collection types that are compatible with backing their storage in Bump arenas.
  • Lifted the limits on size and alignment of allocations.

1.0.2

1.0.1

1.0.0