diff --git a/CHANGELOG.md b/CHANGELOG.md index a8c4268f0df..1a2add63b5e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,10 +5,11 @@ All PRs to the Wasmer repository must add to this file. Blocks of changes will separated by version increments. ## **[Unreleased]** -- [#541](https://github.com/wasmerio/wasmer/pull/541) Fix dependency graph by making separate test crates; ABI implementations should not depend on compilers +- [#541](https://github.com/wasmerio/wasmer/pull/541) Fix dependency graph by making separate test crates; ABI implementations should not depend on compilers. Add Cranelift fork as git submodule of clif-backend +- [#537](https://github.com/wasmerio/wasmer/pull/537) Add hidden flag (`--cache-key`) to use prehashed key into the compiled wasm cache and change compiler backend-specific caching to use directories +- [#536](https://github.com/wasmerio/wasmer/pull/536) ~Update cache to use compiler backend name in cache key~ ## 0.5.4 -- [#536](https://github.com/wasmerio/wasmer/pull/536) Update cache to use compiler backend name in cache key - [#529](https://github.com/wasmerio/wasmer/pull/529) Updates the Wasm Interface library, which is used by wapm, with bug fixes and error message improvements ## 0.5.3 diff --git a/Cargo.toml b/Cargo.toml index efaaa4b904a..921a3c456dd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -73,8 +73,8 @@ trace = ["wasmer-runtime-core/trace"] extra-debug = ["wasmer-clif-backend/debug", "wasmer-runtime-core/debug"] # This feature will allow cargo test to run much faster fast-tests = [] -"backend:llvm" = ["wasmer-llvm-backend"] -"backend:singlepass" = ["wasmer-singlepass-backend"] +"backend:llvm" = ["wasmer-llvm-backend", "wasmer-runtime-core/backend:llvm"] +"backend:singlepass" = ["wasmer-singlepass-backend", "wasmer-runtime-core/backend:singlepass"] wasi = ["wasmer-wasi"] # vfs = ["wasmer-runtime-abi"] diff --git a/lib/runtime-core/Cargo.toml b/lib/runtime-core/Cargo.toml index 0cba9424019..936b66e1612 100644 --- a/lib/runtime-core/Cargo.toml +++ b/lib/runtime-core/Cargo.toml @@ -54,3 +54,6 @@ cc = "1.0" [features] debug = [] trace = ["debug"] +# backend flags used in conditional compilation of Backend::variants +"backend:singlepass" = [] +"backend:llvm" = [] diff --git a/lib/runtime-core/src/cache.rs b/lib/runtime-core/src/cache.rs index 8f1c82db2b4..18c571b00ad 100644 --- a/lib/runtime-core/src/cache.rs +++ b/lib/runtime-core/src/cache.rs @@ -37,31 +37,17 @@ impl From for Error { pub struct WasmHash([u8; 32], [u8; 32]); impl WasmHash { - /// Hash a wasm module for the default compiler backend. - /// - /// See also: `WasmHash::generate_for_backend`. + /// Hash a wasm module. /// /// # Note: /// This does no verification that the supplied data /// is, in fact, a wasm module. pub fn generate(wasm: &[u8]) -> Self { - WasmHash::generate_for_backend(wasm, Backend::default()) - } - - /// Hash a wasm module for a specific compiler backend. - /// This allows multiple cache entries containing the same compiled - /// module with different compiler backends. - /// - /// # Note: - /// This function also does no verification that the supplied data - /// is a wasm module - pub fn generate_for_backend(wasm: &[u8], backend: Backend) -> Self { let mut first_part = [0u8; 32]; let mut second_part = [0u8; 32]; let mut state = blake2bp::State::new(); state.update(wasm); - state.update(backend.to_string().as_bytes()); let hasher = state.finalize(); let generic_array = hasher.as_bytes(); @@ -77,6 +63,30 @@ impl WasmHash { hex::encode(&self.into_array() as &[u8]) } + /// Create hash from hexadecimal representation + pub fn decode(hex_str: &str) -> Result { + let bytes = hex::decode(hex_str).map_err(|e| { + Error::DeserializeError(format!( + "Could not decode prehashed key as hexadecimal: {}", + e + )) + })?; + if bytes.len() != 64 { + return Err(Error::DeserializeError( + "Prehashed keys must deserialze into exactly 64 bytes".to_string(), + )); + } + use std::convert::TryInto; + Ok(WasmHash( + bytes[0..32].try_into().map_err(|e| { + Error::DeserializeError(format!("Could not get first 32 bytes: {}", e)) + })?, + bytes[32..64].try_into().map_err(|e| { + Error::DeserializeError(format!("Could not get last 32 bytes: {}", e)) + })?, + )) + } + pub(crate) fn into_array(self) -> [u8; 64] { let mut total = [0u8; 64]; total[0..32].copy_from_slice(&self.0); @@ -219,7 +229,11 @@ pub trait Cache { type LoadError: fmt::Debug; type StoreError: fmt::Debug; + /// loads a module using the default `Backend` fn load(&self, key: WasmHash) -> Result; + /// loads a cached module using a specific `Backend` + fn load_with_backend(&self, key: WasmHash, backend: Backend) + -> Result; fn store(&mut self, key: WasmHash, module: Module) -> Result<(), Self::StoreError>; } diff --git a/lib/runtime/src/cache.rs b/lib/runtime/src/cache.rs index 5b2c2669e16..fdb0d58c87e 100644 --- a/lib/runtime/src/cache.rs +++ b/lib/runtime/src/cache.rs @@ -7,7 +7,10 @@ use std::{ }; use wasmer_runtime_core::cache::Error as CacheError; -pub use wasmer_runtime_core::cache::{Artifact, Cache, WasmHash, WASMER_VERSION_HASH}; +pub use wasmer_runtime_core::{ + backend::Backend, + cache::{Artifact, Cache, WasmHash, WASMER_VERSION_HASH}, +}; /// Representation of a directory that contains compiled wasm artifacts. /// @@ -20,7 +23,6 @@ pub use wasmer_runtime_core::cache::{Artifact, Cache, WasmHash, WASMER_VERSION_H /// /// ```rust /// use wasmer_runtime::cache::{Cache, FileSystemCache, WasmHash}; -/// use wasmer_runtime_core::backend::Backend; /// /// # use wasmer_runtime::{Module, error::CacheError}; /// fn store_module(module: Module) -> Result { @@ -29,7 +31,7 @@ pub use wasmer_runtime_core::cache::{Artifact, Cache, WasmHash, WASMER_VERSION_H /// // corrupted or tampered with. /// let mut fs_cache = unsafe { FileSystemCache::new("some/directory/goes/here")? }; /// // Compute a key for a given WebAssembly binary -/// let key = WasmHash::generate_for_backend(&[], Backend::Cranelift); +/// let key = WasmHash::generate(&[]); /// // Store a module into the cache given a key /// fs_cache.store(key, module.clone())?; /// Ok(module) @@ -88,8 +90,13 @@ impl Cache for FileSystemCache { type StoreError = CacheError; fn load(&self, key: WasmHash) -> Result { + self.load_with_backend(key, Backend::default()) + } + + fn load_with_backend(&self, key: WasmHash, backend: Backend) -> Result { let filename = key.encode(); let mut new_path_buf = self.path.clone(); + new_path_buf.push(backend.to_string()); new_path_buf.push(filename); let file = File::open(new_path_buf)?; let mmap = unsafe { Mmap::map(&file)? }; @@ -102,12 +109,15 @@ impl Cache for FileSystemCache { fn store(&mut self, key: WasmHash, module: Module) -> Result<(), CacheError> { let filename = key.encode(); + let backend_str = module.info().backend.to_string(); let mut new_path_buf = self.path.clone(); - new_path_buf.push(filename); + new_path_buf.push(backend_str); let serialized_cache = module.cache()?; let buffer = serialized_cache.serialize()?; + std::fs::create_dir_all(&new_path_buf)?; + new_path_buf.push(filename); let mut file = File::create(new_path_buf)?; file.write_all(&buffer)?; diff --git a/src/bin/wasmer.rs b/src/bin/wasmer.rs index 297d0199b78..d1e46fbd66c 100644 --- a/src/bin/wasmer.rs +++ b/src/bin/wasmer.rs @@ -24,6 +24,7 @@ use wasmer_runtime::{ use wasmer_runtime_core::{ self, backend::{Backend, Compiler, CompilerConfig, MemoryBoundCheckMode}, + debug, loader::{Instance as LoadedInstance, LocalLoader}, }; #[cfg(feature = "backend:singlepass")] @@ -115,9 +116,18 @@ struct Run { #[structopt(long = "resume")] resume: Option, + /// The command name is a string that will override the first argument passed + /// to the wasm program. This is used in wapm to provide nicer output in + /// help commands and error messages of the running wasm program #[structopt(long = "command-name", hidden = true)] command_name: Option, + /// A prehashed string, used to speed up start times by avoiding hashing the + /// wasm module. If the specified hash is not found, Wasmer will hash the module + /// as if no `cache-key` argument was passed. + #[structopt(long = "cache-key", hidden = true)] + cache_key: Option, + /// Application arguments #[structopt(name = "--", raw(multiple = "true"))] args: Vec, @@ -350,10 +360,6 @@ fn execute_wasm(options: &Run) -> Result<(), String> { } else { // If we have cache enabled - // We generate a hash for the given binary, so we can use it as key - // for the Filesystem cache - let hash = WasmHash::generate_for_backend(&wasm_binary, options.backend); - let wasmer_cache_dir = get_cache_dir(); // We create a new cache instance. @@ -362,31 +368,49 @@ fn execute_wasm(options: &Run) -> Result<(), String> { let mut cache = unsafe { FileSystemCache::new(wasmer_cache_dir).map_err(|e| format!("Cache error: {:?}", e))? }; - - // cache.load will return the Module if it's able to deserialize it properly, and an error if: - // * The file is not found - // * The file exists, but it's corrupted or can't be converted to a module - match cache.load(hash) { - Ok(module) => { - // We are able to load the module from cache - module + let load_cache_key = || -> Result<_, String> { + if let Some(ref prehashed_cache_key) = options.cache_key { + if let Ok(module) = + WasmHash::decode(prehashed_cache_key).and_then(|prehashed_key| { + cache.load_with_backend(prehashed_key, options.backend) + }) + { + debug!("using prehashed key: {}", prehashed_cache_key); + return Ok(module); + } } - Err(_) => { - let module = webassembly::compile_with_config_with( - &wasm_binary[..], - CompilerConfig { - symbol_map: em_symbol_map, - ..Default::default() - }, - &*compiler, - ) - .map_err(|e| format!("Can't compile module: {:?}", e))?; - // We try to save the module into a cache file - cache.store(hash, module.clone()).unwrap_or_default(); - module + // We generate a hash for the given binary, so we can use it as key + // for the Filesystem cache + let hash = WasmHash::generate(&wasm_binary); + + // cache.load will return the Module if it's able to deserialize it properly, and an error if: + // * The file is not found + // * The file exists, but it's corrupted or can't be converted to a module + match cache.load_with_backend(hash, options.backend) { + Ok(module) => { + // We are able to load the module from cache + Ok(module) + } + Err(_) => { + let module = webassembly::compile_with_config_with( + &wasm_binary[..], + CompilerConfig { + symbol_map: em_symbol_map, + ..Default::default() + }, + &*compiler, + ) + .map_err(|e| format!("Can't compile module: {:?}", e))?; + // We try to save the module into a cache file + cache.store(hash, module.clone()).unwrap_or_default(); + + Ok(module) + } } - } + }; + + load_cache_key()? }; if let Some(loader) = options.loader {