chore: improve value stack

Signed-off-by: Henry Gressmann <mail@henrygressmann.de>

Author: explodingcamera

benchmarks/benches/fibonacci.rs

@@ -46,21 +46,21 @@ fn run_native_recursive(n: i32) -> i32 {
 
 const FIBONACCI: &[u8] = include_bytes!("../../examples/rust/out/fibonacci.wasm");
 fn criterion_benchmark(c: &mut Criterion) {
-    {
-        let mut group = c.benchmark_group("fibonacci");
-        group.bench_function("native", |b| b.iter(|| run_native(black_box(60))));
-        group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(FIBONACCI, black_box(60), "fibonacci")));
-        group.bench_function("wasmi", |b| b.iter(|| run_wasmi(FIBONACCI, black_box(60), "fibonacci")));
-        group.bench_function("wasmer", |b| b.iter(|| run_wasmer(FIBONACCI, black_box(60), "fibonacci")));
-    }
+    // {
+    //     let mut group = c.benchmark_group("fibonacci");
+    //     group.bench_function("native", |b| b.iter(|| run_native(black_box(60))));
+    //     group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(FIBONACCI, black_box(60), "fibonacci")));
+    //     group.bench_function("wasmi", |b| b.iter(|| run_wasmi(FIBONACCI, black_box(60), "fibonacci")));
+    //     group.bench_function("wasmer", |b| b.iter(|| run_wasmer(FIBONACCI, black_box(60), "fibonacci")));
+    // }
 
     {
         let mut group = c.benchmark_group("fibonacci-recursive");
         group.measurement_time(std::time::Duration::from_secs(5));
-        group.bench_function("native", |b| b.iter(|| run_native_recursive(black_box(26))));
+        // group.bench_function("native", |b| b.iter(|| run_native_recursive(black_box(26))));
         group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(FIBONACCI, black_box(26), "fibonacci_recursive")));
-        group.bench_function("wasmi", |b| b.iter(|| run_wasmi(FIBONACCI, black_box(26), "fibonacci_recursive")));
-        group.bench_function("wasmer", |b| b.iter(|| run_wasmer(FIBONACCI, black_box(26), "fibonacci_recursive")));
+        // group.bench_function("wasmi", |b| b.iter(|| run_wasmi(FIBONACCI, black_box(26), "fibonacci_recursive")));
+        // group.bench_function("wasmer", |b| b.iter(|| run_wasmer(FIBONACCI, black_box(26), "fibonacci_recursive")));
     }
 }
 

crates/parser/Cargo.toml

@@ -16,3 +16,4 @@ tinywasm-types={version="0.7.0", path="../types", default-features=false}
 default=["std", "logging"]
 logging=["log"]
 std=["tinywasm-types/std", "wasmparser/std"]
+nightly=[]

crates/tinywasm/Cargo.toml

@@ -34,7 +34,7 @@ std=["tinywasm-parser?/std", "tinywasm-types/std"]
 parser=["tinywasm-parser"]
 archive=["tinywasm-types/archive"]
 simd=[]
-nightly=[]
+nightly=["tinywasm-parser?/nightly"]
 
 [[test]]
 name="test-mvp"

crates/tinywasm/src/boxvec.rs

