Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

Add `wasmtime_core::alloc` functions to allocate uninitialized boxed slices and write iterators into them to initialize them (#12460)

Nick Fitzgeraldc0e42072441b
diff --git a/cranelift/bitset/src/compound.rs b/cranelift/bitset/src/compound.rs
index 5ebe10bf1f..6687aebaed 100644
--- a/cranelift/bitset/src/compound.rs
+++ b/cranelift/bitset/src/compound.rs
@@ -306,10 +306,7 @@ impl<T: ScalarBitSetStorage> CompoundBitSet<T> {
self.elems = new_elems;
Ok(())
}
- Err(wasmtime_core::alloc::BoxedSliceFromIterWithLenError::Oom(oom)) => Err(oom),
- Err(wasmtime_core::alloc::BoxedSliceFromIterWithLenError::TooFewItems) => {
- unreachable!()
- }
+ Err(e) => Err(e.unwrap_oom()),
}
}
diff --git a/crates/core/src/alloc.rs b/crates/core/src/alloc.rs
index 695c8bb398..99751857f9 100644
--- a/crates/core/src/alloc.rs
+++ b/crates/core/src/alloc.rs
@@ -6,9 +6,9 @@ mod try_new;
mod vec;
pub use boxed::{
- BoxedSliceFromFallibleIterError, BoxedSliceFromIterWithLenError,
+ BoxedSliceFromFallibleIterError, TooFewItemsOrOom, boxed_slice_write_iter,
new_boxed_slice_from_fallible_iter, new_boxed_slice_from_iter,
- new_boxed_slice_from_iter_with_len,
+ new_boxed_slice_from_iter_with_len, new_uninit_boxed_slice,
};
pub use try_new::{TryNew, try_new};
pub use vec::Vec;
diff --git a/crates/core/src/alloc/boxed.rs b/crates/core/src/alloc/boxed.rs
index c0d179214a..28e3c788a0 100644
--- a/crates/core/src/alloc/boxed.rs
+++ b/crates/core/src/alloc/boxed.rs
@@ -42,6 +42,32 @@ impl<T> TryNew for Box<T> {
}
}
+/// Allocate a new `Box<[MaybeUninit<T>]>` of the given length with
+/// uninitialized contents, returning `Err(OutOfMemory)` on allocation failure.
+///
+/// You can initialize the resulting boxed slice with
+/// [`boxed_slice_write_iter`].
+pub fn new_uninit_boxed_slice<T>(len: usize) -> Result<Box<[MaybeUninit<T>]>, OutOfMemory> {
+ let layout = Layout::array::<MaybeUninit<T>>(len)
+ .map_err(|_| OutOfMemory::new(mem::size_of::<T>().saturating_mul(len)))?;
+
+ if layout.size() == 0 {
+ // NB: no actual allocation takes place when boxing zero-sized
+ // types.
+ return Ok(Box::new_uninit_slice(len));
+ }
+
+ // Safety: layout size is non-zero.
+ let ptr = unsafe { try_alloc(layout)? };
+
+ let ptr = ptr.cast::<MaybeUninit<T>>().as_ptr();
+ let ptr = core::ptr::slice_from_raw_parts_mut(ptr, len);
+
+ // Safety: The pointer's memory block was allocated by the global allocator
+ // and holds room for `[T; len]`.
+ Ok(unsafe { Box::from_raw(ptr) })
+}
+
use boxed_slice_builder::BoxedSliceBuilder;
mod boxed_slice_builder {
use super::*;
@@ -59,7 +85,17 @@ mod boxed_slice_builder {
pub fn new(len: usize) -> Result<Self, OutOfMemory> {
let mut vec = Vec::new();
vec.reserve_exact(len)?;
- Ok(BoxedSliceBuilder { vec })
+ Ok(Self { vec })
+ }
+
+ pub fn from_boxed_slice(boxed: Box<[MaybeUninit<T>]>) -> Self {
+ let len = boxed.len();
+ let ptr = Box::into_raw(boxed);
+ let ptr = ptr.cast::<T>();
+ // Safety: the pointer was allocated by the global allocator and is
+ // valid for `[T; len]` since it was a boxed slice.
+ let vec = unsafe { Vec::from_raw_parts(ptr, 0, len) };
+ Self { vec }
}
pub fn init_len(&self) -> usize {
@@ -158,25 +194,56 @@ mod boxed_slice_builder {
}
}
+/// An error returned when an iterator yields too few items to fully initialize
+/// a `Box<[MaybeUninit<T>]>`.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy)]
+pub struct TooFewItems;
+
+impl core::fmt::Display for TooFewItems {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ f.write_str("iterator yielded too few items to fully initialize boxed slice")
+ }
+}
+
+impl core::error::Error for TooFewItems {}
+
/// An error returned by [`new_boxed_slice_from_iter`].
#[derive(Debug)]
-pub enum BoxedSliceFromIterWithLenError {
+pub enum TooFewItemsOrOom {
/// The iterator did not yield enough items to fill the boxed slice.
- TooFewItems,
+ TooFewItems(TooFewItems),
/// Failed to allocate space for the boxed slice.
Oom(OutOfMemory),
}
-impl From<OutOfMemory> for BoxedSliceFromIterWithLenError {
+impl TooFewItemsOrOom {
+ /// Unwrap the inner `OutOfMemory` error, or panic if this is a different
+ /// error variant.
+ pub fn unwrap_oom(&self) -> OutOfMemory {
+ match self {
+ TooFewItemsOrOom::TooFewItems(_) => panic!("`unwrap_oom` on non-OOM error"),
+ TooFewItemsOrOom::Oom(oom) => *oom,
+ }
+ }
+}
+
+impl From<TooFewItems> for TooFewItemsOrOom {
+ fn from(e: TooFewItems) -> Self {
+ Self::TooFewItems(e)
+ }
+}
+
+impl From<OutOfMemory> for TooFewItemsOrOom {
fn from(oom: OutOfMemory) -> Self {
Self::Oom(oom)
}
}
-impl core::fmt::Display for BoxedSliceFromIterWithLenError {
+impl core::fmt::Display for TooFewItemsOrOom {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
- Self::TooFewItems => {
+ Self::TooFewItems(_) => {
f.write_str("The iterator did not yield enough items to fill the boxed slice")
}
Self::Oom(_) => f.write_str("Failed to allocate space for the boxed slice"),
@@ -184,15 +251,27 @@ impl core::fmt::Display for BoxedSliceFromIterWithLenError {
}
}
-impl core::error::Error for BoxedSliceFromIterWithLenError {
+impl core::error::Error for TooFewItemsOrOom {
fn cause(&self) -> Option<&dyn core::error::Error> {
match self {
- Self::TooFewItems => None,
+ Self::TooFewItems(e) => Some(e),
Self::Oom(oom) => Some(oom),
}
}
}
+/// Initialize a `Box<[MaybeUninit<T>]>` slice by writing the elements of the
+/// given iterator into it.
+pub fn boxed_slice_write_iter<T>(
+ boxed: Box<[MaybeUninit<T>]>,
+ iter: impl IntoIterator<Item = T>,
+) -> Result<Box<[T]>, TooFewItems> {
+ let len = boxed.len();
+ let builder = BoxedSliceBuilder::from_boxed_slice(boxed);
+ assert_eq!(len, builder.capacity());
+ write_iter_into_builder(builder, iter)
+}
+
/// Create a `Box<[T]>` of length `len` from the given iterator's elements.
///
/// Returns an error on allocation failure, or if `iter` yields fewer than `len`
@@ -203,16 +282,25 @@ impl core::error::Error for BoxedSliceFromIterWithLenError {
pub fn new_boxed_slice_from_iter_with_len<T>(
len: usize,
iter: impl IntoIterator<Item = T>,
-) -> Result<Box<[T]>, BoxedSliceFromIterWithLenError> {
- let mut builder = BoxedSliceBuilder::new(len)?;
+) -> Result<Box<[T]>, TooFewItemsOrOom> {
+ let builder = BoxedSliceBuilder::new(len)?;
assert_eq!(len, builder.capacity());
+ let boxed = write_iter_into_builder(builder, iter)?;
+ Ok(boxed)
+}
+
+fn write_iter_into_builder<T>(
+ mut builder: BoxedSliceBuilder<T>,
+ iter: impl IntoIterator<Item = T>,
+) -> Result<Box<[T]>, TooFewItems> {
+ let len = builder.capacity();
for elem in iter.into_iter().take(len) {
builder.push(elem).expect("reserved capacity");
}
if builder.init_len() < builder.capacity() {
- return Err(BoxedSliceFromIterWithLenError::TooFewItems);
+ return Err(TooFewItems);
}
debug_assert_eq!(builder.init_len(), builder.capacity());
@@ -345,8 +433,8 @@ mod tests {
let (c_dropped, c) = SetFlagOnDrop::new();
match new_boxed_slice_from_iter_with_len(4, [a, b, c]) {
- Err(BoxedSliceFromIterWithLenError::TooFewItems) => {}
- Ok(_) | Err(BoxedSliceFromIterWithLenError::Oom(_)) => unreachable!(),
+ Err(TooFewItemsOrOom::TooFewItems(_)) => {}
+ Ok(_) | Err(TooFewItemsOrOom::Oom(_)) => unreachable!(),
}
assert!(a_dropped.get());
@@ -394,4 +482,54 @@ mod tests {
};
assert_eq!(err, 30);
}
+
+ #[test]
+ fn new_uninit_boxed_slice_smoke_test() {
+ let slice = new_uninit_boxed_slice::<u32>(5).unwrap();
+ assert_eq!(slice.len(), 5);
+ }
+
+ #[test]
+ fn boxed_slice_write_iter_smoke_test() {
+ let uninit = new_uninit_boxed_slice(3).unwrap();
+ let init = boxed_slice_write_iter(uninit, [10, 20, 30]).unwrap();
+ assert_eq!(&*init, &[10, 20, 30]);
+ }
+
+ #[test]
+ fn boxed_slice_write_iter_with_too_few_elems() {
+ let (a_dropped, a) = SetFlagOnDrop::new();
+ let (b_dropped, b) = SetFlagOnDrop::new();
+ let (c_dropped, c) = SetFlagOnDrop::new();
+
+ let uninit = new_uninit_boxed_slice(4).unwrap();
+ match boxed_slice_write_iter(uninit, [a, b, c]) {
+ Err(_) => {}
+ Ok(_) => unreachable!(),
+ }
+
+ assert!(a_dropped.get());
+ assert!(b_dropped.get());
+ assert!(c_dropped.get());
+ }
+
+ #[test]
+ fn boxed_slice_write_iter_with_too_many_elems() {
+ let (a_dropped, a) = SetFlagOnDrop::new();
+ let (b_dropped, b) = SetFlagOnDrop::new();
+ let (c_dropped, c) = SetFlagOnDrop::new();
+
+ let uninit = new_uninit_boxed_slice(2).unwrap();
+ let slice = boxed_slice_write_iter(uninit, [a, b, c]).unwrap();
+
+ assert!(!a_dropped.get());
+ assert!(!b_dropped.get());
+ assert!(c_dropped.get());
+
+ drop(slice);
+
+ assert!(a_dropped.get());
+ assert!(b_dropped.get());
+ assert!(c_dropped.get());
+ }
}