Finalize new cache api

lib/runtime-core/src/backend.rs

@@ -8,14 +8,12 @@ use crate::{
 };
 
 use crate::{
-    cache::{Cache, Error as CacheError},
+    cache::{Error as CacheError, SerializedCache},
     module::ModuleInfo,
     sys::Memory,
 };
 use std::ptr::NonNull;
 
-use std::sync::Arc;
-
 pub mod sys {
     pub use crate::sys::*;
 }
@@ -44,7 +42,11 @@ pub trait Compiler {
     /// be called from inside the runtime.
     fn compile(&self, wasm: &[u8], _: Token) -> CompileResult<ModuleInner>;
 
-    unsafe fn from_cache(&self, cache: Cache, _: Token) -> Result<ModuleInner, CacheError>;
+    unsafe fn from_cache(
+        &self,
+        cache: SerializedCache,
+        _: Token,
+    ) -> Result<ModuleInner, CacheError>;
 }
 
 /// The functionality exposed by this trait is expected to be used

lib/runtime-core/src/cache.rs

@@ -1,4 +1,7 @@
-use crate::{module::ModuleInfo, sys::Memory};
+use crate::{
+    module::{Module, ModuleInfo},
+    sys::Memory,
+};
 use memmap::Mmap;
 use serde_bench::{deserialize, serialize};
 use sha2::{Digest, Sha256};
@@ -8,7 +11,6 @@ use std::{
     mem,
     path::Path,
     slice,
-    sync::Arc,
 };
 
 #[derive(Debug)]
