feat: add flush_all_blocks option to also write intermediate blocks

Author: rvagg

fvm/src/blockstore/buffered.rs

@@ -35,15 +35,17 @@ where
         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<()> {
+    /// Flushes all blocks from the write cache to the provided blockstore,
+    /// regardless of whether they're reachable from any state root.
+    /// Unlike the standard flush() operation which only writes blocks connected
+    /// to the final state tree, this writes every block created during execution.
+    pub fn flush_all(&self) -> Result<()> {
         log::info!(
-            "Dumping {} cache blocks to blockstore",
+            "Flushing all ({}) cache blocks to blockstore",
             self.write.borrow().len()
         );
-        bs.put_many_keyed(self.write.borrow().iter().map(|(k, v)| (*k, v.as_slice())))
+        self.base
+            .put_many_keyed(self.write.borrow().iter().map(|(k, v)| (*k, v.as_slice())))
     }
 }
 

fvm/src/executor/default.rs

@@ -5,7 +5,6 @@ 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;
@@ -290,12 +289,6 @@ 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,7 +7,6 @@ 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;
@@ -45,9 +44,6 @@ 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,7 +2,6 @@
 // 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;
 
@@ -51,9 +50,4 @@ 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,9 +485,6 @@ 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,7 +5,6 @@ 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;
 
@@ -49,11 +48,6 @@ 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

@@ -157,17 +157,19 @@ where
     /// This method also flushes all new blocks (reachable from this new root CID) from the write
     /// buffer into the underlying blockstore (the blockstore with which the machine was
     /// constructed).
+    ///
+    /// If an intermediate blockstore was provided, all intermediate blocks created during message
+    /// execution are flushed to it.
     fn flush(&mut self) -> Result<Cid> {
         let root = self.state_tree_mut().flush()?;
-        self.blockstore().flush(&root).or_fatal()?;
+        if self.context.flush_all_blocks {
+            self.blockstore().flush_all().or_fatal()?;
+        } else {
+            self.blockstore().flush(&root).or_fatal()?;
+        }
         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,9 +73,6 @@ 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;
 
@@ -197,6 +194,7 @@ impl NetworkConfig {
             initial_state_root: initial_state,
             circ_supply: fvm_shared::TOTAL_FILECOIN.clone(),
             tracing: false,
+            flush_all_blocks: false,
         }
     }
 
@@ -243,6 +241,10 @@ pub struct MachineContext {
     /// Whether or not to produce execution traces in the returned result.
     /// Not consensus-critical, but has a performance impact.
     pub tracing: bool,
+
+    /// When true, flush() will write all blocks created during execution to the
+    /// blockstore, not just those reachable from the final state root.
+    pub flush_all_blocks: bool,
 }
 
 impl MachineContext {

fvm/tests/dummy.rs

@@ -10,7 +10,6 @@ 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;
@@ -182,10 +181,6 @@ 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::{Blockstore, MemoryBlockstore};
+use fvm_ipld_blockstore::MemoryBlockstore;
 use fvm_shared::consensus::ConsensusFault;
 use fvm_shared::piece::PieceInfo;
 use fvm_shared::sector::{
@@ -137,10 +137,6 @@ 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()
     }