@@ -0,0 +1,120 @@
+use crate::unlikely;
+use alloc::{borrow::Cow, boxed::Box, vec};
+use core::ops::RangeBounds;
+
+// A Vec-like type that doesn't deallocate memory when popping elements.
+#[derive(Debug)]
+pub(crate) struct BoxVec<T> {
+    pub(crate) data: Box<[T]>,
+    pub(crate) end: usize,
+}
+
+impl<T: Copy + Default> BoxVec<T> {
+    #[inline(always)]
+    pub(crate) fn with_capacity(capacity: usize) -> Self {
+        Self { data: vec![T::default(); capacity].into_boxed_slice(), end: 0 }
+    }
+
+    #[inline(always)]
+    pub(crate) fn push(&mut self, value: T) {
+        assert!(self.end <= self.data.len(), "stack overflow");
+        self.data[self.end] = value;
+        self.end += 1;
+    }
+
+    #[inline(always)]
+    pub(crate) fn pop(&mut self) -> Option<T> {
+        assert!(self.end <= self.data.len(), "invalid stack state (should be impossible)");
+        if unlikely(self.end == 0) {
+            None
+        } else {
+            self.end -= 1;
+            Some(self.data[self.end])
+        }
+    }
+
+    #[inline(always)]
+    pub(crate) fn len(&self) -> usize {
+        self.end
+    }
+
+    #[inline(always)]
+    pub(crate) fn extend_from_slice(&mut self, values: &[T]) {
+        let new_end = self.end + values.len();
+        assert!(new_end <= self.data.len(), "stack overflow");
+        self.data[self.end..new_end].copy_from_slice(values);
+        self.end = new_end;
+    }
+
+    #[inline(always)]
+    pub(crate) fn last_mut(&mut self) -> Option<&mut T> {
+        assert!(self.end <= self.data.len(), "invalid stack state (should be impossible)");
+        if unlikely(self.end == 0) {
+            None
+        } else {
+            Some(&mut self.data[self.end - 1])
+        }
+    }
+
+    #[inline(always)]
+    pub(crate) fn last(&self) -> Option<&T> {
+        assert!(self.end <= self.data.len(), "invalid stack state (should be impossible)");
+        if unlikely(self.end == 0) {
+            None
+        } else {
+            Some(&self.data[self.end - 1])
+        }
+    }
+
+    #[inline(always)]
+    pub(crate) fn drain(&mut self, range: impl RangeBounds<usize>) -> Cow<'_, [T]> {
+        let start = match range.start_bound() {
+            core::ops::Bound::Included(&start) => start,
+            core::ops::Bound::Excluded(&start) => start + 1,
+            core::ops::Bound::Unbounded => 0,
+        };
+        let end = match range.end_bound() {
+            core::ops::Bound::Included(&end) => end + 1,
+            core::ops::Bound::Excluded(&end) => end,
+            core::ops::Bound::Unbounded => self.end,
+        };
+
+        assert!(start <= end);
+        assert!(end <= self.end);
+
+        if end == self.end {
+            self.end = start;
+            return Cow::Borrowed(&self.data[start..end]);
+        }
+
+        let drain = self.data[start..end].to_vec();
+        self.data.copy_within(end..self.end, start);
+        self.end -= end - start;
+        Cow::Owned(drain)
+    }
+}
+
+impl<T> core::ops::Index<usize> for BoxVec<T> {
+    type Output = T;
+
+    #[inline(always)]
+    fn index(&self, index: usize) -> &T {
+        &self.data[index]
+    }
+}
+
+impl<T> core::ops::Index<core::ops::Range<usize>> for BoxVec<T> {
+    type Output = [T];
+
+    #[inline(always)]
+    fn index(&self, index: core::ops::Range<usize>) -> &[T] {
+        &self.data[index]
+    }
+}
+
+impl<T> core::ops::IndexMut<usize> for BoxVec<T> {
+    #[inline(always)]
+    fn index_mut(&mut self, index: usize) -> &mut T {
+        &mut self.data[index]
+    }
+}

crates/tinywasm/src/func.rs

@@ -59,8 +59,8 @@ impl FuncHandle {
         };
 
         // 6. Let f be the dummy frame
-        let call_frame_params = params.iter().map(|v| RawWasmValue::from(*v));
-        let call_frame = CallFrame::new(wasm_func.clone(), func_inst.owner, call_frame_params, 0);
+        let call_frame_params = params.iter().map(|v| RawWasmValue::from(*v)).collect::<Vec<_>>();
+        let call_frame = CallFrame::new(wasm_func.clone(), func_inst.owner, &call_frame_params, 0);
 
         // 7. Push the frame f to the call stack
         // & 8. Push the values to the stack (Not needed since the call frame owns the values)

crates/tinywasm/src/lib.rs

@@ -100,6 +100,7 @@ pub use module::Module;
 pub use reference::*;
 pub use store::*;
 
+mod boxvec;
 mod func;
 mod imports;
 mod instance;

crates/tinywasm/src/runtime/interpreter/mod.rs

@@ -64,13 +64,13 @@ impl<'store, 'stack> Executor<'store, 'stack> {
     }
 
     #[inline(always)]
