randomize tx limits in test per epoch

Author: alex-mysten

Cargo.lock

@@ -1,8 +1,15 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+use rand::SeedableRng;
+use rand::rngs::StdRng;
+
 use crate::in_antithesis;
 
+pub fn seeded_rng(seed: &[u8; 32]) -> StdRng {
+    StdRng::from_seed(*seed)
+}
+
 /// Get a random number generator.
 ///
 /// If we are running in antithesis mode, use the antithesis RNG.

crates/mysten-common/src/random.rs

@@ -1111,7 +1111,9 @@ impl AuthorityPerEpochStore {
             chain_from_id, chain.1
         );
 
-        let protocol_config = ProtocolConfig::get_for_version(protocol_version, chain.1);
+        let mut protocol_config = ProtocolConfig::get_for_version(protocol_version, chain.1);
+        protocol_config
+            .apply_seeded_test_overrides(epoch_start_configuration.epoch_digest().inner());
 
         let execution_component = ExecutionComponents::new(
             &protocol_config,

crates/sui-core/src/authority/authority_per_epoch_store.rs

@@ -644,7 +644,9 @@ impl CheckpointQueue {
             let next_tx_count = queued.roots.tx_roots.len();
 
             if current_tx_count + next_tx_count > max_tx && !current_roots.is_empty() {
-                assert_reachable!("checkpoint split due to transaction limit");
+                assert_reachable!(
+                    "checkpoint flush split due to batched roots exceeding transaction limit"
+                );
                 let details = current_details.unwrap();
                 pending_checkpoints.push(PendingCheckpointV2 {
                     roots: std::mem::take(&mut current_roots),
@@ -1710,7 +1712,17 @@ impl<C: CheckpointServiceNotify + Send + Sync> ConsensusHandler<C> {
                     .collect()
             };
 
+        let num_schedulables = schedulables.len();
         let chunked_schedulables = build_chunks(schedulables, &mut checkpoint_queue);
+        if chunked_schedulables.len() > 1 {
+            info!(
+                "Splitting transactions into {} checkpoint chunks (num_schedulables={}, max_tx={})",
+                chunked_schedulables.len(),
+                num_schedulables,
+                max_transactions_per_checkpoint
+            );
+            assert_reachable!("checkpoint split due to transaction limit");
+        }
         let chunked_randomness_schedulables = if should_write_random_checkpoint {
             build_chunks(randomness_schedulables, &mut checkpoint_queue)
         } else {

crates/sui-core/src/consensus_handler.rs

@@ -22,6 +22,7 @@ fastcrypto = { workspace = true }
 move-core-types.workspace = true
 move-binary-format.workspace = true
 mysten-common.workspace = true
+rand.workspace = true
 
 [dev-dependencies]
 insta.workspace = true

crates/sui-protocol-config/Cargo.toml

@@ -4554,21 +4554,24 @@ impl ProtocolConfig {
             }
         }
 
-        // Simtest specific overrides.
-        if cfg!(msim) {
-            // Trigger checkpoint splitting more often.
-            // cfg.max_transactions_per_checkpoint = Some(10);
-            // FIXME: Re-introduce this once we resolve the checkpoint splitting issue
-            // in the quarantine output.
-        }
+        cfg
+    }
 
-        // Antithesis specific overrides.
-        #[cfg(not(msim))]
-        if mysten_common::in_antithesis() {
-            cfg.max_transactions_per_checkpoint = Some(100);
+    pub fn apply_seeded_test_overrides(&mut self, seed: &[u8; 32]) {
+        let should_apply = if cfg!(msim) {
+            true
+        } else {
+            mysten_common::in_antithesis()
+        };
+        if !should_apply {
+            return;
         }
 
-        cfg
+        use rand::Rng;
+        let mut rng = mysten_common::random::seeded_rng(seed);
+        let max_txns = rng.gen_range(10..=100u64);
+        info!("seeded test override: max_transactions_per_checkpoint = {max_txns}");
+        self.max_transactions_per_checkpoint = Some(max_txns);
     }
 
     // Extract the bytecode verifier config from this protocol config.