Skip to content

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

Add some fallible allocation methods to `cranelift_entity::SecondaryMap` (#12453)

Nick Fitzgerald63ecb815c34c
diff --git a/cranelift/entity/src/map.rs b/cranelift/entity/src/map.rs
index 34ce35c778..965f8ac9f7 100644
--- a/cranelift/entity/src/map.rs
+++ b/cranelift/entity/src/map.rs
@@ -15,6 +15,7 @@ use serde::{
de::{Deserializer, SeqAccess, Visitor},
ser::{SerializeSeq, Serializer},
};
+use wasmtime_core::error::OutOfMemory;
/// A mapping `K -> V` for densely indexed entity references.
///
@@ -67,6 +68,22 @@ where
}
}
+ /// Like `with_capacity` but returns an error on allocation failure.
+ pub fn try_with_capacity(capacity: usize) -> Result<Self, OutOfMemory>
+ where
+ V: Default,
+ {
+ let mut elems = Vec::new();
+ elems
+ .try_reserve(capacity)
+ .map_err(|_| OutOfMemory::new(core::mem::size_of::<V>().saturating_mul(capacity)))?;
+ Ok(Self {
+ elems,
+ default: Default::default(),
+ unused: PhantomData,
+ })
+ }
+
/// Create a new empty map with a specified default value.
///
/// This constructor does not require V to implement Default.
@@ -89,6 +106,35 @@ where
self.elems.get(k.index())
}
+ /// Get the element at `k` mutably, if it exists.
+ pub fn get_mut(&mut self, k: K) -> Option<&mut V> {
+ self.elems.get_mut(k.index())
+ }
+
+ /// Insert the given key-value pair, returning the old value if it exists.
+ pub fn insert(&mut self, k: K, v: V) -> Option<V> {
+ let i = k.index();
+ if i < self.elems.len() {
+ Some(core::mem::replace(&mut self.elems[i], v))
+ } else {
+ self.resize(i + 1);
+ self.elems[i] = v;
+ None
+ }
+ }
+
+ /// Like `insert` but returns an error on allocation failure.
+ pub fn try_insert(&mut self, k: K, v: V) -> Result<Option<V>, OutOfMemory> {
+ let i = k.index();
+ if i < self.elems.len() {
+ Ok(Some(core::mem::replace(&mut self.elems[i], v)))
+ } else {
+ self.try_resize(i + 1)?;
+ self.elems[i] = v;
+ Ok(None)
+ }
+ }
+
/// Is this map completely empty?
#[inline(always)]
pub fn is_empty(&self) -> bool {
@@ -131,6 +177,18 @@ where
self.elems.resize(n, self.default.clone());
}
+ /// Like `resize` but returns an error on allocation failure.
+ pub fn try_resize(&mut self, n: usize) -> Result<(), OutOfMemory> {
+ if self.elems.capacity() < n {
+ self.elems
+ .try_reserve(n - self.elems.len())
+ .map_err(|_| OutOfMemory::new(core::mem::size_of::<V>().saturating_mul(n)))?;
+ }
+ debug_assert!(self.elems.capacity() >= n);
+ self.elems.resize(n, self.default.clone());
+ Ok(())
+ }
+
/// Slow path for `index_mut` which resizes the vector.
#[cold]
fn resize_for_index_mut(&mut self, i: usize) -> &mut V {
@@ -331,6 +389,7 @@ mod tests {
let r0 = E(0);
let r1 = E(1);
let r2 = E(2);
+ let r3 = E(3);
let mut m = SecondaryMap::new();
let v: Vec<E> = m.keys().collect();
@@ -342,12 +401,30 @@ mod tests {
assert_eq!(m[r1], 5);
assert_eq!(m[r2], 3);
+ assert!(m.get(r3).is_none());
+ assert!(m.get_mut(r3).is_none());
+
+ let old = m.insert(r3, 99);
+ assert!(old.is_none());
+ assert_eq!(m.get(r3), Some(&99));
+ assert_eq!(m[r3], 99);
+
+ *m.get_mut(r3).unwrap() += 1;
+ assert_eq!(m.get(r3), Some(&100));
+ assert_eq!(m[r3], 100);
+
+ let old = m.insert(r3, 42);
+ assert_eq!(old, Some(100));
+ assert_eq!(m.get(r3), Some(&42));
+ assert_eq!(m[r3], 42);
+
let v: Vec<E> = m.keys().collect();
- assert_eq!(v, [r0, r1, r2]);
+ assert_eq!(v, [r0, r1, r2, r3]);
let shared = &m;
assert_eq!(shared[r0], 0);
assert_eq!(shared[r1], 5);
assert_eq!(shared[r2], 3);
+ assert_eq!(shared[r3], 42);
}
}
diff --git a/crates/fuzzing/tests/oom.rs b/crates/fuzzing/tests/oom.rs
index 17d1b8b0b4..2e022e5aef 100644
--- a/crates/fuzzing/tests/oom.rs
+++ b/crates/fuzzing/tests/oom.rs
@@ -5,7 +5,7 @@ use std::{
sync::atomic::{AtomicU32, Ordering::SeqCst},
};
use wasmtime::{error::OutOfMemory, *};
-use wasmtime_environ::{PrimaryMap, collections::*};
+use wasmtime_environ::{PrimaryMap, SecondaryMap, collections::*};
use wasmtime_fuzzing::oom::{OomTest, OomTestAllocator};
#[global_allocator]
@@ -68,12 +68,12 @@ fn compound_bit_set_try_ensure_capacity() -> Result<()> {
})
}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct Key(u32);
+wasmtime_environ::entity_impl!(Key);
+
#[test]
fn primary_map_try_with_capacity() -> Result<()> {
- #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
- struct Key(u32);
- wasmtime_environ::entity_impl!(Key);
-
OomTest::new().test(|| {
let _map = PrimaryMap::<Key, u32>::try_with_capacity(32)?;
Ok(())
@@ -82,10 +82,6 @@ fn primary_map_try_with_capacity() -> Result<()> {
#[test]
fn primary_map_try_reserve() -> Result<()> {
- #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
- struct Key(u32);
- wasmtime_environ::entity_impl!(Key);
-
OomTest::new().test(|| {
let mut map = PrimaryMap::<Key, u32>::new();
map.try_reserve(100)?;
@@ -95,10 +91,6 @@ fn primary_map_try_reserve() -> Result<()> {
#[test]
fn primary_map_try_reserve_exact() -> Result<()> {
- #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
- struct Key(u32);
- wasmtime_environ::entity_impl!(Key);
-
OomTest::new().test(|| {
let mut map = PrimaryMap::<Key, u32>::new();
map.try_reserve_exact(13)?;
@@ -106,6 +98,32 @@ fn primary_map_try_reserve_exact() -> Result<()> {
})
}
+#[test]
+fn secondary_map_try_with_capacity() -> Result<()> {
+ OomTest::new().test(|| {
+ let _map = SecondaryMap::<Key, u32>::try_with_capacity(32)?;
+ Ok(())
+ })
+}
+
+#[test]
+fn secondary_map_try_resize() -> Result<()> {
+ OomTest::new().test(|| {
+ let mut map = SecondaryMap::<Key, u32>::new();
+ map.try_resize(100)?;
+ Ok(())
+ })
+}
+
+#[test]
+fn secondary_map_try_insert() -> Result<()> {
+ OomTest::new().test(|| {
+ let mut map = SecondaryMap::<Key, u32>::new();
+ map.try_insert(Key::from_u32(42), 100)?;
+ Ok(())
+ })
+}
+
#[test]
fn vec_with_capacity() -> Result<()> {
OomTest::new().test(|| {