-    pub(crate) fn exec_next(&mut self) -> Result<ControlFlow<()>> {
+    fn exec_next(&mut self) -> Result<ControlFlow<()>> {
         use tinywasm_types::Instruction::*;
         match self.cf.fetch_instr() {
-            Nop => cold(),
+            Nop => self.exec_noop(),
             Unreachable => self.exec_unreachable()?,
 
-            Drop => self.stack.values.pop().map(|_| ())?,
+            Drop => self.exec_drop()?,
             Select(_valtype) => self.exec_select()?,
 
             Call(v) => return self.exec_call_direct(*v),
@@ -80,7 +80,7 @@ impl<'store, 'stack> Executor<'store, 'stack> {
             Else(end_offset) => self.exec_else(*end_offset)?,
             Loop(args, end) => self.enter_block(self.cf.instr_ptr, *end, BlockType::Loop, *args),
             Block(args, end) => self.enter_block(self.cf.instr_ptr, *end, BlockType::Block, *args),
-            Br(v) => break_to!(*v, self),
+            Br(v) => return self.exec_br(*v),
             BrIf(v) => return self.exec_br_if(*v),
             BrTable(default, len) => return self.exec_brtable(*default, *len),
             Return => return self.exec_return(),
@@ -310,7 +310,6 @@ impl<'store, 'stack> Executor<'store, 'stack> {
             I32StoreLocal { local, const_i32, offset, mem_addr } => {
                 self.exec_i32_store_local(*local, *const_i32, *offset, *mem_addr)?
             }
-
             i => {
                 cold();
                 return Err(Error::UnsupportedFeature(format!("unimplemented instruction: {:?}", i)));
@@ -344,6 +343,13 @@ impl<'store, 'stack> Executor<'store, 'stack> {
         Ok(())
     }
 
+    #[inline(always)]
+    fn exec_br(&mut self, to: u32) -> Result<ControlFlow<()>> {
+        break_to!(to, self);
+        self.cf.instr_ptr += 1;
+        Ok(ControlFlow::Continue(()))
+    }
+
     #[inline(always)]
     fn exec_br_if(&mut self, to: u32) -> Result<ControlFlow<()>> {
         let val: i32 = self.stack.values.pop()?.into();
@@ -396,6 +402,9 @@ impl<'store, 'stack> Executor<'store, 'stack> {
         Err(Error::Trap(Trap::Unreachable))
     }
 
+    #[inline(always)]
+    fn exec_noop(&self) {}
+
     #[inline(always)]
     fn exec_ref_is_null(&mut self) -> Result<()> {
         self.stack.values.replace_top(|val| ((i32::from(val) == -1) as i32).into())
@@ -551,18 +560,24 @@ impl<'store, 'stack> Executor<'store, 'stack> {
         let table_idx = self.module.resolve_table_addr(table_index);
         let table = self.store.get_table(table_idx)?;
         let delta: i32 = self.stack.values.pop()?.into();
-        let prev_size = table.borrow().size() as i32;
+        let prev_size = table.borrow().size();
         table.borrow_mut().grow_to_fit((prev_size + delta) as usize)?;
         self.stack.values.push(prev_size.into());
         Ok(())
     }
 
     #[inline(always)]
-    fn exec_table_fill(&mut self, table_index: u32) -> Result<()> {
+    fn exec_table_fill(&mut self, _table_index: u32) -> Result<()> {
         // TODO: implement
         Ok(())
     }
 
+    #[inline(always)]
+    fn exec_drop(&mut self) -> Result<()> {
+        self.stack.values.pop()?;
+        Ok(())
+    }
+
     #[inline(always)]
     fn exec_select(&mut self) -> Result<()> {
         let cond: i32 = self.stack.values.pop()?.into();
@@ -695,7 +710,7 @@ impl<'store, 'stack> Executor<'store, 'stack> {
     #[inline(always)]
     fn exec_call(&mut self, wasm_func: Rc<WasmFunction>, owner: ModuleInstanceAddr) -> Result<ControlFlow<()>> {
         let params = self.stack.values.pop_n_rev(wasm_func.ty.params.len())?;
-        let new_call_frame = CallFrame::new(wasm_func, owner, params, self.stack.blocks.len() as u32);
+        let new_call_frame = CallFrame::new(wasm_func, owner, &params, self.stack.blocks.len() as u32);
         self.cf.instr_ptr += 1; // skip the call instruction
         self.stack.call_stack.push(core::mem::replace(&mut self.cf, new_call_frame))?;
         self.module.swap_with(self.cf.module_addr, self.store);

crates/tinywasm/src/runtime/stack/call_stack.rs

@@ -103,7 +103,7 @@ impl CallFrame {
     pub(crate) fn new(
         wasm_func_inst: Rc<WasmFunction>,
         owner: ModuleInstanceAddr,
-        params: impl ExactSizeIterator<Item = RawWasmValue>,
+        params: &[RawWasmValue],
         block_ptr: u32,
     ) -> Self {
         let locals = {