@feltdb/core 0.4.12 → 0.4.14

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

@@ -0,0 +1,259 @@
+/// Phase 7.1: Causal Release Economics
+///
+/// Measurement-only investigation to determine whether frontier advancement
+/// and pending-operation release is a material bottleneck.
+///
+/// Three possible outcomes:
+/// - Outcome A: Release is cheap (O(m) with low constants)
+/// - Outcome B: Release is O(m) but acceptable cost
+/// - Outcome C: Repeated advances cause O(m²) pathological rescanning
+///
+/// Only Outcome C justifies architectural changes to release mechanism.
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput};
+use feltdb::{CausalDependencyBarrier, VectorClock};
+
+fn make_vector_clock(node_count: usize) -> VectorClock {
+    let mut vc = VectorClock::new();
+    for i in 0..node_count {
+        vc.clocks.insert(format!("node_{}", i), 1);
+    }
+    vc
+}
+
+/// Benchmark 1: Single Release Scan
+///
+/// Measure: How expensive is one call to check_unblocked_operations()?
+/// Varies: Pending buffer size (0, 10, 100, 1K, 10K)
+/// Setup: All operations are blocked (frontier hasn't advanced enough)
+fn benchmark_release_single_scan(c: &mut Criterion) {
+    let mut group = c.benchmark_group("gate13_release_single_scan");
+    group.sample_size(20);
+
+    for pending_size in [0, 10, 100, 1000, 10000].iter() {
+        group.throughput(Throughput::Elements(*pending_size as u64));
+        group.bench_function(
+            format!("release_single_scan_pending{}", pending_size),
+            |b| {
+                b.iter_batched(
+                    || {
+                        // Setup: Create barrier and fill with pending operations
+                        let mut barrier = CausalDependencyBarrier::new();
+
+                        // All operations require high timestamps that frontier doesn't satisfy
+                        for i in 0..*pending_size {
+                            let mut required = VectorClock::new();
+                            // Each requires increasing timestamp: A:1000, A:1001, etc.
+                            required.clocks.insert("node_a".to_string(), (1000 + i) as u64);
+                            let _ = barrier.receive_operation(
+                                format!("pending_{}", i),
+                                required,
+                            );
+                        }
+                        barrier
+                    },
+                    |mut barrier| {
+                        // Measure: What does it cost to advance frontier by one operation?
+                        // This calls check_unblocked_operations() internally
+                        let mut frontier = VectorClock::new();
+                        frontier.clocks.insert("node_a".to_string(), 1);
+                        barrier.advance_frontier(&frontier);
+                        black_box(barrier)
+                    },
+                    criterion::BatchSize::SmallInput,
+                );
+            },
+        );
+    }
+
+    group.finish();
+}
+
+/// Benchmark 2: Release Selectivity
+///
+/// Measure: Does it matter what % of pending operations are ready?
+/// Varies: Pending size fixed at 1K, but % ready = [0, 1, 10, 50, 100]
+/// Question: Is the cost proportional to (pending_size) or (ready_count)?
+fn benchmark_release_selectivity(c: &mut Criterion) {
+    let mut group = c.benchmark_group("gate13_release_selectivity");
+    group.sample_size(20);
+
+    let pending_size = 1000;
+
+    for ready_percent in [0, 1, 10, 50, 100].iter() {
+        group.throughput(Throughput::Elements(pending_size as u64));
+        group.bench_function(
+            format!("release_selectivity_ready{}pct", ready_percent),
+            |b| {
+                b.iter_batched(
+                    || {
+                        let mut barrier = CausalDependencyBarrier::new();
+
+                        let ready_count = (pending_size * ready_percent) / 100;
+                        let blocked_count = pending_size - ready_count;
+
+                        // Add ready operations (frontier will satisfy them)
+                        for i in 0..ready_count {
+                            let mut required = VectorClock::new();
+                            // Frontier will be at A:2000, these require A:100
+                            required.clocks.insert("node_a".to_string(), 100);
+                            let _ = barrier.receive_operation(
+                                format!("ready_{}", i),
+                                required,
+                            );
+                        }
+
+                        // Add blocked operations (frontier won't satisfy them yet)
+                        for i in 0..blocked_count {
+                            let mut required = VectorClock::new();
+                            // These require A:5000, frontier will only be at A:2000
+                            required.clocks.insert("node_a".to_string(), 5000);
+                            let _ = barrier.receive_operation(
+                                format!("blocked_{}", i),
+                                required,
+                            );
+                        }
+                        barrier
+                    },
+                    |mut barrier| {
+                        // Measure: Advance frontier to release the ready operations
+                        let mut frontier = VectorClock::new();
+                        // Advance to A:2000 - just enough to release ready operations
+                        frontier.clocks.insert("node_a".to_string(), 2000);
+                        barrier.advance_frontier(&frontier);
+                        black_box(barrier)
+                    },
+                    criterion::BatchSize::SmallInput,
+                );
+            },
+        );
+    }
+
+    group.finish();
+}
+
+/// Benchmark 3: Pathological Repeated Release (THE CRITICAL TEST)
+///
+/// Measure: Does repeated frontier advancement cause O(m²) rescanning?
+/// Setup: 10,000 pending operations, all ready
+/// Scenario: Advance frontier 10,000 times (one per operation)
+/// Each advance should release exactly one operation
+///
+/// Question: Does the implementation catch this efficiently?
+///
+/// Expected behavior:
+/// - Good: entries_examined ≈ 10,000 (one pass through, each op examined once)
+/// - Bad: entries_examined ≈ 50,000,000 (each advance scans remaining operations)
+fn benchmark_release_pathological_repeated(c: &mut Criterion) {
+    let mut group = c.benchmark_group("gate13_release_pathological_repeated");
+    group.sample_size(5);  // Fewer samples for large workload
+    group.measurement_time(std::time::Duration::from_secs(30));
+
+    // Note: Using 1000 instead of 10000 to keep benchmark runtime reasonable
+    // The scaling pattern will still show if O(m²) is happening
+    let pending_size = 1000;
+
+    group.throughput(Throughput::Elements(pending_size as u64));
+    group.bench_function(
+        format!("release_pathological_{}ops_one_at_a_time", pending_size),
+        |b| {
+            b.iter_batched(
+                || {
+                    let mut barrier = CausalDependencyBarrier::new();
+
+                    // Create pending operations requiring A:1, A:2, A:3, ..., A:pending_size
+                    for i in 0..pending_size {
+                        let mut required = VectorClock::new();
+                        // Each requires A:(i+1)
+                        required.clocks.insert("node_a".to_string(), (i + 1) as u64);
+                        let _ = barrier.receive_operation(
+                            format!("seq_{}", i),
+                            required,
+                        );
+                    }
+                    barrier
+                },
+                |mut barrier| {
+                    // Now advance frontier one step at a time
+                    // This is the pathological scenario
+                    // Simulate advancing frontier one operation at a time
+                    for step in 1..=pending_size {
+                        let mut frontier = VectorClock::new();
+                        // Advance to A:step
+                        frontier.clocks.insert("node_a".to_string(), step as u64);
+                        barrier.advance_frontier(&frontier);
+                    }
+                    black_box(barrier)
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.finish();
+}
+
+/// Benchmark 4: Mixed Frontier Advances
+///
+/// Measure: Realistic scenario with varying frontier advances
+/// Setup: Operations with different dependency timestamps
+/// Scenario: Advance frontier gradually, each step releases some operations
+///
+/// This tests whether the implementation efficiently handles the common case
+/// of incremental frontier progress.
+fn benchmark_release_mixed_advances(c: &mut Criterion) {
+    let mut group = c.benchmark_group("gate13_release_mixed_advances");
+    group.sample_size(10);
+
+    for pending_size in [100, 1000].iter() {
+        group.throughput(Throughput::Elements(*pending_size as u64));
+        group.bench_function(
+            format!("release_mixed_advances_pending{}", pending_size),
+            |b| {
+                b.iter_batched(
+                    || {
+                        let mut barrier = CausalDependencyBarrier::new();
+
+                        // Create pending operations with mixed dependencies
+                        // Some require A:100, some A:500, some A:1000, etc.
+                        for i in 0..*pending_size {
+                            let mut required = VectorClock::new();
+
+                            // Distribute dependencies: some low, some high
+                            let dependency_level = ((i * 997) % 1000) as u64 + 1;
+                            required.clocks.insert("node_a".to_string(), dependency_level);
+
+                            let _ = barrier.receive_operation(
+                                format!("mixed_{}", i),
+                                required,
+                            );
+                        }
+                        barrier
+                    },
+                    |mut barrier| {
+                        // Measure: Series of frontier advances
+                        // Simulate gradual frontier advancement
+                        for level in (100..=1000).step_by(100) {
+                            let mut frontier = VectorClock::new();
+                            frontier.clocks.insert("node_a".to_string(), level as u64);
+                            barrier.advance_frontier(&frontier);
+                        }
+                        black_box(barrier)
+                    },
+                    criterion::BatchSize::SmallInput,
+                );
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    benchmark_release_single_scan,
+    benchmark_release_selectivity,
+    benchmark_release_pathological_repeated,
+    benchmark_release_mixed_advances,
+);
+criterion_main!(benches);