Reset cache if version becomes active

massa-execution-worker/src/execution.rs

@@ -140,6 +140,7 @@ pub(crate) struct ExecutionState {
     pub(crate) execution_info: Arc<RwLock<ExecutionInfo>>,
     #[cfg(feature = "dump-block")]
     block_storage_backend: Arc<RwLock<dyn StorageBackend>>,
+    cur_execution_version: u32,
 }
 
 impl ExecutionState {
@@ -188,14 +189,16 @@ impl ExecutionState {
         })));
 
         // Create an empty placeholder execution context, with shared atomic access
-        let execution_context = Arc::new(Mutex::new(ExecutionContext::new(
+        let unwrapped_execution_context = ExecutionContext::new(
             config.clone(),
             final_state.clone(),
             active_history.clone(),
             module_cache.clone(),
             mip_store.clone(),
             execution_trail_hash,
-        )));
+        );
+        let cur_execution_version = unwrapped_execution_context.execution_component_version;
+        let execution_context = Arc::new(Mutex::new(unwrapped_execution_context));
 
         // Instantiate the interface providing ABI access to the VM, share the execution context with it
         let execution_interface = Box::new(InterfaceImpl::new(
@@ -238,6 +241,7 @@ impl ExecutionState {
             config,
             #[cfg(feature = "dump-block")]
             block_storage_backend,
+            cur_execution_version,
         }
     }
 
@@ -1458,7 +1462,7 @@ impl ExecutionState {
     /// # Returns
     /// An `ExecutionOutput` structure summarizing the output of the executed slot
     pub fn execute_slot(
-        &self,
+        &mut self,
         slot: &Slot,
         exec_target: Option<&(BlockId, ExecutionBlockMetadata)>,
         selector: Box<dyn SelectorController>,
@@ -1488,6 +1492,11 @@ impl ExecutionState {
         );
 
         let execution_version = execution_context.execution_component_version;
+        if self.cur_execution_version != execution_version {
+            // Reset the cache because a new execution version has become active
+            self.module_cache.write().reset();
+            self.cur_execution_version = execution_version;
+        }
 
         let mut deferred_calls_slot_gas = 0;
 

massa-module-cache/src/controller.rs

@@ -39,6 +39,11 @@ impl ModuleCache {
         }
     }
 
+    pub fn reset(&mut self) {
+        self.lru_cache.reset();
+        self.hd_cache.reset();
+    }
+
     /// Internal function to compile and build `ModuleInfo`
     fn compile_cached(
         &mut self,

massa-module-cache/src/hd_cache.rs

@@ -5,7 +5,7 @@ use massa_hash::Hash;
 use massa_sc_runtime::{CondomLimits, GasCosts, RuntimeModule};
 use massa_serialization::{DeserializeError, Deserializer, Serializer};
 use rand::RngCore;
-use rocksdb::{Direction, IteratorMode, WriteBatch, DB};
+use rocksdb::{Direction, IteratorMode, Options, WriteBatch, DB};
 use std::path::PathBuf;
 use tracing::debug;
 
@@ -36,7 +36,7 @@ macro_rules! metadata_key {
 
 pub(crate) struct HDCache {
     /// RocksDB database
-    db: DB,
+    db: Option<DB>,
     /// How many entries are in the db. Count is initialized at creation time by iterating
     /// over all the entries in the db then it is maintained in memory
     entry_count: usize,
@@ -63,7 +63,7 @@ impl HDCache {
         let entry_count = db.iterator(IteratorMode::Start).count();
 
         Self {
-            db,
+            db: Some(db),
             entry_count,
             max_entry_count,
             snip_amount,
@@ -72,6 +72,20 @@ impl HDCache {
         }
     }
 
+    pub fn reset(&mut self) {
+        let path = self.db.as_ref().unwrap().path().to_path_buf();
+
+        // Close the existing database by dropping it
+        let _ = self.db.take();
+
+        // Destroy the database files
+        DB::destroy(&Options::default(), &path).expect("Failed to destroy the database");
+        // Reopen the database
+        let db = DB::open_default(&path).expect(OPEN_ERROR);
+        self.db = Some(db);
+        self.entry_count = 0;
+    }
+
     /// Insert a new module in the cache
     pub fn insert(&mut self, hash: Hash, module_info: ModuleInfo) {
         if self.entry_count >= self.max_entry_count {
@@ -103,7 +117,11 @@ impl HDCache {
         let mut batch = WriteBatch::default();
         batch.put(module_key!(hash), ser_module);
         batch.put(metadata_key!(hash), ser_metadata);
-        self.db.write(batch).expect(CRUD_ERROR);
+        self.db
+            .as_ref()
+            .expect(CRUD_ERROR)
+            .write(batch)
+            .expect(CRUD_ERROR);
 
         self.entry_count = self.entry_count.saturating_add(1);
 
@@ -121,6 +139,8 @@ impl HDCache {
             .serialize(&ModuleMetadata::Delta(init_cost), &mut ser_metadata)
             .expect(DATA_SER_ERROR);
         self.db
+            .as_ref()
+            .expect(CRUD_ERROR)
             .put(metadata_key!(hash), ser_metadata)
             .expect(CRUD_ERROR);
     }
@@ -132,6 +152,8 @@ impl HDCache {
             .serialize(&ModuleMetadata::Invalid(err_msg), &mut ser_metadata)
             .expect(DATA_SER_ERROR);
         self.db
+            .as_ref()
+            .expect(CRUD_ERROR)
             .put(metadata_key!(hash), ser_metadata)
             .expect(CRUD_ERROR);
     }
@@ -145,6 +167,8 @@ impl HDCache {
     ) -> Option<ModuleInfo> {
         let mut iterator = self
             .db
+            .as_ref()
+            .expect(CRUD_ERROR)
             .iterator(IteratorMode::From(&module_key!(hash), Direction::Forward));
 
         if let (Some(Ok((key_1, ser_module))), Some(Ok((key_2, ser_metadata)))) =
@@ -181,7 +205,7 @@ impl HDCache {
 
     /// Try to remove as much as `self.amount_to_snip` entries from the db
     fn snip(&mut self) {
-        let mut iter = self.db.raw_iterator();
+        let mut iter = self.db.as_ref().expect(CRUD_ERROR).raw_iterator();
         let mut batch = WriteBatch::default();
         let mut snipped_count: usize = 0;
 
@@ -218,7 +242,11 @@ impl HDCache {
         }
 
         // delete the key and reduce entry_count
-        self.db.write(batch).expect(CRUD_ERROR);
+        self.db
+            .as_ref()
+            .expect(CRUD_ERROR)
+            .write(batch)
+            .expect(CRUD_ERROR);
         self.entry_count -= snipped_count;
     }
 }

massa-module-cache/src/lru_cache.rs

@@ -27,6 +27,10 @@ impl LRUCache {
         }
     }
 
+    pub fn reset(&mut self) {
+        self.cache.clear();
+    }
+
     /// If the module is contained in the cache:
     /// * retrieve a copy of it
     /// * move it up in the LRU cache