@feltdb/core 0.8.4 → 0.8.5

package/dist/create/server-source/crates/feltdb/benches/gate_14d_combined_dimension_scaling.rs

@@ -17,13 +17,13 @@
 /// - Replication: messages sent, delivered, delivery rate
 /// - Convergence: all replicas converged, state_hash match
 /// - Interaction ratio: observed throughput / expected composed throughput
-
 use feltdb::{
-    convergence::VectorClock, distributed_transactions::{
+    convergence::VectorClock,
+    distributed_transactions::{
         DistributedTransactionExecutor, ReplicationMessage, TransactionEnvelope,
     },
     state_hash::StateHash,
-    transactions::{Operation, OperationCommand, OperationId, StateVersion, ConsistencyContract},
+    transactions::{ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion},
 };
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
@@ -68,7 +68,13 @@ impl SeededRng {
     }
 }
 
-fn generate_operation(rng: &mut SeededRng, op_id: u64, seq: u64, node: &str, client_id: usize) -> Operation {
+fn generate_operation(
+    rng: &mut SeededRng,
+    op_id: u64,
+    seq: u64,
+    node: &str,
+    client_id: usize,
+) -> Operation {
     let record_id = format!("rec_{}", rng.next_range(0, 99));
     let _is_write = rng.next_f64() >= 0.7; // 70% reads, 30% writes
 
@@ -190,9 +196,10 @@ async fn measure_combination(
 
     // Initialize distributed system
     let initial_hash = StateHash::from_hex("hash0".to_string());
-    let leader_executor = Arc::new(Mutex::new(
-        DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone()),
-    ));
+    let leader_executor = Arc::new(Mutex::new(DistributedTransactionExecutor::new(
+        "leader".to_string(),
+        initial_hash.clone(),
+    )));
 
     // Create follower replicas
     let mut follower_executors = Vec::new();
@@ -202,9 +209,10 @@ async fn measure_combination(
             let replica_id = format!("replica_{}", i);
             leader.register_replica(replica_id.clone(), initial_hash.clone());
 
-            let replica_executor = Arc::new(Mutex::new(
-                DistributedTransactionExecutor::new(replica_id, initial_hash.clone()),
-            ));
+            let replica_executor = Arc::new(Mutex::new(DistributedTransactionExecutor::new(
+                replica_id,
+                initial_hash.clone(),
+            )));
             follower_executors.push(replica_executor);
         }
     }
@@ -223,7 +231,10 @@ async fn measure_combination(
     for client_id in 0..writers {
         let outcomes = Arc::clone(&outcomes);
         let leader = Arc::clone(&leader_executor);
-        let followers = follower_executors.iter().map(Arc::clone).collect::<Vec<_>>();
+        let followers = follower_executors
+            .iter()
+            .map(Arc::clone)
+            .collect::<Vec<_>>();
         let global_seq = Arc::clone(&global_seq);
         let admission_latencies = Arc::clone(&admission_latencies);
         let e2e_latencies = Arc::clone(&e2e_latencies);
@@ -326,7 +337,9 @@ async fn measure_combination(
         }
     }
 
-    let all_same = operations_applied_per_replica.iter().all(|&c| c == operations_accepted);
+    let all_same = operations_applied_per_replica
+        .iter()
+        .all(|&c| c == operations_accepted);
     let converged = all_same && operations_applied_per_replica.len() == replica_count;
 
     // Latency percentiles
@@ -401,7 +414,8 @@ async fn measure_combination(
         _ => 1.0,
     };
 
-    let expected_throughput = BASELINE_14C_SINGLE_WRITER_2_REPLICA * replica_factor * backlog_factor * writer_factor;
+    let expected_throughput =
+        BASELINE_14C_SINGLE_WRITER_2_REPLICA * replica_factor * backlog_factor * writer_factor;
 
     let interaction_ratio = if expected_throughput > 0.0 {
         throughput_ops_sec / expected_throughput
@@ -421,7 +435,10 @@ async fn measure_combination(
         "compositional".to_string()
     };
 
-    let correctness_check = converged && operations_applied_per_replica.iter().all(|&c| c == operations_accepted);
+    let correctness_check = converged
+        && operations_applied_per_replica
+            .iter()
+            .all(|&c| c == operations_accepted);
     let correctness_status = if correctness_check { "PASS" } else { "FAIL" };
 
     CombinationMetrics {
@@ -442,13 +459,15 @@ async fn measure_combination(
         end_to_end_latency_p99_us: p99_e2e,
         target_backlog_depth: backlog_depth,
         actual_max_pending_depth: backlog_depth.min(operations_accepted),
-        backlog_drain_rate_ops_sec: if backlog_depth > 0 && submission_duration.as_secs_f64() > 0.0 {
+        backlog_drain_rate_ops_sec: if backlog_depth > 0 && submission_duration.as_secs_f64() > 0.0
+        {
             backlog_depth as f64 / submission_duration.as_secs_f64()
         } else {
             0.0
         },
         operations_waiting_on_causal_barrier: backlog_depth.min(operations_accepted),
-        operations_ready_to_apply: (operations_accepted as isize - backlog_depth as isize).max(0) as usize,
+        operations_ready_to_apply: (operations_accepted as isize - backlog_depth as isize).max(0)
+            as usize,
         median_wait_time_for_barrier_us: if backlog_depth > 0 { 100 } else { 0 },
         p99_wait_time_for_barrier_us: if backlog_depth > 0 { 500 } else { 0 },
         replication_messages_sent: operations_accepted * (replica_count - 1),
@@ -492,7 +511,10 @@ fn main() {
     println!("  Writers: {:?}", WRITERS);
     println!("  Causal backlog depths: {:?}", BACKLOG_DEPTHS);
     println!("  Replica counts: {:?}", REPLICA_COUNTS);
-    println!("  Total combinations: {}\n", WRITERS.len() * BACKLOG_DEPTHS.len() * REPLICA_COUNTS.len());
+    println!(
+        "  Total combinations: {}\n",
+        WRITERS.len() * BACKLOG_DEPTHS.len() * REPLICA_COUNTS.len()
+    );
 
     let mut all_results = Vec::new();
     let mut combination_count = 0;
@@ -501,52 +523,108 @@ fn main() {
         for &backlog_depth in BACKLOG_DEPTHS {
             for &replica_count in REPLICA_COUNTS {
                 combination_count += 1;
-                print!("\n[{}/75] Writers={} Backlog={} Replicas={}... ",
-                    combination_count, writer_count, backlog_depth, replica_count);
+                print!(
+                    "\n[{}/75] Writers={} Backlog={} Replicas={}... ",
+                    combination_count, writer_count, backlog_depth, replica_count
+                );
                 std::io::Write::flush(&mut std::io::stdout()).unwrap();
 
-                let result = rt.block_on(measure_combination(writer_count, backlog_depth, replica_count));
+                let result = rt.block_on(measure_combination(
+                    writer_count,
+                    backlog_depth,
+                    replica_count,
+                ));
 
                 if result.correctness_status != "PASS" {
                     println!("❌ FAILED");
                     println!("\n⚠️  CORRECTNESS VIOLATION DETECTED");
                     println!("   Expected state_hash to match across all replicas");
-                    println!("   Configuration: writers={} backlog={} replicas={}",
-                        writer_count, backlog_depth, replica_count);
+                    println!(
+                        "   Configuration: writers={} backlog={} replicas={}",
+                        writer_count, backlog_depth, replica_count
+                    );
                     std::process::exit(1);
                 }
 
                 println!("✓");
 
                 // Detailed output
-                println!("\n{:-^60}", format!("Writers={} Backlog={} Replicas={}", writer_count, backlog_depth, replica_count));
+                println!(
+                    "\n{:-^60}",
+                    format!(
+                        "Writers={} Backlog={} Replicas={}",
+                        writer_count, backlog_depth, replica_count
+                    )
+                );
 
                 println!("\nADMISSION:");
                 println!("  operations_attempted: {}", result.operations_attempted);
-                println!("  operations_accepted: {}", result.operations_first_attempt_accepted);
-                println!("  operations_rejected: {}", result.operations_permanent_reject);
-                println!("  acceptance_rate_percent: {:.1}%", result.acceptance_rate_percent);
+                println!(
+                    "  operations_accepted: {}",
+                    result.operations_first_attempt_accepted
+                );
+                println!(
+                    "  operations_rejected: {}",
+                    result.operations_permanent_reject
+                );
+                println!(
+                    "  acceptance_rate_percent: {:.1}%",
+                    result.acceptance_rate_percent
+                );
 
                 println!("\nPERFORMANCE:");
                 println!("  throughput_ops_sec: {:.3}", result.throughput_ops_sec);
-                println!("  admission_latency_p50_us: {}", result.admission_latency_p50_us);
-                println!("  admission_latency_p95_us: {}", result.admission_latency_p95_us);
-                println!("  admission_latency_p99_us: {}", result.admission_latency_p99_us);
-                println!("  end_to_end_latency_p50_us: {}", result.end_to_end_latency_p50_us);
-                println!("  end_to_end_latency_p95_us: {}", result.end_to_end_latency_p95_us);
-                println!("  end_to_end_latency_p99_us: {}", result.end_to_end_latency_p99_us);
+                println!(
+                    "  admission_latency_p50_us: {}",
+                    result.admission_latency_p50_us
+                );
+                println!(
+                    "  admission_latency_p95_us: {}",
+                    result.admission_latency_p95_us
+                );
+                println!(
+                    "  admission_latency_p99_us: {}",
+                    result.admission_latency_p99_us
+                );
+                println!(
+                    "  end_to_end_latency_p50_us: {}",
+                    result.end_to_end_latency_p50_us
+                );
+                println!(
+                    "  end_to_end_latency_p95_us: {}",
+                    result.end_to_end_latency_p95_us
+                );
+                println!(
+                    "  end_to_end_latency_p99_us: {}",
+                    result.end_to_end_latency_p99_us
+                );
 
                 println!("\nCAUSAL BACKLOG:");
                 println!("  target_backlog: {}", result.target_backlog_depth);
                 println!("  actual_max_pending: {}", result.actual_max_pending_depth);
-                println!("  drain_rate_ops_sec: {:.3}", result.backlog_drain_rate_ops_sec);
-                println!("  operations_waiting_on_barrier: {}", result.operations_waiting_on_causal_barrier);
-                println!("  operations_ready_to_apply: {}", result.operations_ready_to_apply);
+                println!(
+                    "  drain_rate_ops_sec: {:.3}",
+                    result.backlog_drain_rate_ops_sec
+                );
+                println!(
+                    "  operations_waiting_on_barrier: {}",
+                    result.operations_waiting_on_causal_barrier
+                );
+                println!(
+                    "  operations_ready_to_apply: {}",
+                    result.operations_ready_to_apply
+                );
 
                 println!("\nREPLICATION:");
                 println!("  messages_sent: {}", result.replication_messages_sent);
-                println!("  messages_delivered: {}", result.replication_messages_delivered);
-                println!("  delivery_rate_percent: {:.1}%", result.replication_delivery_success_rate_percent);
+                println!(
+                    "  messages_delivered: {}",
+                    result.replication_messages_delivered
+                );
+                println!(
+                    "  delivery_rate_percent: {:.1}%",
+                    result.replication_delivery_success_rate_percent
+                );
                 for (i, &applied) in result.per_replica_operations_applied.iter().enumerate() {
                     if i == 0 {
                         println!("  operations_applied_leader: {}", applied);
@@ -556,13 +634,33 @@ fn main() {
                 }
 
                 println!("\nCORRECTNESS:");
-                println!("  replicas_converged: {}", if result.all_replicas_converged { "YES" } else { "NO" });
-                println!("  state_hashes_match: {}", if result.state_hashes_match { "YES" } else { "NO" });
+                println!(
+                    "  replicas_converged: {}",
+                    if result.all_replicas_converged {
+                        "YES"
+                    } else {
+                        "NO"
+                    }
+                );
+                println!(
+                    "  state_hashes_match: {}",
+                    if result.state_hashes_match {
+                        "YES"
+                    } else {
+                        "NO"
+                    }
+                );
                 println!("  status: {}", result.correctness_status);
 
                 println!("\nINTERACTION:");
-                println!("  observed_throughput: {:.3} ops/sec", result.throughput_ops_sec);
-                println!("  expected_throughput: {:.3} ops/sec (composed)", result.expected_throughput_ops_sec);
+                println!(
+                    "  observed_throughput: {:.3} ops/sec",
+                    result.throughput_ops_sec
+                );
+                println!(
+                    "  expected_throughput: {:.3} ops/sec (composed)",
+                    result.expected_throughput_ops_sec
+                );
                 println!("  interaction_ratio: {:.3}", result.interaction_ratio);
                 println!("  classification: {}", result.interaction_classification);
 
@@ -576,52 +674,85 @@ fn main() {
     println!("INTERACTION ANALYSIS");
     println!("═════════════════════════════════════════════════════════════");
 
-    let compositional: Vec<_> = all_results.iter()
+    let compositional: Vec<_> = all_results
+        .iter()
         .filter(|r| r.interaction_classification == "compositional")
         .collect();
-    let overhead: Vec<_> = all_results.iter()
+    let overhead: Vec<_> = all_results
+        .iter()
         .filter(|r| r.interaction_classification == "overhead")
         .collect();
-    let nonlinear: Vec<_> = all_results.iter()
+    let nonlinear: Vec<_> = all_results
+        .iter()
         .filter(|r| r.interaction_classification == "nonlinear")
         .collect();
-    let beneficial: Vec<_> = all_results.iter()
+    let beneficial: Vec<_> = all_results
+        .iter()
         .filter(|r| r.interaction_classification == "beneficial")
         .collect();
 
     println!("\nComposition Summary:");
-    println!("  Compositional (ratio ~1.0): {} combinations", compositional.len());
+    println!(
+        "  Compositional (ratio ~1.0): {} combinations",
+        compositional.len()
+    );
     if let Some(first) = compositional.first() {
-        println!("    Example: writers={} backlog={} replicas={}", first.writers, first.backlog_depth, first.replica_count);
+        println!(
+            "    Example: writers={} backlog={} replicas={}",
+            first.writers, first.backlog_depth, first.replica_count
+        );
     }
 
-    println!("  Overhead (ratio 1.0-2.0): {} combinations", overhead.len());
+    println!(
+        "  Overhead (ratio 1.0-2.0): {} combinations",
+        overhead.len()
+    );
     if let Some(first) = overhead.first() {
-        println!("    Example: writers={} backlog={} replicas={}", first.writers, first.backlog_depth, first.replica_count);
+        println!(
+            "    Example: writers={} backlog={} replicas={}",
+            first.writers, first.backlog_depth, first.replica_count
+        );
     }
 
     println!("  Nonlinear (ratio >2.0): {} combinations", nonlinear.len());
     if let Some(first) = nonlinear.first() {
-        println!("    Example: writers={} backlog={} replicas={}", first.writers, first.backlog_depth, first.replica_count);
+        println!(
+            "    Example: writers={} backlog={} replicas={}",
+            first.writers, first.backlog_depth, first.replica_count
+        );
     }
 
-    println!("  Beneficial (ratio <1.0): {} combinations", beneficial.len());
+    println!(
+        "  Beneficial (ratio <1.0): {} combinations",
+        beneficial.len()
+    );
 
     println!("\n\nOVERALL FINDING:");
     if nonlinear.is_empty() {
         println!("\n✅ Gate 14D finding: The three dimensions compose approximately independently");
-        println!("   through the tested configuration space, with typical interaction ratio < 2.0.");
+        println!(
+            "   through the tested configuration space, with typical interaction ratio < 2.0."
+        );
         println!("   No architectural bottlenecks identified.");
     } else {
         println!("\n⚠️  Gate 14D finding: A nonlinear interaction appears between dimensions");
         println!("   at certain configurations:");
         for (i, result) in nonlinear.iter().take(3).enumerate() {
-            println!("   {}. writers={} backlog={} replicas={} (ratio: {:.2})",
-                i + 1, result.writers, result.backlog_depth, result.replica_count, result.interaction_ratio);
+            println!(
+                "   {}. writers={} backlog={} replicas={} (ratio: {:.2})",
+                i + 1,
+                result.writers,
+                result.backlog_depth,
+                result.replica_count,
+                result.interaction_ratio
+            );
         }
     }
 
     println!("\n═════════════════════════════════════════════════════════════");
-    println!("Gate 14D measurement complete: {} combinations verified.", all_results.len());
+    println!(
+        "Gate 14D measurement complete: {} combinations verified.",
+        all_results.len()
+    );
     println!("═════════════════════════════════════════════════════════════\n");
 }

package/dist/create/server-source/crates/feltdb/benches/phase_7_1_2_optimization_benchmark.rs

@@ -7,17 +7,16 @@
 ///
 /// Key principle: Don't declare victory from a microbenchmark.
 /// Systematically measure: latency, examination counts, memory, concurrency.
-
-use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
 use feltdb::causal_dependency_barrier::CausalDependencyBarrier;
 use feltdb::convergence::VectorClock;
 
 /// Benchmark workload configuration
 #[derive(Clone, Debug)]
 struct BenchmarkWorkload {
-    pending_size: usize,        // 10, 100, 1K, 10K, 100K
-    frontier_advances: usize,   // 1, 10
-    release_selectivity: f64,   // Fraction of operations that will be released
+    pending_size: usize,      // 10, 100, 1K, 10K, 100K
+    frontier_advances: usize, // 1, 10
+    release_selectivity: f64, // Fraction of operations that will be released
 }
 
 /// Metrics collected during a benchmark run
@@ -46,8 +45,7 @@ impl ReleaseMetrics {
         if self.ref_pending_examined == 0 {
             0.0
         } else {
-            (1.0 - (self.opt_candidates_examined as f64 / self.ref_pending_examined as f64))
-                * 100.0
+            (1.0 - (self.opt_candidates_examined as f64 / self.ref_pending_examined as f64)) * 100.0
         }
     }
 
@@ -62,7 +60,10 @@ impl ReleaseMetrics {
 }
 
 /// Generate a benchmark workload with reproducible randomness
-fn generate_workload(workload: &BenchmarkWorkload, seed: u64) -> (Vec<(String, VectorClock)>, Vec<VectorClock>) {
+fn generate_workload(
+    workload: &BenchmarkWorkload,
+    seed: u64,
+) -> (Vec<(String, VectorClock)>, Vec<VectorClock>) {
     use std::collections::hash_map::DefaultHasher;
     use std::hash::{Hash, Hasher};
 
@@ -71,7 +72,9 @@ fn generate_workload(workload: &BenchmarkWorkload, seed: u64) -> (Vec<(String, V
     let mut rng_seed = hasher.finish();
 
     fn next_rng(seed: &mut u64) -> u64 {
-        *seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+        *seed = seed
+            .wrapping_mul(6364136223846793005)
+            .wrapping_add(1442695040888963407);
         *seed
     }
 
@@ -82,7 +85,8 @@ fn generate_workload(workload: &BenchmarkWorkload, seed: u64) -> (Vec<(String, V
     for i in 0..workload.pending_size {
         let mut required = VectorClock::new();
         // Create dependency that will be satisfied based on selectivity
-        let release_threshold = (workload.pending_size as f64 * workload.release_selectivity) as usize;
+        let release_threshold =
+            (workload.pending_size as f64 * workload.release_selectivity) as usize;
         let ts = if i < release_threshold {
             10 // Will be released when frontier advances to 10
         } else {
@@ -188,8 +192,10 @@ fn benchmark_optimization_matrix(c: &mut Criterion) {
     let selectivities = vec![0.10]; // Start with 10% release
 
     println!("\n=== Phase 7.1.2: Optimization Matrix Metrics ===");
-    println!("{:<8} {:<10} {:<10} {:<15} {:<15} {:<12} {:<12}",
-        "Pending", "Advances", "Selectivity", "Ref (µs)", "Opt (µs)", "Speedup", "Candidate %");
+    println!(
+        "{:<8} {:<10} {:<10} {:<15} {:<15} {:<12} {:<12}",
+        "Pending", "Advances", "Selectivity", "Ref (µs)", "Opt (µs)", "Speedup", "Candidate %"
+    );
 
     for pending in &pending_sizes {
         for advances in &advance_counts {
@@ -209,11 +215,23 @@ fn benchmark_optimization_matrix(c: &mut Criterion) {
                 let speedup = ref_metrics.ref_latency_ns as f64 / opt_metrics.opt_latency_ns as f64;
                 let candidate_reduction = opt_metrics.candidate_reduction_pct();
 
-                println!("{:<8} {:<10} {:<10.0}% {:<15.1} {:<15.1} {:<12.2}x {:<12.1}%",
-                    pending, advances, selectivity * 100.0, ref_us, opt_us, speedup, candidate_reduction);
+                println!(
+                    "{:<8} {:<10} {:<10.0}% {:<15.1} {:<15.1} {:<12.2}x {:<12.1}%",
+                    pending,
+                    advances,
+                    selectivity * 100.0,
+                    ref_us,
+                    opt_us,
+                    speedup,
+                    candidate_reduction
+                );
 
-                let bench_name = format!("pending_{}_advances_{}_sel_{:.0}pct",
-                    pending, advances, selectivity * 100.0);
+                let bench_name = format!(
+                    "pending_{}_advances_{}_sel_{:.0}pct",
+                    pending,
+                    advances,
+                    selectivity * 100.0
+                );
 
                 group.bench_with_input(
                     BenchmarkId::new("reference", &bench_name),
@@ -221,7 +239,11 @@ fn benchmark_optimization_matrix(c: &mut Criterion) {
                     |b, w| {
                         let (ops, advs) = generate_workload(w, 42);
                         b.iter(|| {
-                            benchmark_reference_release(black_box(w), black_box(&ops), black_box(&advs))
+                            benchmark_reference_release(
+                                black_box(w),
+                                black_box(&ops),
+                                black_box(&advs),
+                            )
                         });
                     },
                 );
@@ -232,7 +254,11 @@ fn benchmark_optimization_matrix(c: &mut Criterion) {
                     |b, w| {
                         let (ops, advs) = generate_workload(w, 42);
                         b.iter(|| {
-                            benchmark_optimized_release(black_box(w), black_box(&ops), black_box(&advs))
+                            benchmark_optimized_release(
+                                black_box(w),
+                                black_box(&ops),
+                                black_box(&advs),
+                            )
                         });
                     },
                 );
@@ -253,8 +279,10 @@ fn benchmark_selectivity_variation(c: &mut Criterion) {
     let selectivities = vec![0.0, 0.01, 0.10, 0.25, 0.50, 0.75, 1.0];
 
     println!("\n=== Phase 7.1.2: Selectivity Variation Metrics ===");
-    println!("{:<12} {:<15} {:<15} {:<12} {:<12}",
-        "Selectivity", "Ref (µs)", "Opt (µs)", "Speedup", "Candidate %");
+    println!(
+        "{:<12} {:<15} {:<15} {:<12} {:<12}",
+        "Selectivity", "Ref (µs)", "Opt (µs)", "Speedup", "Candidate %"
+    );
 
     for selectivity in selectivities {
         let workload = BenchmarkWorkload {
@@ -276,8 +304,14 @@ fn benchmark_selectivity_variation(c: &mut Criterion) {
         };
         let candidate_reduction = opt_metrics.candidate_reduction_pct();
 
-        println!("{:<12.0}% {:<15.1} {:<15.1} {:<12.2}x {:<12.1}%",
-            selectivity * 100.0, ref_us, opt_us, speedup, candidate_reduction);
+        println!(
+            "{:<12.0}% {:<15.1} {:<15.1} {:<12.2}x {:<12.1}%",
+            selectivity * 100.0,
+            ref_us,
+            opt_us,
+            speedup,
+            candidate_reduction
+        );
 
         let bench_name = format!("pending_1000_sel_{:.0}pct", selectivity * 100.0);
 
@@ -319,8 +353,10 @@ fn benchmark_pathological_scaling(c: &mut Criterion) {
     let selectivity = 0.10; // 10% of pending operations become ready each advance
 
     println!("\n=== Phase 7.1.2: Pathological Scaling (10 advances) ===");
-    println!("{:<10} {:<15} {:<15} {:<12} {:<12}",
-        "Pending", "Ref (µs)", "Opt (µs)", "Speedup", "Candidate %");
+    println!(
+        "{:<10} {:<15} {:<15} {:<12} {:<12}",
+        "Pending", "Ref (µs)", "Opt (µs)", "Speedup", "Candidate %"
+    );
 
     for pending in &pending_sizes {
         let workload = BenchmarkWorkload {
@@ -342,8 +378,10 @@ fn benchmark_pathological_scaling(c: &mut Criterion) {
         };
         let candidate_reduction = opt_metrics.candidate_reduction_pct();
 
-        println!("{:<10} {:<15.1} {:<15.1} {:<12.2}x {:<12.1}%",
-            pending, ref_us, opt_us, speedup, candidate_reduction);
+        println!(
+            "{:<10} {:<15.1} {:<15.1} {:<12.2}x {:<12.1}%",
+            pending, ref_us, opt_us, speedup, candidate_reduction
+        );
 
         let bench_name = format!("pending_{}_advances_{}", pending, advance_count);