remove cache stats

Author: colmazia

packages/vm/src/cache.rs

@@ -1,5 +1,5 @@
 use std::{
-    borrow::{BorrowMut},
+    borrow::BorrowMut,
     sync::{Arc, RwLock},
 };
 
@@ -9,18 +9,6 @@ use crate::error::Error;
 use clru::CLruCache;
 use wasmer::{Instance, Module, Store};
 
-#[derive(Debug, Default, Clone, Copy, PartialEq)]
-pub struct Stats {
-    pub hits: u32,
-    pub misses: u32,
-}
-
-impl Stats {
-    pub fn new() -> Self {
-        Self { hits: 0, misses: 0 }
-    }
-}
-
 /// An in-memory module cache
 pub struct InMemoryCache {
     modules: CLruCache<Checksum, Module>,
@@ -48,55 +36,45 @@ pub struct CacheOptions {
 
 pub struct Cache {
     memory_cache: Arc<RwLock<InMemoryCache>>,
-    stats: Stats,
 }
 
 impl Cache {
     pub fn new(options: CacheOptions) -> Self {
         let CacheOptions { cache_size } = options;
 
-        Self {
-            memory_cache: Arc::new(RwLock::new(InMemoryCache::new(cache_size))),
-            stats: Stats::new(),
-        }
-    }
-
-    pub fn stats(&self) -> &Stats {
-        &self.stats
+        Self { memory_cache: Arc::new(RwLock::new(InMemoryCache::new(cache_size))) }
     }
 
     fn with_in_memory_cache<C, R>(&mut self, callback: C) -> R
     where
-        C: FnOnce(&mut InMemoryCache, &mut Stats) -> R,
+        C: FnOnce(&mut InMemoryCache) -> R,
     {
         let mut guard = self.memory_cache.as_ref().write().unwrap();
         let in_memory_cache = guard.borrow_mut();
-        callback(in_memory_cache, &mut self.stats)
+        callback(in_memory_cache)
     }
 
     pub fn get_instance(
         &mut self,
         wasm: &[u8],
         store: &Store,
         import_object: &wasmer::ImportObject,
-    ) -> Result<wasmer::Instance, Error> {
+    ) -> Result<(wasmer::Instance, bool), Error> {
         let checksum = Checksum::generate(wasm);
-        self.with_in_memory_cache(|in_memory_cache, stats| {
+        self.with_in_memory_cache(|in_memory_cache| {
             // lookup cache
             if let Some(module) = in_memory_cache.load(&checksum) {
-                stats.hits += 1;
-                return Ok(Instance::new(&module, &import_object).unwrap());
+                return Ok((Instance::new(&module, &import_object).unwrap(), true));
             }
-            stats.misses += 1;
-            
+
             // recompile
             let module = Module::new(store, &wasm).map_err(|_| Error::InstantiationError)?;
             let instance =
-            Instance::new(&module, &import_object).map_err(|_| Error::InstantiationError)?;
-            
+                Instance::new(&module, &import_object).map_err(|_| Error::InstantiationError)?;
+
             in_memory_cache.store(&checksum, module);
-            
-            Ok(instance)
+
+            Ok((instance, false))
         })
     }
 }
@@ -126,13 +104,13 @@ mod test {
         wasm
     }
 
-    fn get_instance_without_err(cache: &mut Cache, wasm: &[u8]) -> wasmer::Instance {
+    fn get_instance_without_err(cache: &mut Cache, wasm: &[u8]) -> (wasmer::Instance, bool) {
         let compiler = Singlepass::new();
         let store = Store::new(&Universal::new(compiler).engine());
         let import_object = imports! {};
 
         match cache.get_instance(&wasm, &store, &import_object) {
-            Ok(instance) => instance,
+            Ok((instance, is_hit)) => (instance, is_hit),
             Err(_) => panic!("Fail to get instance"),
         }
     }
@@ -155,14 +133,14 @@ mod test {
               )"#,
         );
 
-        let instance1 = get_instance_without_err(&mut cache, &wasm);
-        assert_eq!(&Stats { hits: 0, misses: 1 }, cache.stats());
+        let (instance1, is_hit) = get_instance_without_err(&mut cache, &wasm);
+        assert_eq!(false, is_hit);
 
-        let instance2 = get_instance_without_err(&mut cache, &wasm);
-        assert_eq!(&Stats { hits: 1, misses: 1 }, cache.stats());
+        let (instance2, is_hit) = get_instance_without_err(&mut cache, &wasm);
+        assert_eq!(true, is_hit);
 
-        get_instance_without_err(&mut cache, &wasm2);
-        assert_eq!(&Stats { hits: 1, misses: 2 }, cache.stats());
+        let (_, is_hit) = get_instance_without_err(&mut cache, &wasm2);
+        assert_eq!(false, is_hit);
 
         let ser1 = match instance1.module().serialize() {
             Ok(r) => r,
@@ -205,31 +183,31 @@ mod test {
         );
 
         // miss [_ _] => [1 _]
-        get_instance_without_err(&mut cache, &wasm1);
-        assert_eq!(&Stats { hits: 0, misses: 1 }, cache.stats());
+        let (_, is_hit) = get_instance_without_err(&mut cache, &wasm1);
+        assert_eq!(false, is_hit);
 
         // miss [1 _] => [2 1]
-        get_instance_without_err(&mut cache, &wasm2);
-        assert_eq!(&Stats { hits: 0, misses: 2 }, cache.stats());
+        let (_, is_hit) = get_instance_without_err(&mut cache, &wasm2);
+        assert_eq!(false, is_hit);
 
         // miss [2 1] => [3 2]
-        get_instance_without_err(&mut cache, &wasm3);
-        assert_eq!(&Stats { hits: 0, misses: 3 }, cache.stats());
+        let (_, is_hit) = get_instance_without_err(&mut cache, &wasm3);
+        assert_eq!(false, is_hit);
 
         // hit [3 2] => [2 3]
-        get_instance_without_err(&mut cache, &wasm2);
-        assert_eq!(&Stats { hits: 1, misses: 3 }, cache.stats());
+        let (_, is_hit) = get_instance_without_err(&mut cache, &wasm2);
+        assert_eq!(true, is_hit);
 
         // miss [2 3] => [1 2]
-        get_instance_without_err(&mut cache, &wasm1);
-        assert_eq!(&Stats { hits: 1, misses: 4 }, cache.stats());
+        let (_, is_hit) = get_instance_without_err(&mut cache, &wasm1);
+        assert_eq!(false, is_hit);
 
         // hit [1 2] => [2 1]
-        get_instance_without_err(&mut cache, &wasm2);
-        assert_eq!(&Stats { hits: 2, misses: 4 }, cache.stats());
+        let (_, is_hit) = get_instance_without_err(&mut cache, &wasm2);
+        assert_eq!(true, is_hit);
 
         // miss [2 1] => [3 2]
-        get_instance_without_err(&mut cache, &wasm3);
-        assert_eq!(&Stats { hits: 2, misses: 5 }, cache.stats());
+        let (_, is_hit) = get_instance_without_err(&mut cache, &wasm3);
+        assert_eq!(false, is_hit);
     }
 }

packages/vm/src/calls.rs

@@ -21,7 +21,7 @@ where
     let store = make_store();
     let import_object = create_import_object(&store, owasm_env.clone());
 
-    let instance = cache.get_instance(code, &store, &import_object)?;
+    let (instance, _) = cache.get_instance(code, &store, &import_object)?;
     let instance_ptr = NonNull::from(&instance);
     owasm_env.set_wasmer_instance(Some(instance_ptr));
     owasm_env.set_gas_left(gas_limit);

packages/vm/src/imports.rs

@@ -322,7 +322,7 @@ mod test {
         let store = make_store();
         let import_object = create_import_object(&store, owasm_env.clone());
         let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
-        let instance = cache.get_instance(&code, &store, &import_object).unwrap();
+        let (instance, _) = cache.get_instance(&code, &store, &import_object).unwrap();
 
         return (owasm_env, instance);
     }

packages/vm/src/vm.rs

@@ -253,7 +253,7 @@ mod test {
         let store = Store::new(&Universal::new(compiler).engine());
         let import_object = imports! {};
         let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
-        let instance = cache.get_instance(&wasm, &store, &import_object).unwrap();
+        let (instance, _) = cache.get_instance(&wasm, &store, &import_object).unwrap();
         env.set_wasmer_instance(Some(NonNull::from(&instance)));
         assert_eq!(Ok(()), env.with_wasmer_instance(|_| { Ok(()) }));
     }
@@ -270,7 +270,7 @@ mod test {
         let store = make_store();
         let import_object = imports! {};
         let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
-        let instance = cache.get_instance(&wasm, &store, &import_object).unwrap();
+        let (instance, _) = cache.get_instance(&wasm, &store, &import_object).unwrap();
         env.set_wasmer_instance(Some(NonNull::from(&instance)));
 
         assert_eq!(0, env.get_gas_left());