feat: Remove caching in wasmer_wamr mode

crates/common/src/result.rs

@@ -30,8 +30,9 @@ pub enum WasmErrorInner {
     /// AND wasm execution MUST immediately halt.
     /// The `Vec<u8>` holds the encoded data as though the guest had returned.
     HostShortCircuit(Vec<u8>),
-    /// Wasmer failed to compile machine code from wasm byte code.
-    Compile(String),
+    /// Wasmer failed to build a Module from wasm byte code.
+    /// With the feature `wasmer_sys` enabled, building a Module includes compiling the wasm.
+    ModuleBuild(String),
     /// The host failed to call a function in the guest.
     CallError(String),
     /// Host attempted to interact with the module cache before it was initialized.
@@ -51,7 +52,7 @@ impl WasmErrorInner {
             // Bad memory is bad memory.
             | Self::Memory
             // Failing to compile means we cannot reuse.
-            | Self::Compile(_)
+            | Self::ModuleBuild(_)
             // This is ambiguous so best to treat as potentially corrupt.
             | Self::CallError(_)
             // We have no cache so cannot cache.

crates/guest/Cargo.toml

@@ -14,7 +14,7 @@ crate-type = ["cdylib", "rlib"]
 path = "src/guest.rs"
 
 [dependencies]
-holochain_serialized_bytes = { version = "=0.0.55", features = [] }
+holochain_serialized_bytes = "=0.0.55"
 holochain_wasmer_common = { version = "=0.0.96", path = "../common" }
 serde = "1"
 tracing = "0.1"

crates/host/src/module/mod.rs → crates/host/src/module.rs

@@ -1,3 +1,13 @@
+//! Wasmer Host Module Manager
+//!
+//! This provides two ways to build & access wasm modules:
+//!
+//! 1. When using the feature flag `wasmer_sys`, modules should be accessed only via the [`ModuleCache`].
+//!    This ensures that wasm modules are compiled once, then cached and stored efficiently.
+//!
+//! 2. When using the feature flag `wasmer_wamr`, modules should be built via the exported build_module function.
+//!    There is no need for caching, as the wasm module is interpreted.
+
 use crate::plru::MicroCache;
 use crate::prelude::*;
 use bimap::BiMap;
@@ -11,15 +21,11 @@ use std::fs::File;
 use std::fs::OpenOptions;
 use std::io::Write;
 use std::path::PathBuf;
-use std::str::FromStr;
 use std::sync::Arc;
-use wasmer::CpuFeature;
 use wasmer::Engine;
 use wasmer::Instance;
 use wasmer::Module;
 use wasmer::Store;
-use wasmer::Target;
-use wasmer::Triple;
 
 #[cfg(feature = "wasmer_sys")]
 mod wasmer_sys;
@@ -36,9 +42,9 @@ pub use wasmer_wamr::*;
 pub type CacheKey = [u8; 32];
 /// Plru uses a usize to track "recently used" so we need a map between 32 byte cache
 /// keys and the bits used to evict things from the cache.
-pub type PlruKeyMap = BiMap<usize, CacheKey>;
+type PlruKeyMap = BiMap<usize, CacheKey>;
 /// Modules serialize to a vec of bytes as per wasmer.
-pub type SerializedModule = Bytes;
+type SerializedModule = Bytes;
 
 #[derive(Clone, Debug)]
 pub struct ModuleWithStore {
@@ -56,7 +62,7 @@ pub struct InstanceWithStore {
 /// with consistently. Default implementations for key functions are provided.
 /// Notably handles keeping the mapping between cache keys and items, and the
 /// plru tracking including touching and evicting.
-pub trait PlruCache {
+trait PlruCache {
     /// The type of items in the cache.
     type Item;
     /// Accessor for mutable reference to internal plru cache.
@@ -104,12 +110,14 @@ pub trait PlruCache {
 
     /// Delete the plru for a given cache key. Care must be taken to ensure this
     /// is not called before a subsequent call to `plru_key` or it will panic.
+    #[allow(dead_code)]
     fn trash(&mut self, key: &CacheKey) {
         let plru_key = self.plru_key(key);
         self.plru_mut().trash(plru_key);
     }
 
     /// Remove an item from the cache and the associated plru entry.
+    #[allow(dead_code)]
     fn remove_item(&mut self, key: &CacheKey) -> Option<Arc<Self::Item>> {
         let maybe_item = self.cache_mut().remove(key);
         if maybe_item.is_some() {
@@ -206,7 +214,7 @@ impl SerializedModuleCache {
             // We do this the long way to get `Bytes` instead of `Vec<u8>` so
             // that the clone when we both deserialize and cache is cheap.
             let mut file = File::open(module_path).map_err(|e| {
-                wasm_error!(WasmErrorInner::Compile(format!(
+                wasm_error!(WasmErrorInner::ModuleBuild(format!(
                     "{} Path: {}",
                     e,
                     module_path.display()
@@ -215,7 +223,7 @@ impl SerializedModuleCache {
             let mut bytes_mut = BytesMut::new().writer();
 
             std::io::copy(&mut file, &mut bytes_mut).map_err(|e| {
-                wasm_error!(WasmErrorInner::Compile(format!(
+                wasm_error!(WasmErrorInner::ModuleBuild(format!(
                     "{} Path: {}",
                     e,
                     module_path.display()
@@ -227,7 +235,7 @@ impl SerializedModuleCache {
             Some(Ok(serialized_module)) => {
                 let deserialized_module =
                     unsafe { Module::deserialize(&self.runtime_engine, serialized_module.clone()) }
-                        .map_err(|e| wasm_error!(WasmErrorInner::Compile(e.to_string())))?;
+                        .map_err(|e| wasm_error!(WasmErrorInner::ModuleBuild(e.to_string())))?;
                 (deserialized_module, serialized_module)
             }
             // no serialized module found on the file system, so serialize the
@@ -237,11 +245,12 @@ impl SerializedModuleCache {
                 // of middleware like metering. Middleware is compiled into the
                 // module once and available in all instances created from it.
                 let compiler_engine = (self.make_engine)();
-                let module = Module::from_binary(&compiler_engine, wasm)
-                    .map_err(|e| wasm_error!(WasmErrorInner::Compile(e.to_string())))?;
+                let res = Module::from_binary(&compiler_engine, wasm);
+                let module =
+                    res.map_err(|e| wasm_error!(WasmErrorInner::ModuleBuild(e.to_string())))?;
                 let serialized_module = module
                     .serialize()
-                    .map_err(|e| wasm_error!(WasmErrorInner::Compile(e.to_string())))?;
+                    .map_err(|e| wasm_error!(WasmErrorInner::ModuleBuild(e.to_string())))?;
 
                 if let Some(module_path) = maybe_module_path {
                     match OpenOptions::new()
@@ -280,7 +289,7 @@ impl SerializedModuleCache {
                 // and stores unnecessary.
                 let module = unsafe {
                     Module::deserialize(&self.runtime_engine, serialized_module.clone())
-                        .map_err(|e| wasm_error!(WasmErrorInner::Compile(e.to_string())))?
+                        .map_err(|e| wasm_error!(WasmErrorInner::ModuleBuild(e.to_string())))?
                 };
 
                 (module, serialized_module)
@@ -299,7 +308,7 @@ impl SerializedModuleCache {
                 let module = unsafe {
                     Module::deserialize(&self.runtime_engine, (**serialized_module).clone())
                 }
-                .map_err(|e| wasm_error!(WasmErrorInner::Compile(e.to_string())))?;
+                .map_err(|e| wasm_error!(WasmErrorInner::ModuleBuild(e.to_string())))?;
                 self.touch(&key);
                 Ok(Arc::new(module))
             }
@@ -312,7 +321,7 @@ impl SerializedModuleCache {
 /// the cache to create callable instances is slow. Therefore modules are
 /// cached in memory after deserialization.
 #[derive(Default, Debug)]
-pub struct DeserializedModuleCache {
+struct DeserializedModuleCache {
     plru: MicroCache,
     key_map: PlruKeyMap,
     cache: BTreeMap<CacheKey, Arc<Module>>,
@@ -385,19 +394,9 @@ impl ModuleCache {
     }
 }
 
-/// Configuration of a Target for wasmer for iOS
-pub fn wasmer_ios_target() -> Target {
-    // use what I see in
-    // platform ios headless example
-    // https://github.com/wasmerio/wasmer/blob/447c2e3a152438db67be9ef649327fabcad6f5b8/examples/platform_ios_headless.rs#L38-L53
-    let triple = Triple::from_str("aarch64-apple-ios").unwrap();
-    let cpu_feature = CpuFeature::set();
-    Target::new(triple, cpu_feature)
-}
-
 #[cfg(test)]
 pub mod tests {
-    use crate::module::{CacheKey, ModuleCache, PlruCache};
+    use super::{CacheKey, ModuleCache, PlruCache};
 
     #[test]
     fn cache_test() {

crates/host/src/module/wasmer_sys.rs

@@ -23,7 +23,7 @@ pub const WASM_METERING_LIMIT: u64 = 10_000_000;
 
 /// Generate an engine with a wasm compiler
 /// and Metering (use limits) in place.
-pub fn make_engine() -> Engine {
+pub(crate) fn make_engine() -> Engine {
     let cost_function = |_operator: &wasmparser::Operator| -> u64 { 1 };
     // @todo 100 giga-ops is totally arbitrary cutoff so we probably
     // want to make the limit configurable somehow.
@@ -50,10 +50,15 @@ pub fn make_engine() -> Engine {
     engine
 }
 
-pub fn make_runtime_engine() -> Engine {
+pub(crate) fn make_runtime_engine() -> Engine {
     Engine::headless()
 }
 
+/// Build an interpreter module from wasm bytes.
+pub fn build_module(_wasm: &[u8]) -> Result<Arc<Module>, wasmer::RuntimeError> {
+    unimplemented!("The feature flag 'wasmer_wamr' must be enabled to support building a Module directly. Please use the ModuleCache instead.");
+}
+
 /// Take WASM binary and prepare a wasmer Module suitable for iOS
 pub fn build_ios_module(wasm: &[u8]) -> Result<Module, CompileError> {
     info!(

crates/host/src/module/wasmer_wamr.rs

@@ -1,4 +1,6 @@
+use crate::prelude::*;
 use std::path::Path;
+use std::sync::Arc;
 use wasmer::CompileError;
 use wasmer::DeserializeError;
 use wasmer::Engine;
@@ -7,14 +9,22 @@ use wasmer::Module;
 /// Generate an engine with a wasm interpreter
 /// The interpreter used (wasm micro runtime) does not support metering
 /// See tracking issue: https://github.com/bytecodealliance/wasm-micro-runtime/issues/2163
-pub fn make_engine() -> Engine {
+pub(crate) fn make_engine() -> Engine {
     Engine::default()
 }
 
-pub fn make_runtime_engine() -> Engine {
+pub(crate) fn make_runtime_engine() -> Engine {
     Engine::default()
 }
 
+/// Build an interpreter module from wasm bytes.
+pub fn build_module(wasm: &[u8]) -> Result<Arc<Module>, wasmer::RuntimeError> {
+    let compiler_engine = make_engine();
+    let res = Module::from_binary(&compiler_engine, wasm);
+    let module = res.map_err(|e| wasm_error!(WasmErrorInner::ModuleBuild(e.to_string())))?;
+    Ok(Arc::new(module))
+}
+
 /// Take WASM binary and prepare a wasmer Module suitable for iOS
 pub fn build_ios_module(_wasm: &[u8]) -> Result<Module, CompileError> {
     unimplemented!("The feature flag 'wasmer_sys' must be enabled to support compiling wasm");
@@ -24,3 +34,25 @@ pub fn build_ios_module(_wasm: &[u8]) -> Result<Module, CompileError> {
 pub fn get_ios_module_from_file(_path: &Path) -> Result<Module, DeserializeError> {
     unimplemented!("The feature flag 'wasmer_sys' must be enabled to support compiling wasm");
 }
+
+#[cfg(test)]
+pub mod tests {
+    use super::build_module;
+
+    #[test]
+    fn build_module_test() {
+        // simple example wasm taken from wasmer docs
+        // https://docs.rs/wasmer/latest/wasmer/struct.Module.html#example
+        let wasm: Vec<u8> = vec![
+            0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x06, 0x01, 0x60, 0x01, 0x7f,
+            0x01, 0x7f, 0x03, 0x02, 0x01, 0x00, 0x07, 0x0b, 0x01, 0x07, 0x61, 0x64, 0x64, 0x5f,
+            0x6f, 0x6e, 0x65, 0x00, 0x00, 0x0a, 0x09, 0x01, 0x07, 0x00, 0x20, 0x00, 0x41, 0x01,
+            0x6a, 0x0b, 0x00, 0x1a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x01, 0x0a, 0x01, 0x00, 0x07,
+            0x61, 0x64, 0x64, 0x5f, 0x6f, 0x6e, 0x65, 0x02, 0x07, 0x01, 0x00, 0x01, 0x00, 0x02,
+            0x70, 0x30,
+        ];
+
+        let res = build_module(wasm.as_slice());
+        assert!(res.is_ok())
+    }
+}

scripts/bench.sh

@@ -1,5 +1,5 @@
 #! /usr/bin/env bash
 
-./bench-wasmer_sys_dev.sh
-./bench-wasmer_sys_prod.sh
-./bench-wasmer_wamr.sh
+./scripts/bench-wasmer_sys_dev.sh
+./scripts/bench-wasmer_sys_prod.sh
+./scripts/bench-wasmer_wamr.sh

scripts/test.sh

@@ -1,5 +1,5 @@
 #! /usr/bin/env bash
 
-./test-wasmer_sys_dev.sh
-./test-wasmer_sys_prod.sh
-./test-wasmer_wamr.sh
+./scripts/test-wasmer_sys_dev.sh
+./scripts/test-wasmer_sys_prod.sh
+./scripts/test-wasmer_wamr.sh

test/benches/bench.rs

@@ -13,7 +13,7 @@ use wasmer::Store;
 pub fn wasm_module_compile(c: &mut Criterion) {
     let mut group = c.benchmark_group("wasm_module_compile");
 
-    for wasm in vec![
+    for wasm in [
         TestWasm::Empty,
         TestWasm::Io,
         TestWasm::Test,
@@ -31,7 +31,7 @@ pub fn wasm_module_compile(c: &mut Criterion) {
 pub fn wasm_module_deserialize_from_file(c: &mut Criterion) {
     let mut group = c.benchmark_group("wasm_module_deserialize_from_file");
 
-    for wasm in vec![
+    for wasm in [
         TestWasm::Empty,
         TestWasm::Io,
         TestWasm::Test,
@@ -56,7 +56,7 @@ pub fn wasm_module_deserialize_from_file(c: &mut Criterion) {
 pub fn wasm_module(c: &mut Criterion) {
     let mut group = c.benchmark_group("wasm_module");
 
-    for wasm in vec![
+    for wasm in [
         TestWasm::Empty,
         TestWasm::Io,
         TestWasm::Test,
@@ -76,7 +76,7 @@ pub fn wasm_module(c: &mut Criterion) {
 pub fn wasm_instance(c: &mut Criterion) {
     let mut group = c.benchmark_group("wasm_instance");
 
-    for wasm in vec![
+    for wasm in [
         TestWasm::Empty,
         TestWasm::Io,
         TestWasm::Test,
@@ -213,7 +213,7 @@ pub fn test_process_string(c: &mut Criterion) {
 
     let instance_with_store = TestWasm::Test.unmetered_instance();
 
-    for n in vec![0, 1, 1_000, 1_000_000] {
+    for n in [0, 1, 1_000, 1_000_000] {
         group.throughput(Throughput::Bytes(n));
         group.sample_size(10);
         let input = test_common::StringType::from(".".repeat(n.try_into().unwrap()));

test/src/test.rs

@@ -239,7 +239,7 @@ pub mod tests {
             &mut store.lock().as_store_mut(),
             instance,
             "ignore_args_process_string",
-            &StringType::from(String::new()),
+            StringType::from(String::new()),
         )
         .expect("ignore_args_process_string call");
         assert_eq!(String::new(), String::from(result));
@@ -254,7 +254,7 @@ pub mod tests {
             &mut store.lock().as_store_mut(),
             instance,
             "process_string",
-            &StringType::from(s.clone()),
+            StringType::from(s.clone()),
         )
         .expect("process string call");
 
@@ -267,15 +267,15 @@ pub mod tests {
     fn process_string_test() {
         // use a "crazy" string that is much longer than a single wasm page to show that pagination
         // and utf-8 are both working OK
-        let starter_string = "╰▐ ✖ 〜 ✖ ▐╯"
-            .repeat(usize::try_from(10_u32 * u32::try_from(std::u16::MAX).unwrap()).unwrap());
+        let starter_string =
+            "╰▐ ✖ 〜 ✖ ▐╯".repeat(usize::try_from(10_u32 * u32::from(u16::MAX)).unwrap());
         let InstanceWithStore { store, instance } = TestWasm::Test.instance();
         let result: StringType = guest::call(
             &mut store.lock().as_store_mut(),
             instance,
             "process_string",
             // This is by reference just to show that it can be done as borrowed or owned.
-            &StringType::from(starter_string.clone()),
+            StringType::from(starter_string.clone()),
         )
         .expect("process string call");
 
@@ -320,8 +320,8 @@ pub mod tests {
                 )
             }
         });
-        assert!(matches!(call_1.join(), Ok(_)));
-        assert!(matches!(call_2.join(), Ok(_)));
+        assert!(call_1.join().is_ok());
+        assert!(call_2.join().is_ok());
     }
 
     #[test]