chore: Memory and Data Instances are no longer reference counted

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

Author: explodingcamera

.cargo/config.toml

@@ -5,8 +5,3 @@ test-mvp="test --package tinywasm --test test-mvp --release -- --enable "
 test-2="test --package tinywasm --test test-two --release -- --enable "
 test-wast="test --package tinywasm --test test-wast -- --enable "
 test-wast-release="test --package tinywasm --test test-wast --release -- --enable "
-
-# enable for linux perf
-[target.x86_64-unknown-linux-gnu]
-linker="/usr/bin/clang"
-rustflags=["-Clink-arg=-fuse-ld=lld", "-Clink-arg=-Wl,--no-rosegment"]

CHANGELOG.md

@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Use a seperate stack and locals for 32, 64 and 128 bit values and references (#21)
 - Updated to latest `wasmparser` version
 - Removed benchmarks comparing TinyWasm to other WebAssembly runtimes to reduce build dependencies
+- Memory and Data Instances are no longer reference counted
 
 ## [0.7.0] - 2024-05-15
 

crates/tinywasm/benches/fibonacci.rs

@@ -43,7 +43,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("fibonacci_to_twasm", |b| b.iter(|| fibonacci_to_twasm(module.clone())));
     c.bench_function("fibonacci_from_twasm", |b| b.iter(|| fibonacci_from_twasm(twasm.clone())));
     c.bench_function("fibonacci_iterative_60", |b| b.iter(|| fibonacci_run(module.clone(), false, 60)));
-    c.bench_function("fibonacci_recursive_60", |b| b.iter(|| fibonacci_run(module.clone(), true, 60)));
+    c.bench_function("fibonacci_recursive_26", |b| b.iter(|| fibonacci_run(module.clone(), true, 26)));
 }
 
 criterion_group!(benches, criterion_benchmark);

crates/tinywasm/src/imports.rs

@@ -6,7 +6,7 @@ use alloc::vec::Vec;
 use core::fmt::Debug;
 
 use crate::func::{FromWasmValueTuple, IntoWasmValueTuple, ValTypesFromTuple};
-use crate::{log, LinkingError, Result};
+use crate::{log, LinkingError, MemoryRef, MemoryRefMut, Result};
 use tinywasm_types::*;
 
 /// The internal representation of a function
@@ -72,12 +72,12 @@ impl FuncContext<'_> {
     }
 
     /// Get a reference to an exported memory
-    pub fn exported_memory(&mut self, name: &str) -> Result<crate::MemoryRef<'_>> {
+    pub fn exported_memory(&mut self, name: &str) -> Result<MemoryRef<'_>> {
         self.module().exported_memory(self.store, name)
     }
 
     /// Get a reference to an exported memory
-    pub fn exported_memory_mut(&mut self, name: &str) -> Result<crate::MemoryRefMut<'_>> {
+    pub fn exported_memory_mut(&mut self, name: &str) -> Result<MemoryRefMut<'_>> {
         self.module().exported_memory_mut(self.store, name)
     }
 }
@@ -394,15 +394,12 @@ impl Imports {
                         }
                         (ExternVal::Table(table_addr), ImportKind::Table(ty)) => {
                             let table = store.get_table(table_addr)?;
-                            Self::compare_table_types(import, &table.borrow().kind, ty)?;
+                            Self::compare_table_types(import, &table.kind, ty)?;
                             imports.tables.push(table_addr);
                         }
                         (ExternVal::Memory(memory_addr), ImportKind::Memory(ty)) => {
                             let mem = store.get_mem(memory_addr)?;
-                            let (size, kind) = {
-                                let mem = mem.borrow();
-                                (mem.page_count(), mem.kind)
-                            };
+                            let (size, kind) = { (mem.page_count(), mem.kind) };
                             Self::compare_memory_types(import, &kind, ty, Some(size))?;
                             imports.memories.push(memory_addr);
                         }

crates/tinywasm/src/instance.rs

@@ -133,37 +133,37 @@ impl ModuleInstance {
     }
 
     // resolve a function address to the global store address
-    #[inline(always)]
+    #[inline]
     pub(crate) fn resolve_func_addr(&self, addr: FuncAddr) -> Result<FuncAddr> {
         self.0.func_addrs.get(addr as usize).ok_or_else(|| Self::not_found_error("function")).copied()
     }
 
     // resolve a table address to the global store address
-    #[inline(always)]
+    #[inline]
     pub(crate) fn resolve_table_addr(&self, addr: TableAddr) -> Result<TableAddr> {
         self.0.table_addrs.get(addr as usize).ok_or_else(|| Self::not_found_error("table")).copied()
     }
 
     // resolve a memory address to the global store address
-    #[inline(always)]
+    #[inline]
     pub(crate) fn resolve_mem_addr(&self, addr: MemAddr) -> Result<MemAddr> {
         self.0.mem_addrs.get(addr as usize).ok_or_else(|| Self::not_found_error("mem")).copied()
     }
 
     // resolve a data address to the global store address
-    #[inline(always)]
+    #[inline]
     pub(crate) fn resolve_data_addr(&self, addr: DataAddr) -> Result<DataAddr> {
         self.0.data_addrs.get(addr as usize).ok_or_else(|| Self::not_found_error("data")).copied()
     }
 
     // resolve a memory address to the global store address
-    #[inline(always)]
+    #[inline]
     pub(crate) fn resolve_elem_addr(&self, addr: ElemAddr) -> Result<ElemAddr> {
         self.0.elem_addrs.get(addr as usize).ok_or_else(|| Self::not_found_error("elem")).copied()
     }
 
     // resolve a global address to the global store address
-    #[inline(always)]
+    #[inline]
     pub(crate) fn resolve_global_addr(&self, addr: GlobalAddr) -> Result<GlobalAddr> {
         self.0.global_addrs.get(addr as usize).ok_or_else(|| Self::not_found_error("global")).copied()
     }
@@ -216,15 +216,15 @@ impl ModuleInstance {
     }
 
     /// Get a memory by address
-    pub fn memory<'a>(&self, store: &'a mut Store, addr: MemAddr) -> Result<MemoryRef<'a>> {
+    pub fn memory<'a>(&self, store: &'a Store, addr: MemAddr) -> Result<MemoryRef<'a>> {
         let mem = store.get_mem(self.resolve_mem_addr(addr)?)?;
-        Ok(MemoryRef(mem.borrow()))
+        Ok(MemoryRef(mem))
     }
 
     /// Get a memory by address (mutable)
     pub fn memory_mut<'a>(&self, store: &'a mut Store, addr: MemAddr) -> Result<MemoryRefMut<'a>> {
-        let mem = store.get_mem(self.resolve_mem_addr(addr)?)?;
-        Ok(MemoryRefMut(mem.borrow_mut()))
+        let mem = store.get_mem_mut(self.resolve_mem_addr(addr)?)?;
+        Ok(MemoryRefMut(mem))
     }
 
     /// Get the start function of the module