Skip to content

Commit 3bcb73a

Browse files
perf: keep lazy memory virtual
Signed-off-by: Henry <mail@henrygressmann.de>
1 parent 4d66c97 commit 3bcb73a

4 files changed

Lines changed: 86 additions & 123 deletions

File tree

‎crates/tinywasm/src/instance.rs‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -174,7 +174,10 @@ impl ModuleInstance {
174174
addrs.funcs.extend(store.init_funcs(&module.funcs, idx));
175175
addrs.tables.extend(store.init_tables(&module.table_types)?);
176176
match module.local_memory_allocation {
177-
LocalMemoryAllocation::Skip => {}
177+
LocalMemoryAllocation::Skip => {
178+
#[cfg(feature = "guest-debug")]
179+
addrs.memories.extend(store.init_memories(&module.memory_types, MemoryInstance::new_lazy)?);
180+
}
178181
LocalMemoryAllocation::Lazy => {
179182
addrs.memories.extend(store.init_memories(&module.memory_types, MemoryInstance::new_lazy)?)
180183
}
Lines changed: 66 additions & 116 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,4 @@
11
use alloc::boxed::Box;
2-
use alloc::vec::Vec;
3-
use core::cell::RefCell;
42
use core::hint::cold_path;
53

64
use tinywasm_types::MemoryType;
@@ -9,167 +7,119 @@ use crate::{Error, MemoryBackend, Result};
97

108
use super::LinearMemory;
119

12-
/// A linear memory wrapper that materializes its inner backend on first access.
10+
/// A linear memory wrapper that allocates its backend on the first mutation.
1311
///
14-
/// If the wrapped backend fails to create the inner memory during first access,
15-
/// this wrapper will panic.
12+
/// Before materialization, the memory is represented by its logical length and
13+
/// reads return the zeroes required by WebAssembly semantics.
1614
pub struct LazyLinearMemory {
1715
ty: MemoryType,
1816
initial_len: usize,
1917
backend: MemoryBackend,
20-
inner: RefCell<Option<Box<dyn LinearMemory>>>,
18+
inner: Option<Box<dyn LinearMemory>>,
2119
}
2220

2321
impl LazyLinearMemory {
24-
/// Creates a lazy memory for `ty` using `backend` for the eventual materialized storage.
22+
/// Creates a lazy memory for `ty` using `backend` for eventual storage.
2523
pub fn try_new(ty: MemoryType, backend: MemoryBackend) -> Result<Self> {
2624
let initial_len = usize::try_from(ty.initial_size())
2725
.map_err(|_| Error::UnsupportedFeature("memory size exceeds the host address space"))?;
2826
Ok(Self::new_with_initial_len(ty, initial_len, backend))
2927
}
3028

3129
pub(crate) fn new_with_initial_len(ty: MemoryType, initial_len: usize, backend: MemoryBackend) -> Self {
32-
Self { ty, initial_len, backend, inner: RefCell::new(None) }
30+
Self { ty, initial_len, backend, inner: None }
3331
}
3432

35-
fn with_inner<R>(&self, f: impl FnOnce(&dyn LinearMemory) -> R) -> R {
36-
self.ensure_materialized();
37-
let inner = self.inner.borrow();
38-
f(inner.as_deref().expect("lazy memory should be materialized"))
39-
}
40-
41-
fn try_with_inner<R>(&self, f: impl FnOnce(&dyn LinearMemory) -> R) -> core::result::Result<R, crate::Trap> {
42-
self.try_ensure_materialized()?;
43-
let inner = self.inner.borrow();
44-
Ok(f(inner.as_deref().expect("lazy memory should be materialized")))
45-
}
46-
47-
fn with_inner_mut<R>(&self, f: impl FnOnce(&mut dyn LinearMemory) -> R) -> R {
48-
self.ensure_materialized();
49-
let mut inner = self.inner.borrow_mut();
50-
f(inner.as_deref_mut().expect("lazy memory should be materialized"))
51-
}
52-
53-
fn try_with_inner_mut<R>(
54-
&self,
55-
f: impl FnOnce(&mut dyn LinearMemory) -> R,
56-
) -> core::result::Result<R, crate::Trap> {
57-
self.try_ensure_materialized()?;
58-
let mut inner = self.inner.borrow_mut();
59-
Ok(f(inner.as_deref_mut().expect("lazy memory should be materialized")))
60-
}
61-
62-
fn ensure_materialized(&self) {
63-
if self.inner.borrow().is_some() {
64-
return;
33+
fn materialize(&mut self) -> &mut dyn LinearMemory {
34+
if self.inner.is_none() {
35+
self.inner =
36+
Some(self.backend.create(self.ty, self.initial_len).expect("lazy memory materialization failed").0);
6537
}
66-
67-
let storage = self.backend.create(self.ty, self.initial_len).expect("lazy memory materialization failed");
68-
*self.inner.borrow_mut() = Some(storage.0);
69-
}
70-
71-
fn try_ensure_materialized(&self) -> core::result::Result<(), crate::Trap> {
72-
if self.inner.borrow().is_some() {
73-
return Ok(());
38+
self.inner.as_deref_mut().expect("lazy memory should be materialized")
39+
}
40+
41+
fn try_materialize(&mut self) -> core::result::Result<&mut dyn LinearMemory, crate::Trap> {
42+
if self.inner.is_none() {
43+
let storage = match self.backend.create(self.ty, self.initial_len) {
44+
Ok(storage) => storage,
45+
Err(Error::Trap(trap)) => {
46+
cold_path();
47+
return Err(trap);
48+
}
49+
Err(err) => panic!("lazy memory materialization failed: {err}"),
50+
};
51+
self.inner = Some(storage.0);
7452
}
75-
76-
let storage = match self.backend.create(self.ty, self.initial_len) {
77-
Ok(storage) => storage,
78-
Err(Error::Trap(trap)) => {
79-
cold_path();
80-
return Err(trap);
81-
}
82-
Err(err) => panic!("lazy memory materialization failed: {err}"),
83-
};
84-
*self.inner.borrow_mut() = Some(storage.0);
85-
Ok(())
53+
Ok(self.inner.as_deref_mut().expect("lazy memory should be materialized"))
8654
}
8755
}
8856

8957
impl LinearMemory for LazyLinearMemory {
9058
fn len(&self) -> usize {
91-
self.with_inner(|inner| inner.len())
59+
self.inner.as_deref().map_or(self.initial_len, LinearMemory::len)
9260
}
9361

9462
fn grow_to(&mut self, new_len: usize) -> Result<(), crate::Trap> {
95-
self.try_with_inner_mut(|inner| inner.grow_to(new_len))?
63+
self.try_materialize()?.grow_to(new_len)
9664
}
9765

9866
fn read(&self, addr: usize, dst: &mut [u8]) -> usize {
99-
self.with_inner(|inner| inner.read(addr, dst))
67+
if let Some(inner) = self.inner.as_deref() {
68+
return inner.read(addr, dst);
69+
}
70+
if addr >= self.initial_len {
71+
return 0;
72+
}
73+
let read_len = dst.len().min(self.initial_len - addr);
74+
dst[..read_len].fill(0);
75+
read_len
10076
}
10177

10278
fn write(&mut self, addr: usize, src: &[u8]) -> usize {
103-
self.with_inner_mut(|inner| inner.write(addr, src))
79+
if src.is_empty() || addr >= self.len() {
80+
return 0;
81+
}
82+
self.materialize().write(addr, src)
10483
}
10584

10685
fn write_all(&mut self, addr: usize, src: &[u8]) -> Option<()> {
107-
self.with_inner_mut(|inner| inner.write_all(addr, src))
86+
let end = addr.checked_add(src.len())?;
87+
if end > self.len() {
88+
return None;
89+
}
90+
if src.is_empty() {
91+
return Some(());
92+
}
93+
self.materialize().write_all(addr, src)
10894
}
10995

11096
fn fill(&mut self, addr: usize, len: usize, val: u8) -> Option<()> {
111-
self.with_inner_mut(|inner| inner.fill(addr, len, val))
97+
let end = addr.checked_add(len)?;
98+
if end > self.len() {
99+
return None;
100+
}
101+
if len == 0 || val == 0 && self.inner.is_none() {
102+
return Some(());
103+
}
104+
self.materialize().fill(addr, len, val)
112105
}
113106

114107
fn copy_within(&mut self, dst: usize, src: usize, len: usize) -> Option<()> {
115-
self.with_inner_mut(|inner| inner.copy_within(dst, src, len))
116-
}
117-
118-
fn read_exact(&self, addr: usize, dst: &mut [u8]) -> Option<()> {
119-
self.with_inner(|inner| inner.read_exact(addr, dst))
120-
}
121-
122-
fn read_vec(&self, addr: usize, len: usize) -> Option<Vec<u8>> {
123-
self.with_inner(|inner| inner.read_vec(addr, len))
124-
}
125-
126-
fn read_8(&self, base: u64, offset: u64) -> core::result::Result<u8, crate::Trap> {
127-
self.try_with_inner(|inner| inner.read_8(base, offset))?
128-
}
129-
130-
fn read_16(&self, base: u64, offset: u64) -> core::result::Result<[u8; 2], crate::Trap> {
131-
self.try_with_inner(|inner| inner.read_16(base, offset))?
132-
}
133-
134-
fn read_32(&self, base: u64, offset: u64) -> core::result::Result<[u8; 4], crate::Trap> {
135-
self.try_with_inner(|inner| inner.read_32(base, offset))?
136-
}
137-
138-
fn read_64(&self, base: u64, offset: u64) -> core::result::Result<[u8; 8], crate::Trap> {
139-
self.try_with_inner(|inner| inner.read_64(base, offset))?
140-
}
141-
142-
fn read_128(&self, base: u64, offset: u64) -> core::result::Result<[u8; 16], crate::Trap> {
143-
self.try_with_inner(|inner| inner.read_128(base, offset))?
144-
}
145-
146-
fn write_8(&mut self, base: u64, offset: u64, byte: u8) -> core::result::Result<(), crate::Trap> {
147-
self.try_with_inner_mut(|inner| inner.write_8(base, offset, byte))?
148-
}
149-
150-
fn write_16(&mut self, base: u64, offset: u64, bytes: [u8; 2]) -> core::result::Result<(), crate::Trap> {
151-
self.try_with_inner_mut(|inner| inner.write_16(base, offset, bytes))?
152-
}
153-
154-
fn write_32(&mut self, base: u64, offset: u64, bytes: [u8; 4]) -> core::result::Result<(), crate::Trap> {
155-
self.try_with_inner_mut(|inner| inner.write_32(base, offset, bytes))?
156-
}
157-
158-
fn write_64(&mut self, base: u64, offset: u64, bytes: [u8; 8]) -> core::result::Result<(), crate::Trap> {
159-
self.try_with_inner_mut(|inner| inner.write_64(base, offset, bytes))?
160-
}
161-
162-
fn write_128(&mut self, base: u64, offset: u64, bytes: [u8; 16]) -> core::result::Result<(), crate::Trap> {
163-
self.try_with_inner_mut(|inner| inner.write_128(base, offset, bytes))?
108+
let src_end = src.checked_add(len)?;
109+
let dst_end = dst.checked_add(len)?;
110+
if src_end > self.len() || dst_end > self.len() {
111+
return None;
112+
}
113+
if self.inner.is_none() || len == 0 || dst == src {
114+
return Some(());
115+
}
116+
self.materialize().copy_within(dst, src, len)
164117
}
165118
}
166119

167120
#[cfg(feature = "debug")]
168121
impl core::fmt::Debug for LazyLinearMemory {
169122
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
170-
f.debug_struct("LazyLinearMemory")
171-
.field("ty", &self.ty)
172-
.field("materialized", &self.inner.borrow().is_some())
173-
.finish()
123+
f.debug_struct("LazyLinearMemory").field("ty", &self.ty).field("materialized", &self.inner.is_some()).finish()
174124
}
175125
}

‎crates/tinywasm/src/store/mod.rs‎

Lines changed: 9 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -281,12 +281,17 @@ impl Store {
281281
pub(crate) fn init_memories(
282282
&mut self,
283283
memories: &[MemoryType],
284-
init: fn(MemoryType, &MemoryBackend) -> Result<MemoryInstance>,
284+
init: impl Fn(MemoryType, &MemoryBackend) -> Result<MemoryInstance>,
285285
) -> Result<impl ExactSizeIterator<Item = MemAddr>> {
286286
let start = self.state.memories.len() as MemAddr;
287-
self.state.memories.reserve_exact(memories.len());
288-
for &mem in memories {
289-
self.state.memories.push(init(mem, &self.engine.config().memory_backend)?);
287+
for mem in memories {
288+
self.state.memories.push(match init(*mem, &self.engine.config().memory_backend) {
289+
Ok(mem) => mem,
290+
Err(e) => {
291+
cold_path();
292+
return Err(e);
293+
}
294+
});
290295
}
291296
Ok(start..start + memories.len() as MemAddr)
292297
}

‎crates/tinywasm/tests/memory_backends.rs‎

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -129,8 +129,8 @@ fn exported_local_memory_is_not_eagerly_allocated() -> Result<()> {
129129
}
130130

131131
#[test]
132-
fn exported_local_memory_materializes_on_first_method_call() -> Result<()> {
133-
let (store, instance, created) = instantiate_exported_memory_with_counting_backend(
132+
fn exported_local_memory_reads_zeroes_without_materializing() -> Result<()> {
133+
let (mut store, instance, created) = instantiate_exported_memory_with_counting_backend(
134134
r#"
135135
(module
136136
(memory (export "memory") 1)
@@ -141,7 +141,12 @@ fn exported_local_memory_materializes_on_first_method_call() -> Result<()> {
141141
let memory = instance.memory("memory")?;
142142
assert_eq!(created.load(Ordering::Relaxed), 0);
143143
assert_eq!(memory.len(&store)?, 65536);
144+
assert_eq!(memory.read_vec(&store, 65534, 2)?, &[0, 0]);
145+
assert_eq!(created.load(Ordering::Relaxed), 0);
146+
147+
memory.copy_from_slice(&mut store, 65534, &[1, 2])?;
144148
assert_eq!(created.load(Ordering::Relaxed), 1);
149+
assert_eq!(memory.read_vec(&store, 65534, 2)?, &[1, 2]);
145150
Ok(())
146151
}
147152

0 commit comments

Comments
 (0)