perf(drive-abci): stop rewriting the whole platform state every block

packages/rs-drive-abci/src/execution/platform_events/block_end/should_checkpoint/v0/mod.rs

@@ -203,7 +203,17 @@ mod tests {
             return;
         }
 
+        // Checkpoints are off in the default test config, and the guard for
+        // that returns before the age of the block is looked at. They have to
+        // be on for this test to reach the code it is about.
         let platform = TestPlatformBuilder::new()
+            .with_config(crate::config::PlatformConfig {
+                testing_configs: crate::config::PlatformTestConfig {
+                    disable_checkpoints: false,
+                    ..Default::default()
+                },
+                ..Default::default()
+            })
             .build_with_mock_rpc()
             .set_genesis_state();
 

packages/rs-drive-abci/src/execution/platform_events/block_end/update_state_cache/v0/mod.rs

@@ -54,6 +54,11 @@ where
         // Persist block state
         self.store_platform_state(&block_platform_state, Some(transaction), platform_version)?;
 
+        // Whatever the store wrote is now what is on disk for this block, so the
+        // next block only has to write the full record if it changes something
+        // heavy itself.
+        block_platform_state.heavy_fields_dirty = false;
+
         let block_platform_state = Arc::new(block_platform_state);
 
         self.state.store(block_platform_state);
@@ -222,4 +227,129 @@ mod tests {
             "genesis_block_info must always be cleared"
         );
     }
+
+    /// While replaying history the full saved record is rewritten only when a
+    /// heavy field changed; the small record carries the block info in between.
+    /// A node restarted from disk must see the newest block info and the heavy
+    /// fields from the last full write.
+    #[test]
+    fn v0_historical_block_with_clean_heavy_fields_reloads_from_the_small_record() {
+        use crate::config::{PlatformConfig, PlatformTestConfig};
+        use crate::platform_types::platform::Platform;
+        use crate::platform_types::platform_state::PlatformState;
+        use dpp::block::extended_block_info::v0::ExtendedBlockInfoV0Getters;
+        use dpp::dashcore::{ProTxHash, Txid};
+        use dpp::dashcore_rpc::dashcore_rpc_json::{DMNState, MasternodeListItem, MasternodeType};
+        use dpp::serialization::PlatformDeserializableFromVersionedStructure;
+
+        let platform_version = PlatformVersion::latest();
+        let platform = TestPlatformBuilder::new()
+            .with_config(PlatformConfig {
+                testing_configs: PlatformTestConfig {
+                    store_platform_state: true,
+                    ..PlatformTestConfig::default_minimal_verifications()
+                },
+                ..Default::default()
+            })
+            .build_with_mock_rpc()
+            .set_genesis_state();
+
+        let loaded = platform.state.load();
+        let mut block_platform_state = loaded.as_ref().clone();
+        drop(loaded);
+
+        // A block from long ago, so the store treats it as replayed history.
+        let mut old_block = make_extended_block_info(7);
+        old_block.basic_info_mut().time_ms = 1_000_000;
+
+        // Block 7 changes a heavy field, so it is written in full.
+        let pro_tx_hash = ProTxHash::from_byte_array([0x77u8; 32]);
+        let masternode = MasternodeListItem {
+            node_type: MasternodeType::Regular,
+            pro_tx_hash,
+            collateral_hash: Txid::from_byte_array([0u8; 32]),
+            collateral_index: 0,
+            collateral_address: [0u8; 20],
+            operator_reward: 0.0,
+            state: DMNState {
+                service: "1.2.3.4:1234".parse().expect("socket address"),
+                registered_height: 0,
+                pose_revived_height: None,
+                pose_ban_height: None,
+                revocation_reason: 0,
+                owner_address: [0u8; 20],
+                voting_address: [0u8; 20],
+                payout_address: [0u8; 20],
+                pub_key_operator: vec![0u8; 48],
+                operator_payout_address: None,
+                platform_node_id: None,
+                platform_p2p_port: None,
+                platform_http_port: None,
+            },
+        };
+        block_platform_state
+            .full_masternode_list_mut()
+            .insert(pro_tx_hash, masternode);
+        assert!(block_platform_state.heavy_fields_dirty);
+
+        let transaction = platform.drive.grove.start_transaction();
+        platform
+            .update_state_cache_v0(
+                old_block,
+                block_platform_state,
+                &transaction,
+                platform_version,
+            )
+            .expect("block 7 must be stored");
+
+        // Block 8 changes nothing heavy, so only the small record is written.
+        let loaded = platform.state.load();
+        let block_platform_state = loaded.as_ref().clone();
+        drop(loaded);
+        assert!(!block_platform_state.heavy_fields_dirty);
+
+        let mut old_block = make_extended_block_info(8);
+        old_block.basic_info_mut().time_ms = 1_000_001;
+        platform
+            .update_state_cache_v0(
+                old_block,
+                block_platform_state,
+                &transaction,
+                platform_version,
+            )
+            .expect("block 8 must be stored");
+
+        let reloaded = Platform::<crate::rpc::core::MockCoreRPCLike>::fetch_platform_state(
+            &platform.drive,
+            Some(&transaction),
+            platform_version,
+        )
+        .expect("fetch must succeed")
+        .expect("a state was stored");
+
+        assert_eq!(
+            reloaded.last_committed_block_height(),
+            8,
+            "block info comes from the small record written at block 8"
+        );
+        assert!(
+            reloaded.full_masternode_list().contains_key(&pro_tx_hash),
+            "heavy fields come from the full record written at block 7"
+        );
+
+        // The full record on disk must still be block 7's: that is what proves
+        // block 8 skipped it rather than rewriting it with the same contents.
+        let full_bytes = platform
+            .drive
+            .fetch_platform_state_bytes(Some(&transaction), platform_version)
+            .expect("fetch must succeed")
+            .expect("a full record was stored");
+        let full_record = PlatformState::versioned_deserialize(&full_bytes, platform_version)
+            .expect("full record must deserialize");
+        assert_eq!(
+            full_record.last_committed_block_height(),
+            7,
+            "the full record is not rewritten for a historical block that changed nothing heavy"
+        );
+    }
 }

packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/update_state_masternode_list/v0/mod.rs

@@ -109,6 +109,23 @@ where
             ..
         } = &masternode_diff;
 
+        // Core advances a block without any masternode changing far more often
+        // than not. Returning before the first mutable borrow keeps the platform
+        // state clean, which is what lets the block skip rewriting the full saved
+        // state (over a megabyte on mainnet) to disk.
+        if !start_from_scratch
+            && added_mns.is_empty()
+            && removed_mns.is_empty()
+            && updated_mns.is_empty()
+        {
+            return Ok(
+                update_state_masternode_list_outcome::v0::UpdateStateMasternodeListOutcome {
+                    masternode_list_diff: masternode_diff,
+                    removed_masternodes: BTreeMap::new(),
+                },
+            );
+        }
+
         //todo: clean up
         let added_hpmns = added_mns.iter().filter_map(|masternode| {
             if masternode.node_type == MasternodeType::Evo {

packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_quorum_info/v0/mod.rs

@@ -117,27 +117,34 @@ where
             .into_iter()
             .collect();
 
-        let mut removed_a_validator_set = false;
+        // Checked before taking a mutable borrow: on most blocks Core reports the
+        // same quorums as the block before, and taking the borrow marks the whole
+        // platform state as needing a full rewrite to disk.
+        let removed_a_validator_set = block_platform_state
+            .validator_sets()
+            .keys()
+            .any(|quorum_hash| !validator_quorums_list.contains_key::<QuorumHash>(quorum_hash));
 
         // Remove validator_sets entries that are no longer valid for the core block height
-        block_platform_state
-            .validator_sets_mut()
-            .retain(|quorum_hash, _| {
-                let retain = validator_quorums_list.contains_key::<QuorumHash>(quorum_hash);
-                removed_a_validator_set |= !retain;
-
-                if !retain {
-                    tracing::trace!(
-                        ?quorum_hash,
-                        quorum_type = ?self.config.validator_set.quorum_type,
-                        "removed validator set {} with quorum type {}",
-                        quorum_hash,
-                        self.config.validator_set.quorum_type
-                    )
-                }
+        if removed_a_validator_set {
+            block_platform_state
+                .validator_sets_mut()
+                .retain(|quorum_hash, _| {
+                    let retain = validator_quorums_list.contains_key::<QuorumHash>(quorum_hash);
+
+                    if !retain {
+                        tracing::trace!(
+                            ?quorum_hash,
+                            quorum_type = ?self.config.validator_set.quorum_type,
+                            "removed validator set {} with quorum type {}",
+                            quorum_hash,
+                            self.config.validator_set.quorum_type
+                        )
+                    }
 
-                retain
-            });
+                    retain
+                });
+        }
 
         // Fetch quorum info and their keys from the RPC for new quorums
         let mut quorum_infos = validator_quorums_list
@@ -192,25 +199,28 @@ where
 
         let is_validator_set_updated = !new_validator_sets.is_empty() || removed_a_validator_set;
 
-        // Add new validator_sets entries
-        block_platform_state
-            .validator_sets_mut()
-            .extend(new_validator_sets);
-
-        // Sort all validator sets into deterministic order by core block height of creation
-        block_platform_state
-            .validator_sets_mut()
-            .sort_by(|_, quorum_a, _, quorum_b| {
-                let primary_comparison = quorum_b.core_height().cmp(&quorum_a.core_height());
-                if primary_comparison == std::cmp::Ordering::Equal {
-                    quorum_b
-                        .quorum_hash()
-                        .cmp(quorum_a.quorum_hash())
-                        .then_with(|| quorum_b.core_height().cmp(&quorum_a.core_height()))
-                } else {
-                    primary_comparison
-                }
-            });
+        // Add new validator_sets entries. Nothing added and nothing removed means
+        // the map is already the one the previous block sorted, so leave it be.
+        if is_validator_set_updated {
+            block_platform_state
+                .validator_sets_mut()
+                .extend(new_validator_sets);
+
+            // Sort all validator sets into deterministic order by core block height of creation
+            block_platform_state
+                .validator_sets_mut()
+                .sort_by(|_, quorum_a, _, quorum_b| {
+                    let primary_comparison = quorum_b.core_height().cmp(&quorum_a.core_height());
+                    if primary_comparison == std::cmp::Ordering::Equal {
+                        quorum_b
+                            .quorum_hash()
+                            .cmp(quorum_a.quorum_hash())
+                            .then_with(|| quorum_b.core_height().cmp(&quorum_a.core_height()))
+                    } else {
+                        primary_comparison
+                    }
+                });
+        }
 
         // Update Chain Lock quorums
 
@@ -231,7 +241,7 @@ where
         } else {
             self.update_quorums_from_quorum_list(
                 quorum_set_type,
-                block_platform_state.chain_lock_validating_quorums_mut(),
+                block_platform_state,
                 platform_state,
                 &extended_quorum_list,
                 last_committed_core_height,
@@ -266,7 +276,7 @@ where
         } else {
             self.update_quorums_from_quorum_list(
                 quorum_set_type,
-                block_platform_state.instant_lock_validating_quorums_mut(),
+                block_platform_state,
                 platform_state,
                 &extended_quorum_list,
                 last_committed_core_height,
@@ -319,7 +329,7 @@ where
     fn update_quorums_from_quorum_list(
         &self,
         quorum_set_type: QuorumSetType,
-        quorum_set: &mut SignatureVerificationQuorumSet,
+        block_platform_state: &mut PlatformState,
         platform_state: Option<&PlatformState>,
         full_quorum_list: &ExtendedQuorumListResult,
         last_committed_core_height: u32,
@@ -341,6 +351,25 @@ where
             })
             .collect();
 
+        // Core reports the same quorums on most blocks. Decide read-only whether
+        // anything moved, because reaching for the mutable quorum set marks the
+        // whole platform state as needing a full rewrite to disk.
+        {
+            let current =
+                quorum_set_by_type(block_platform_state, &quorum_set_type).current_quorums();
+            let unchanged = current.len() == quorums_list.len()
+                && current.iter().all(|(quorum_hash, quorum)| {
+                    quorums_list
+                        .get(quorum_hash)
+                        .is_some_and(|index| *index == quorum.index)
+                });
+            if unchanged {
+                return Ok(false);
+            }
+        }
+
+        let quorum_set = quorum_set_by_type_mut(block_platform_state, &quorum_set_type);
+
         let mut removed_a_validating_quorum = false;
 
         // Remove validating_quorums entries that are no longer valid for the core block height