add dump_cache() to write out intermediate blocks to a blockstore

Author: rvagg

fvm/src/blockstore/buffered.rs

@@ -34,6 +34,17 @@ where
     pub fn into_inner(self) -> BS {
         self.base
     }
+
+    /// Dumps all cached state blocks to the provided blockstore. Blocks in the cache are not
+    /// guaranteed to be connected to the final state tree and may be intermediate state blocks
+    /// that are not reachable from the eventual state root.
+    pub fn dump_cache<S: Blockstore>(&self, bs: S) -> Result<()> {
+        log::info!(
+            "Dumping {} cache blocks to blockstore",
+            self.write.borrow().len()
+        );
+        bs.put_many_keyed(self.write.borrow().iter().map(|(k, v)| (*k, v.as_slice())))
+    }
 }
 
 impl<BS> Buffered for BufferedBlockstore<BS>

fvm/src/executor/default.rs

@@ -5,6 +5,7 @@ use std::result::Result as StdResult;
 
 use anyhow::{anyhow, Result};
 use cid::Cid;
+use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::{RawBytes, CBOR};
 use fvm_shared::address::Payload;
 use fvm_shared::econ::TokenAmount;
@@ -289,6 +290,12 @@ where
         let k = (**self).flush()?;
         Ok(k)
     }
+
+    /// Dumps all cached state blocks (intermediate and final) to the provided blockstore.
+    fn dump_cache<B: Blockstore>(&mut self, bs: B) -> anyhow::Result<()> {
+        (**self).dump_cache(bs)?;
+        Ok(())
+    }
 }
 
 impl<K> DefaultExecutor<K>

fvm/src/executor/mod.rs

@@ -7,6 +7,7 @@ use std::fmt::Display;
 
 use cid::Cid;
 pub use default::DefaultExecutor;
+use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::RawBytes;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::ExitCode;
@@ -44,6 +45,9 @@ pub trait Executor {
 
     /// Flushes the state-tree, returning the new root CID.
     fn flush(&mut self) -> anyhow::Result<Cid>;
+
+    /// Dumps all cached state blocks (intermediate and final) to the provided blockstore.
+    fn dump_cache<S: Blockstore>(&mut self, bs: S) -> anyhow::Result<()>;
 }
 
 /// A description of some failure encountered when applying a message.

fvm/src/executor/threaded.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 use anyhow::anyhow;
 use cid::Cid;
+use fvm_ipld_blockstore::Blockstore;
 use fvm_shared::message::Message;
 use lazy_static::lazy_static;
 
@@ -50,4 +51,9 @@ where
     fn flush(&mut self) -> anyhow::Result<Cid> {
         self.0.flush()
     }
+
+    /// Dumps all cached state blocks (intermediate and final) to the provided blockstore.
+    fn dump_cache<S: Blockstore>(&mut self, bs: S) -> anyhow::Result<()> {
+        self.0.dump_cache(bs)
+    }
 }

fvm/src/kernel/default.rs

@@ -485,6 +485,9 @@ where
             .or_fatal()?;
         self.blocks.mark_reachable(&k);
 
+        // TODO: remove this, it's just for debugging.
+        self.call_manager.log(format!("block_link({})", k));
+
         t.stop_with(start);
         Ok(k)
     }

fvm/src/machine/boxed.rs

@@ -5,6 +5,7 @@ use cid::Cid;
 use super::{Machine, MachineContext, Manifest};
 use crate::kernel::Result;
 use crate::state_tree::StateTree;
+use fvm_ipld_blockstore::Blockstore;
 
 type Type = MachineContext;
 
@@ -48,6 +49,11 @@ impl<M: Machine> Machine for Box<M> {
         (**self).flush()
     }
 
+    #[inline(always)]
+    fn dump_cache<B: Blockstore>(&mut self, bs: B) -> Result<()> {
+        (**self).dump_cache(bs)
+    }
+
     #[inline(always)]
     fn into_store(self) -> Self::Blockstore {
         (*self).into_store()

fvm/src/machine/default.rs

@@ -163,6 +163,11 @@ where
         Ok(root)
     }
 
+    /// Dumps all cached state blocks (intermediate and final) to the provided blockstore.
+    fn dump_cache<S: Blockstore>(&mut self, bs: S) -> Result<()> {
+        self.blockstore().dump_cache(bs).or_fatal()
+    }
+
     fn into_store(self) -> Self::Blockstore {
         self.state_tree.into_store()
     }

fvm/src/machine/mod.rs

@@ -73,6 +73,9 @@ pub trait Machine: 'static {
         self.state_tree_mut().flush()
     }
 
+    /// Dumps all cached state blocks (intermediate and final) to the provided blockstore.
+    fn dump_cache<S: Blockstore>(&mut self, bs: S) -> Result<()>;
+
     /// Consumes the machine and returns the owned blockstore.
     fn into_store(self) -> Self::Blockstore;
 

fvm/tests/dummy.rs

@@ -10,6 +10,7 @@ use fvm::call_manager::{Backtrace, CallManager, Entrypoint, FinishRet, Invocatio
 use fvm::engine::Engine;
 use fvm::externs::{Chain, Consensus, Externs, Rand};
 use fvm::gas::{Gas, GasCharge, GasTimer, GasTracker};
+use fvm::kernel::ExecutionError;
 use fvm::machine::limiter::MemoryLimiter;
 use fvm::machine::{Machine, MachineContext, Manifest, NetworkConfig};
 use fvm::state_tree::StateTree;
@@ -181,6 +182,10 @@ impl Machine for DummyMachine {
     fn new_limiter(&self) -> Self::Limiter {
         DummyLimiter::default()
     }
+
+    fn dump_cache<S: Blockstore>(&mut self, _bs: S) -> anyhow::Result<(), ExecutionError> {
+        Ok(())
+    }
 }
 
 /// Minimal *pseudo-functional* implementation CallManager

testing/conformance/src/vm.rs

@@ -10,7 +10,7 @@ use fvm::machine::limiter::MemoryLimiter;
 use fvm::machine::{DefaultMachine, Machine, MachineContext, Manifest, NetworkConfig};
 use fvm::state_tree::StateTree;
 use fvm::syscalls::Linker;
-use fvm_ipld_blockstore::MemoryBlockstore;
+use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore};
 use fvm_shared::consensus::ConsensusFault;
 use fvm_shared::piece::PieceInfo;
 use fvm_shared::sector::{
@@ -137,6 +137,10 @@ where
         self.machine.flush()
     }
 
+    fn dump_cache<S: Blockstore>(&mut self, bs: S) -> Result<()> {
+        self.machine.dump_cache(bs)
+    }
+
     fn machine_id(&self) -> &str {
         self.machine.machine_id()
     }