Commit b0aa3bc

/// Keeps allocation work out of the inline fast path in [`Self::reserve`].

///

/// Buffer capacity measures the space available from the data pointer. The allocation also

/// includes any bytes before that pointer, which can come from alignment padding or slicing.

/// The new layout follows the buffer growth policy without retaining that old prefix.

///

/// For a byte buffer:

///

/// ```text

/// Before reserve(100): allocation = 1,000 bytes, capacity = 100 bytes.

/// | 900 bytes before slice | 100 data |

/// ^ data pointer

///

/// After reserve(100): allocation = 257 bytes, capacity = 256 bytes.

/// | 100 data | 156 spare | 1 unused |

/// ^ data pointer

/// ```

///

/// [`Allocator::grow`] requires the new allocation to be at least as large as the entire old

/// allocation. If the new layout is smaller, allocate a separate block and copy the initialized

/// data instead of violating that safety contract.

///

/// [`Allocator::grow`]: allocator_api2::alloc::Allocator::grow

let required_capacity = self

let required_bytes = required_capacity

let capacity_bytes = self

let new_capacity_bytes = required_bytes

.max(capacity_bytes.saturating_mul(2))

// Reserve space before the data so its pointer can satisfy the buffer's alignment.

let data_alignment = self.alignment.as_usize();

let new_allocation_bytes = new_capacity_bytes

.checked_add(data_alignment)

let new_layout = Layout::from_size_align(new_allocation_bytes, allocation_alignment)

let initialized_bytes = self.length * size_of::<T>();

// The default global allocator (`is_statically_allocated`) uses allocate-and-copy. Custom

// allocators must also allocate and copy when the new layout is smaller, because

// `Allocator::grow` forbids shrinking.

let needs_new_allocation = self.allocation.allocator().is_statically_allocated()

|| new_layout.size() < self.allocation.size();

let data_offset = if needs_new_allocation {

let new_allocation =

Allocation::allocate(new_layout, self.allocation.allocator().clone());

let new_data_offset = new_allocation.ptr().as_ptr().align_offset(data_alignment);

// SAFETY: self.ptr addresses initialized_bytes of live data. The new allocation has

// room for those bytes after alignment padding and is disjoint from the old allocation.

new_allocation.ptr().as_ptr().add(new_data_offset),

initialized_bytes,

self.allocation = new_allocation;

new_data_offset

let old_data_offset =

self.ptr.cast::<u8>().addr().get() - self.allocation.ptr().addr().get();

self.allocation.grow(new_layout);

let new_data_offset = self.allocation.ptr().as_ptr().align_offset(data_alignment);

if new_data_offset != old_data_offset {

// SAFETY: grow preserved initialized_bytes at old_data_offset. The reserved padding

// leaves room for the data at new_data_offset, and copy permits overlap.

self.allocation.ptr().as_ptr().add(old_data_offset),

self.allocation.ptr().as_ptr().add(new_data_offset),

initialized_bytes,

new_data_offset

// SAFETY: data_offset satisfies the required alignment and leaves new_capacity_bytes

// available within the allocation.

self.ptr = unsafe { self.allocation.ptr().add(data_offset).cast() };

self.capacity = new_capacity_bytes / size_of::<T>();

#[test]

fn growth_of_sliced_buffer_preserves_allocator_and_values() {

let allocator = BufferAllocatorRef::new(Global);

let mut buffer = BufferMut::<u32>::with_capacity_preferred_aligned_in(

1024,

Alignment::of::<u32>(),

None,

allocator.clone(),

);

buffer.extend_from_slice(&[7; 1024]);

let sliced_ptr = buffer.as_ptr().wrapping_add(1016);

let sliced = buffer.freeze().slice(1016..);

let mut buffer = sliced.try_into_mut().unwrap();

assert_eq!(buffer.as_ptr(), sliced_ptr);

// The slice retains a large backing allocation, but needs only a small capacity increase.

buffer.extend_from_slice(&[8; 16]);

assert!(buffer.allocator().ptr_eq(&allocator));

assert_eq!(&buffer[..8], &[7; 8]);

assert_eq!(&buffer[8..], &[8; 16]);

}