Refactor/clarify dylib ios functionality

CHANGELOG.md

@@ -4,6 +4,9 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+- **BREAKING CHANGE:** Remove unused function `wasmer_ios_target`
+- **BREAKING CHANGE:** Rename functions `build_ios_module` to `write_precompiled_serialized_module_to_file` and `get_ios_module_from_file` to `read_precompiled_serialized_module_from_file` to clarify that they are not an ios-specific.
+
 ## [0.0.93] - 2024-04-24
 
 ### Changed

crates/host/Cargo.toml

@@ -24,6 +24,9 @@ bytes = "1"
 hex = "0.4"
 thiserror = "1"
 
+[dev-dependencies]
+tempfile = "3.12.0"
+
 [lib]
 name = "holochain_wasmer_host"
 crate-type = ["cdylib", "rlib"]

crates/host/src/error.rs

@@ -1,6 +1,7 @@
 use holochain_wasmer_common::WasmError;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
+use wasmer::{CompileError, SerializeError};
 
 /// Wraps a WasmErrorInner with a file and line number.
 /// The easiest way to generate this is with the `wasm_error!` macro that will
@@ -41,3 +42,12 @@ macro_rules! wasm_host_error {
         $crate::wasm_host_error!(std::format!($($arg)*))
     }};
 }
+
+#[derive(Debug, Error)]
+pub enum PreCompiledSerilializedModuleError {
+    #[error(transparent)]
+    CompileError(#[from] CompileError),
+
+    #[error(transparent)]
+    SerializeError(#[from] SerializeError),
+}

crates/host/src/module/mod.rs

@@ -11,15 +11,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;
@@ -385,19 +381,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 crate::module::{CacheKey, ModuleCache, PlruCache, write_precompiled_serialized_module_to_file, read_precompiled_serialized_module_from_file};
 
     #[test]
     fn cache_test() {
@@ -438,4 +424,25 @@ pub mod tests {
             assert_eq!(*deserialized_cached_module, *module);
         }
     }
+
+    #[test]
+    #[cfg(feature = "wasmer_sys")]
+    fn precompiled_serialized_module_roundtrip_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 tmp = tempfile::tempdir().unwrap();
+        let path = tmp.path().join("module.dylib");
+        write_precompiled_serialized_module_to_file(wasm.as_slice(), path.clone()).unwrap();
+        let _module = read_precompiled_serialized_module_from_file(path.as_path()).unwrap();
+    }
 }

crates/host/src/module/wasmer_sys.rs

@@ -1,10 +1,10 @@
+use crate::error::PreCompiledSerilializedModuleError;
 use std::path::Path;
+use std::path::PathBuf;
 use std::sync::Arc;
-use tracing::info;
 use wasmer::sys::BaseTunables;
 use wasmer::sys::CompilerConfig;
 use wasmer::wasmparser;
-use wasmer::CompileError;
 use wasmer::Cranelift;
 use wasmer::DeserializeError;
 use wasmer::Engine;
@@ -49,18 +49,22 @@ pub fn make_runtime_engine() -> Engine {
     Engine::headless()
 }
 
-/// Take WASM binary and prepare a wasmer Module suitable for iOS
-pub fn build_ios_module(wasm: &[u8]) -> Result<Module, CompileError> {
-    info!(
-        "Found wasm and was instructed to serialize it for ios in wasmer format, doing so now..."
-    );
+/// Compile a wasm binary, serialize it with wasmer's serializtion format, and write to a file.
+/// This file can later be used for contexts where JIT compilation is not possible (iOS for example).
+pub fn write_precompiled_serialized_module_to_file(
+    wasm: &[u8],
+    path: PathBuf,
+) -> Result<(), PreCompiledSerilializedModuleError> {
     let compiler_engine = make_engine();
     let store = Store::new(compiler_engine);
-    Module::from_binary(&store, wasm)
+    Module::from_binary(&store, wasm)?.serialize_to_file(path.clone())?;
+    Ok(())
 }
 
-/// Deserialize a previously compiled module for iOS from a file.
-pub fn get_ios_module_from_file(path: &Path) -> Result<Module, DeserializeError> {
+/// Deserialize a previously precompiled and serialized module
+pub fn read_precompiled_serialized_module_from_file(
+    path: &Path,
+) -> Result<Module, DeserializeError> {
     let engine = Engine::headless();
     unsafe { Module::deserialize_from_file(&engine, path) }
 }

crates/host/src/module/wasmer_wamr.rs

@@ -1,5 +1,6 @@
+use crate::error::PreCompiledSerilializedModuleError;
 use std::path::Path;
-use wasmer::CompileError;
+use std::path::PathBuf;
 use wasmer::DeserializeError;
 use wasmer::Engine;
 use wasmer::Module;
@@ -15,12 +16,20 @@ pub fn make_runtime_engine() -> Engine {
     Engine::default()
 }
 
-/// Take WASM binary and prepare a wasmer Module suitable for iOS
-pub fn build_ios_module(_wasm: &[u8]) -> Result<Module, CompileError> {
+/// Compile a wasm binary, serialize it with wasmer's serializtion format, and write to a file.
+/// This file can later be used for contexts where JIT compilation is not possible (iOS for example).
+pub fn write_precompiled_serialized_module_to_file(
+    _wasm: &[u8],
+    _path: PathBuf,
+) -> Result<(), PreCompiledSerilializedModuleError> {
     unimplemented!("The feature flag 'wasmer_sys' must be enabled to support compiling wasm");
 }
 
-/// Deserialize a previously compiled module for iOS from a file.
-pub fn get_ios_module_from_file(_path: &Path) -> Result<Module, DeserializeError> {
+/// Deserialize a previously precompiled and serialized module.
+/// Even though the `wasmer_wamr` feature flag supports deserializing a pre-compiled and serialized module,
+/// it doesn't make sense to use a pre-compiled module as it would be executed by the interpreter engine anyway.
+pub fn read_precompiled_serialized_module_from_file(
+    _path: &Path,
+) -> Result<Module, DeserializeError> {
     unimplemented!("The feature flag 'wasmer_sys' must be enabled to support compiling wasm");
 }