@@ -27,23 +29,43 @@ pub enum Error {
     InvalidatedCache,
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct WasmHash([u8; 32]);
+
+impl WasmHash {
+    pub fn generate(wasm: &[u8]) -> Self {
+        let mut array = [0u8; 32];
+        array.copy_from_slice(Sha256::digest(wasm).as_slice());
+        WasmHash(array)
+    }
+
+    pub fn encode(self) -> String {
+        hex::encode(self.0)
+    }
+
+    pub(crate) fn into_array(self) -> [u8; 32] {
+        self.0
+    }
+}
+
 const CURRENT_CACHE_VERSION: u64 = 0;
 
 /// The header of a cache file.
 #[repr(C, packed)]
-struct CacheHeader {
+struct SerializedCacheHeader {
     magic: [u8; 8], // [W, A, S, M, E, R, \0, \0]
     version: u64,
     data_len: u64,
     wasm_hash: [u8; 32], // Sha256 of the wasm in binary format.
 }
 
-impl CacheHeader {
-    pub fn read_from_slice(buffer: &[u8]) -> Result<(&CacheHeader, &[u8]), Error> {
-        if buffer.len() >= mem::size_of::<CacheHeader>() {
+impl SerializedCacheHeader {
+    pub fn read_from_slice(buffer: &[u8]) -> Result<(&Self, &[u8]), Error> {
+        if buffer.len() >= mem::size_of::<SerializedCacheHeader>() {
             if &buffer[..8] == "WASMER\0\0".as_bytes() {
-                let (header_slice, body_slice) = buffer.split_at(mem::size_of::<CacheHeader>());
-                let header = unsafe { &*(header_slice.as_ptr() as *const CacheHeader) };
+                let (header_slice, body_slice) =
+                    buffer.split_at(mem::size_of::<SerializedCacheHeader>());
+                let header = unsafe { &*(header_slice.as_ptr() as *const SerializedCacheHeader) };
 
                 if header.version == CURRENT_CACHE_VERSION {
                     Ok((header, body_slice))
@@ -59,31 +81,31 @@ impl CacheHeader {
     }
 
     pub fn as_slice(&self) -> &[u8] {
-        let ptr = self as *const CacheHeader as *const u8;
-        unsafe { slice::from_raw_parts(ptr, mem::size_of::<CacheHeader>()) }
+        let ptr = self as *const SerializedCacheHeader as *const u8;
+        unsafe { slice::from_raw_parts(ptr, mem::size_of::<SerializedCacheHeader>()) }
     }
 }
 
 #[derive(Serialize, Deserialize)]
-struct CacheInner {
+struct SerializedCacheInner {
     info: Box<ModuleInfo>,
     #[serde(with = "serde_bytes")]
     backend_metadata: Box<[u8]>,
     compiled_code: Memory,
 }
 
-pub struct Cache {
-    inner: CacheInner,
+pub struct SerializedCache {
+    inner: SerializedCacheInner,
 }
 
-impl Cache {
+impl SerializedCache {
     pub(crate) fn from_parts(
         info: Box<ModuleInfo>,
         backend_metadata: Box<[u8]>,
         compiled_code: Memory,
     ) -> Self {
         Self {
-            inner: CacheInner {
+            inner: SerializedCacheInner {
                 info,
                 backend_metadata,
                 compiled_code,
@@ -91,7 +113,7 @@ impl Cache {
         }
     }
 
-    pub fn open<P>(path: P) -> Result<Cache, Error>
+    pub fn open<P>(path: P) -> Result<Self, Error>
     where
         P: AsRef<Path>,
     {
@@ -99,12 +121,12 @@ impl Cache {
 
         let mmap = unsafe { Mmap::map(&file).map_err(|e| Error::IoError(e))? };
 
-        let (header, body_slice) = CacheHeader::read_from_slice(&mmap[..])?;
+        let (_header, body_slice) = SerializedCacheHeader::read_from_slice(&mmap[..])?;
 
         let inner =
             deserialize(body_slice).map_err(|e| Error::DeserializeError(format!("{:#?}", e)))?;
 
-        Ok(Cache { inner })
+        Ok(SerializedCache { inner })
     }
 
     pub fn info(&self) -> &ModuleInfo {
@@ -132,8 +154,10 @@ impl Cache {
 
         let data_len = buffer.len() as u64;
 
-        file.seek(SeekFrom::Start(mem::size_of::<CacheHeader>() as u64))
-            .map_err(|e| Error::IoError(e))?;
+        file.seek(SeekFrom::Start(
+            mem::size_of::<SerializedCacheHeader>() as u64
+        ))
+        .map_err(|e| Error::IoError(e))?;
 
         file.write(buffer.as_slice())
             .map_err(|e| Error::IoError(e))?;
@@ -143,7 +167,7 @@ impl Cache {
 
         let wasm_hash = self.inner.info.wasm_hash.into_array();
 
-        let cache_header = CacheHeader {
+        let cache_header = SerializedCacheHeader {
             magic: [
                 'W' as u8, 'A' as u8, 'S' as u8, 'M' as u8, 'E' as u8, 'R' as u8, 0, 0,
             ],
@@ -159,8 +183,10 @@ impl Cache {
     }
 }
 
-pub fn hash_data(data: &[u8]) -> [u8; 32] {
-    let mut array = [0u8; 32];
-    array.copy_from_slice(Sha256::digest(data).as_slice());
-    array
+pub trait Cache {
+    type LoadError;
+    type StoreError;
+
+    unsafe fn load(&self, key: WasmHash) -> Result<Module, Self::LoadError>;
+    fn store(&mut self, module: Module) -> Result<WasmHash, Self::StoreError>;
 }

lib/runtime-core/src/lib.rs

@@ -43,7 +43,7 @@ pub use self::module::Module;
 pub use self::typed_func::Func;
 use std::sync::Arc;
 
-use self::cache::{Cache, Error as CacheError};
+use self::cache::{Error as CacheError, SerializedCache};
 
 pub mod prelude {
     pub use crate::import::{ImportObject, Namespace};
@@ -88,20 +88,8 @@ pub fn validate(wasm: &[u8]) -> bool {
     }
 }
 
-//
-// pub fn compile_to_cache_with(
-//     wasm: &[u8],
-//     compiler: &dyn backend::Compiler,
-// ) -> CompileResult<Cache> {
-//     let token = backend::Token::generate();
-//     let (info, backend_metadata, compiled_code) =
-//         compiler.compile_to_backend_cache_data(wasm, token)?;
-
-//     Ok(Cache::new(wasm, info, backend_metadata, compiled_code))
-// }
-
 pub unsafe fn load_cache_with(
-    cache: Cache,
+    cache: SerializedCache,
     compiler: &dyn backend::Compiler,
 ) -> std::result::Result<module::Module, CacheError> {
     let token = backend::Token::generate();

lib/runtime-core/src/module.rs

@@ -1,6 +1,6 @@
 use crate::{
     backend::{Backend, FuncResolver, ProtectedCaller},
-    cache::{Cache, Error as CacheError},
+    cache::{Error as CacheError, SerializedCache, WasmHash},
     error,
     import::ImportObject,
     structures::{Map, TypedIndex},
@@ -60,19 +60,6 @@ pub struct ModuleInfo {
     pub wasm_hash: WasmHash,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub struct WasmHash([u8; 32]);
-
-impl WasmHash {
-    pub fn generate(wasm: &[u8]) -> Self {
-        WasmHash(crate::cache::hash_data(wasm))
-    }
-
-    pub(crate) fn into_array(self) -> [u8; 32] {
-        self.0
-    }
-}
-
 /// A compiled WebAssembly module.
 ///
 /// `Module` is returned by the [`compile`] and
@@ -119,9 +106,9 @@ impl Module {
         Instance::new(Arc::clone(&self.inner), import_object)
     }
 
-    pub fn cache(&self) -> Result<Cache, CacheError> {
+    pub fn cache(&self) -> Result<SerializedCache, CacheError> {
         let (info, backend_metadata, code) = self.inner.cache_gen.generate_cache(&self.inner)?;
-        Ok(Cache::from_parts(info, backend_metadata, code))
+        Ok(SerializedCache::from_parts(info, backend_metadata, code))
     }
 
     pub fn info(&self) -> &ModuleInfo {