Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

vendor/ruvector/crates/cognitum-gate-tilezero/benches/benchmarks.rs

@@ -0,0 +1,638 @@
+//! Consolidated benchmarks for cognitum-gate-tilezero
+//!
+//! Target latencies:
+//! - Merge 255 reports: < 10ms
+//! - Full gate decision: p99 < 50ms
+//! - Receipt hash: < 10us
+//! - Chain verify 1000 receipts: < 100ms
+//! - Permit sign: < 5ms
+//! - Permit verify: < 1ms
+
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use rand::Rng;
+use std::collections::HashMap;
+
+use cognitum_gate_tilezero::{
+    merge::{EdgeSummary, MergeStrategy, NodeSummary, ReportMerger, WorkerReport},
+    ActionContext, ActionMetadata, ActionTarget, EvidenceFilter, GateDecision, GateThresholds,
+    PermitState, PermitToken, ReceiptLog, ReducedGraph, ThreeFilterDecision, TileId, TileZero,
+    TimestampProof, WitnessReceipt, WitnessSummary,
+};
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/// Create a test permit token
+fn create_test_token(sequence: u64) -> PermitToken {
+    PermitToken {
+        decision: GateDecision::Permit,
+        action_id: format!("action-{}", sequence),
+        timestamp: 1704067200_000_000_000 + sequence * 1_000_000,
+        ttl_ns: 60_000_000_000,
+        witness_hash: [0u8; 32],
+        sequence,
+        signature: [0u8; 64],
+    }
+}
+
+/// Create a test witness summary
+fn create_test_summary() -> WitnessSummary {
+    let json = serde_json::json!({
+        "structural": {
+            "cut_value": 10.5,
+            "partition": "stable",
+            "critical_edges": 15,
+            "boundary": ["edge-1", "edge-2"]
+        },
+        "predictive": {
+            "set_size": 3,
+            "coverage": 0.95
+        },
+        "evidential": {
+            "e_value": 150.0,
+            "verdict": "accept"
+        }
+    });
+    serde_json::from_value(json).unwrap()
+}
+
+/// Create a test receipt
+fn create_test_receipt(sequence: u64, previous_hash: [u8; 32]) -> WitnessReceipt {
+    WitnessReceipt {
+        sequence,
+        token: create_test_token(sequence),
+        previous_hash,
+        witness_summary: create_test_summary(),
+        timestamp_proof: TimestampProof {
+            timestamp: 1704067200_000_000_000 + sequence * 1_000_000,
+            previous_receipt_hash: previous_hash,
+            merkle_root: [0u8; 32],
+        },
+    }
+}
+
+/// Create a realistic worker report
+fn create_worker_report(
+    tile_id: TileId,
+    epoch: u64,
+    node_count: usize,
+    boundary_edge_count: usize,
+) -> WorkerReport {
+    let mut rng = rand::thread_rng();
+    let mut report = WorkerReport::new(tile_id, epoch);
+
+    for i in 0..node_count {
+        report.add_node(NodeSummary {
+            id: format!("node-{}-{}", tile_id, i),
+            weight: rng.gen_range(0.1..10.0),
+            edge_count: rng.gen_range(5..50),
+            coherence: rng.gen_range(0.7..1.0),
+        });
+    }
+
+    for i in 0..boundary_edge_count {
+        report.add_boundary_edge(EdgeSummary {
+            source: format!("node-{}-{}", tile_id, i % node_count.max(1)),
+            target: format!(
+                "node-{}-{}",
+                (tile_id as usize + 1) % 256,
+                i % node_count.max(1)
+            ),
+            capacity: rng.gen_range(1.0..100.0),
+            is_boundary: true,
+        });
+    }
+
+    report.local_mincut = rng.gen_range(1.0..20.0);
+    report.confidence = rng.gen_range(0.8..1.0);
+    report.timestamp_ms = 1704067200_000 + tile_id as u64 * 100;
+
+    report
+}
+
+/// Create all 255 tile reports
+fn create_all_tile_reports(
+    epoch: u64,
+    nodes_per_tile: usize,
+    edges_per_tile: usize,
+) -> Vec<WorkerReport> {
+    (1..=255u8)
+        .map(|tile_id| create_worker_report(tile_id, epoch, nodes_per_tile, edges_per_tile))
+        .collect()
+}
+
+/// Create action context for benchmarking
+fn create_action_context(id: usize) -> ActionContext {
+    ActionContext {
+        action_id: format!("action-{}", id),
+        action_type: "config_change".to_string(),
+        target: ActionTarget {
+            device: Some("router-1".to_string()),
+            path: Some("/config/routing/policy".to_string()),
+            extra: {
+                let mut m = HashMap::new();
+                m.insert("priority".to_string(), serde_json::json!(100));
+                m
+            },
+        },
+        context: ActionMetadata {
+            agent_id: "agent-001".to_string(),
+            session_id: Some("session-12345".to_string()),
+            prior_actions: vec!["action-prev-1".to_string()],
+            urgency: "normal".to_string(),
+        },
+    }
+}
+
+/// Create realistic graph state
+fn create_realistic_graph(coherence_level: f64) -> ReducedGraph {
+    let mut graph = ReducedGraph::new();
+
+    for tile_id in 1..=255u8 {
+        let tile_coherence = (coherence_level + (tile_id as f64 * 0.001) % 0.1) as f32;
+        graph.update_coherence(tile_id, tile_coherence);
+    }
+
+    graph.set_global_cut(coherence_level * 15.0);
+    graph.set_evidence(coherence_level * 150.0);
+    graph.set_shift_pressure(0.1 * (1.0 - coherence_level));
+
+    graph
+}
+
+// ============================================================================
+// 1. Merge Reports Benchmark
+// ============================================================================
+
+/// Benchmark merging 255 tile reports (target: < 10ms)
+fn bench_merge_reports(c: &mut Criterion) {
+    let mut group = c.benchmark_group("merge_reports");
+    group.throughput(Throughput::Elements(255));
+
+    // Test different merge strategies
+    let strategies = [
+        ("simple_average", MergeStrategy::SimpleAverage),
+        ("weighted_average", MergeStrategy::WeightedAverage),
+        ("median", MergeStrategy::Median),
+        ("maximum", MergeStrategy::Maximum),
+        ("byzantine_ft", MergeStrategy::ByzantineFaultTolerant),
+    ];
+
+    // Minimal reports (baseline)
+    let minimal_reports = create_all_tile_reports(0, 1, 2);
+
+    for (name, strategy) in &strategies {
+        let merger = ReportMerger::new(*strategy);
+
+        group.bench_with_input(
+            BenchmarkId::new("255_tiles_minimal", name),
+            &minimal_reports,
+            |b, reports| b.iter(|| black_box(merger.merge(black_box(reports)))),
+        );
+    }
+
+    // Realistic reports (10 nodes, 5 boundary edges)
+    let realistic_reports = create_all_tile_reports(0, 10, 5);
+    let merger = ReportMerger::new(MergeStrategy::SimpleAverage);
+
+    group.bench_function("255_tiles_realistic", |b| {
+        b.iter(|| black_box(merger.merge(black_box(&realistic_reports))))
+    });
+
+    // Heavy reports (50 nodes, 20 edges)
+    let heavy_reports = create_all_tile_reports(0, 50, 20);
+
+    group.bench_function("255_tiles_heavy", |b| {
+        b.iter(|| black_box(merger.merge(black_box(&heavy_reports))))
+    });
+
+    group.finish();
+}
+
+// ============================================================================
+// 2. Full Gate Decision Benchmark
+// ============================================================================
+
+/// Benchmark full gate decision (target: p99 < 50ms)
+fn bench_decision(c: &mut Criterion) {
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let mut group = c.benchmark_group("gate_decision");
+    group.throughput(Throughput::Elements(1));
+
+    // Full TileZero decision
+    let thresholds = GateThresholds::default();
+    let tilezero = TileZero::new(thresholds.clone());
+    let ctx = create_action_context(0);
+
+    group.bench_function("tilezero_full_decision", |b| {
+        b.to_async(&rt)
+            .iter(|| async { black_box(tilezero.decide(black_box(&ctx)).await) });
+    });
+
+    // Three-filter decision only (no crypto)
+    let decision = ThreeFilterDecision::new(thresholds);
+
+    let graph_states = [
+        ("high_coherence", create_realistic_graph(0.95)),
+        ("medium_coherence", create_realistic_graph(0.7)),
+        ("low_coherence", create_realistic_graph(0.3)),
+    ];
+
+    for (name, graph) in &graph_states {
+        group.bench_with_input(BenchmarkId::new("three_filter", name), graph, |b, graph| {
+            b.iter(|| black_box(decision.evaluate(black_box(graph))))
+        });
+    }
+
+    // Batch decisions
+    for batch_size in [10, 50] {
+        let contexts: Vec<_> = (0..batch_size).map(create_action_context).collect();
+
+        group.bench_with_input(
+            BenchmarkId::new("batch_sequential", batch_size),
+            &contexts,
+            |b, contexts| {
+                b.to_async(&rt).iter(|| async {
+                    for ctx in contexts {
+                        black_box(tilezero.decide(ctx).await);
+                    }
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+// ============================================================================
+// 3. Receipt Hash Benchmark
+// ============================================================================
+
+/// Benchmark receipt hash computation (target: < 10us)
+fn bench_receipt_hash(c: &mut Criterion) {
+    let mut group = c.benchmark_group("receipt_hash");
+    group.throughput(Throughput::Elements(1));
+
+    let receipt = create_test_receipt(0, [0u8; 32]);
+
+    // Single hash
+    group.bench_function("hash_single", |b| b.iter(|| black_box(receipt.hash())));
+
+    // Hash with varying boundary sizes
+    for boundary_size in [0, 10, 50, 100] {
+        let mut receipt = create_test_receipt(0, [0u8; 32]);
+        receipt.witness_summary.structural.boundary = (0..boundary_size)
+            .map(|i| format!("boundary-edge-{}", i))
+            .collect();
+
+        group.bench_with_input(
+            BenchmarkId::new("boundary_size", boundary_size),
+            &receipt,
+            |b, receipt| b.iter(|| black_box(receipt.hash())),
+        );
+    }
+
+    // Witness summary hash
+    let summary = create_test_summary();
+    group.bench_function("witness_summary_hash", |b| {
+        b.iter(|| black_box(summary.hash()))
+    });
+
+    group.finish();
+}
+
+// ============================================================================
+// 4. Receipt Chain Verification Benchmark
+// ============================================================================
+
+/// Benchmark receipt chain verification (target: < 100ms for 1000 receipts)
+fn bench_receipt_chain_verify(c: &mut Criterion) {
+    let mut group = c.benchmark_group("receipt_chain_verify");
+
+    for chain_length in [100, 500, 1000, 2000] {
+        group.throughput(Throughput::Elements(chain_length as u64));
+
+        // Build the chain
+        let mut log = ReceiptLog::new();
+        for i in 0..chain_length {
+            let receipt = create_test_receipt(i as u64, log.last_hash());
+            log.append(receipt);
+        }
+
+        group.bench_with_input(
+            BenchmarkId::new("verify_chain", chain_length),
+            &log,
+            |b, log| b.iter(|| black_box(log.verify_chain_to((chain_length - 1) as u64))),
+        );
+    }
+
+    // Chain building (append) benchmark
+    group.bench_function("build_chain_1000", |b| {
+        b.iter(|| {
+            let mut log = ReceiptLog::new();
+            for i in 0..1000 {
+                let receipt = create_test_receipt(i, log.last_hash());
+                log.append(receipt);
+            }
+            black_box(log)
+        })
+    });
+
+    group.finish();
+}
+
+// ============================================================================
+// 5. Permit Sign Benchmark
+// ============================================================================
+
+/// Benchmark permit token signing (target: < 5ms)
+fn bench_permit_sign(c: &mut Criterion) {
+    let mut group = c.benchmark_group("permit_sign");
+    group.throughput(Throughput::Elements(1));
+
+    let state = PermitState::new();
+
+    // Single sign
+    group.bench_function("sign_single", |b| {
+        b.iter(|| {
+            let token = create_test_token(black_box(0));
+            black_box(state.sign_token(token))
+        })
+    });
+
+    // Sign with varying action_id lengths
+    for action_len in [10, 50, 100, 500] {
+        let mut token = create_test_token(0);
+        token.action_id = "x".repeat(action_len);
+
+        group.bench_with_input(
+            BenchmarkId::new("action_len", action_len),
+            &token,
+            |b, token| b.iter(|| black_box(state.sign_token(token.clone()))),
+        );
+    }
+
+    // Batch signing
+    for batch_size in [10, 50, 100] {
+        let tokens: Vec<_> = (0..batch_size)
+            .map(|i| create_test_token(i as u64))
+            .collect();
+
+        group.bench_with_input(
+            BenchmarkId::new("batch_sign", batch_size),
+            &tokens,
+            |b, tokens| {
+                b.iter(|| {
+                    let signed: Vec<_> = tokens
+                        .iter()
+                        .cloned()
+                        .map(|t| state.sign_token(t))
+                        .collect();
+                    black_box(signed)
+                })
+            },
+        );
+    }
+
+    // Signable content generation
+    let token = create_test_token(0);
+    group.bench_function("signable_content", |b| {
+        b.iter(|| black_box(token.signable_content()))
+    });
+
+    group.finish();
+}
+
+// ============================================================================
+// 6. Permit Verify Benchmark
+// ============================================================================
+
+/// Benchmark permit token verification (target: < 1ms)
+fn bench_permit_verify(c: &mut Criterion) {
+    let mut group = c.benchmark_group("permit_verify");
+    group.throughput(Throughput::Elements(1));
+
+    let state = PermitState::new();
+    let verifier = state.verifier();
+    let signed_token = state.sign_token(create_test_token(0));
+
+    // Single verify
+    group.bench_function("verify_single", |b| {
+        b.iter(|| black_box(verifier.verify(black_box(&signed_token))))
+    });
+
+    // Token encoding/decoding (often paired with verification)
+    let encoded = signed_token.encode_base64();
+
+    group.bench_function("encode_base64", |b| {
+        b.iter(|| black_box(signed_token.encode_base64()))
+    });
+
+    group.bench_function("decode_base64", |b| {
+        b.iter(|| black_box(PermitToken::decode_base64(black_box(&encoded))))
+    });
+
+    group.bench_function("roundtrip_encode_decode", |b| {
+        b.iter(|| {
+            let encoded = signed_token.encode_base64();
+            black_box(PermitToken::decode_base64(&encoded))
+        })
+    });
+
+    // Batch verification
+    let signed_tokens: Vec<_> = (0..100)
+        .map(|i| state.sign_token(create_test_token(i)))
+        .collect();
+
+    group.bench_function("verify_batch_100", |b| {
+        b.iter(|| {
+            for token in &signed_tokens {
+                black_box(verifier.verify(token));
+            }
+        })
+    });
+
+    group.finish();
+}
+
+// ============================================================================
+// Additional Benchmarks
+// ============================================================================
+
+/// Benchmark E-value computation
+fn bench_evalue_computation(c: &mut Criterion) {
+    let mut group = c.benchmark_group("evalue_computation");
+    group.throughput(Throughput::Elements(1));
+
+    // Scalar update
+    for capacity in [10, 100, 1000] {
+        let mut filter = EvidenceFilter::new(capacity);
+        for i in 0..capacity {
+            filter.update(1.0 + (i as f64 * 0.001));
+        }
+
+        group.bench_with_input(
+            BenchmarkId::new("scalar_update", capacity),
+            &capacity,
+            |b, _| {
+                b.iter(|| {
+                    filter.update(black_box(1.5));
+                    black_box(filter.current())
+                })
+            },
+        );
+    }
+
+    // SIMD-friendly aggregation patterns
+    let tile_count = 255;
+    let e_values: Vec<f64> = (0..tile_count).map(|i| 1.0 + (i as f64 * 0.01)).collect();
+
+    group.bench_function("aggregate_255_scalar", |b| {
+        b.iter(|| {
+            let product: f64 = e_values.iter().product();
+            black_box(product)
+        })
+    });
+
+    // Chunked processing (SIMD-friendly)
+    group.bench_function("aggregate_255_chunked_4", |b| {
+        b.iter(|| {
+            let mut accumulator = 1.0f64;
+            for chunk in e_values.chunks(4) {
+                let chunk_product: f64 = chunk.iter().product();
+                accumulator *= chunk_product;
+            }
+            black_box(accumulator)
+        })
+    });
+
+    // Log-sum pattern (numerically stable)
+    group.bench_function("aggregate_255_log_sum", |b| {
+        b.iter(|| {
+            let log_sum: f64 = e_values.iter().map(|x| x.ln()).sum();
+            black_box(log_sum.exp())
+        })
+    });
+
+    // Parallel reduction
+    group.bench_function("aggregate_255_parallel_8", |b| {
+        b.iter(|| {
+            let mut lanes = [1.0f64; 8];
+            for (i, &val) in e_values.iter().enumerate() {
+                lanes[i % 8] *= val;
+            }
+            let result: f64 = lanes.iter().product();
+            black_box(result)
+        })
+    });
+
+    group.finish();
+}
+
+/// Benchmark graph operations
+fn bench_graph_operations(c: &mut Criterion) {
+    let mut group = c.benchmark_group("graph_operations");
+
+    // Coherence updates
+    for tile_count in [64, 128, 255] {
+        group.throughput(Throughput::Elements(tile_count as u64));
+
+        group.bench_with_input(
+            BenchmarkId::new("coherence_updates", tile_count),
+            &tile_count,
+            |b, &count| {
+                b.iter(|| {
+                    let mut graph = ReducedGraph::new();
+                    for tile_id in 1..=count as u8 {
+                        graph.update_coherence(tile_id, black_box(0.9));
+                    }
+                    black_box(graph)
+                })
+            },
+        );
+    }
+
+    // Witness summary generation
+    let graph = create_realistic_graph(0.9);
+    group.bench_function("witness_summary_generate", |b| {
+        b.iter(|| black_box(graph.witness_summary()))
+    });
+
+    group.finish();
+}
+
+/// Benchmark log operations
+fn bench_receipt_log_operations(c: &mut Criterion) {
+    let mut group = c.benchmark_group("receipt_log_ops");
+    group.throughput(Throughput::Elements(1));
+
+    // Append to various log sizes
+    for initial_size in [10, 100, 500] {
+        group.bench_with_input(
+            BenchmarkId::new("append_to_n", initial_size),
+            &initial_size,
+            |b, &size| {
+                b.iter_batched(
+                    || {
+                        let mut log = ReceiptLog::new();
+                        for i in 0..size {
+                            let receipt = create_test_receipt(i as u64, log.last_hash());
+                            log.append(receipt);
+                        }
+                        log
+                    },
+                    |mut log| {
+                        let receipt = create_test_receipt(log.len() as u64, log.last_hash());
+                        log.append(receipt);
+                        black_box(log)
+                    },
+                    criterion::BatchSize::SmallInput,
+                )
+            },
+        );
+    }
+
+    // Get receipt
+    let mut log = ReceiptLog::new();
+    for i in 0..100 {
+        let receipt = create_test_receipt(i, log.last_hash());
+        log.append(receipt);
+    }
+
+    group.bench_function("get_receipt", |b| {
+        b.iter(|| black_box(log.get(black_box(50))))
+    });
+
+    group.finish();
+}
+
+// ============================================================================
+// Criterion Groups
+// ============================================================================
+
+criterion_group!(merge_benches, bench_merge_reports,);
+
+criterion_group!(decision_benches, bench_decision,);
+
+criterion_group!(
+    crypto_benches,
+    bench_receipt_hash,
+    bench_receipt_chain_verify,
+    bench_permit_sign,
+    bench_permit_verify,
+);
+
+criterion_group!(
+    additional_benches,
+    bench_evalue_computation,
+    bench_graph_operations,
+    bench_receipt_log_operations,
+);
+
+criterion_main!(
+    merge_benches,
+    decision_benches,
+    crypto_benches,
+    additional_benches
+);