@feltdb/core 0.4.12 → 0.4.14

package/dist/create/server-source/crates/feltdb/src/causal_dependency_barrier_phase_7_1.rs

@@ -0,0 +1,194 @@
+/// Phase 7.1: Release Economics Testing
+///
+/// Direct measurement of frontier advancement costs without criterion harness
+/// This provides rapid feedback on release behavior
+
+#[cfg(test)]
+mod phase_7_1_release_economics {
+    use crate::causal_dependency_barrier::CausalDependencyBarrier;
+    use crate::convergence::VectorClock;
+    use std::time::Instant;
+
+    #[test]
+    fn phase_7_1_release_single_scan_small() {
+        // Test 1: Single release scan with small pending buffer
+        println!("\n=== Phase 7.1 Test 1: Single Release Scan (Small) ===");
+
+        for pending_size in [0, 10, 100].iter() {
+            let mut barrier = CausalDependencyBarrier::new();
+
+            // Fill with blocked operations
+            for i in 0..*pending_size {
+                let mut required = VectorClock::new();
+                required.clocks.insert("node_a".to_string(), (1000 + i) as u64);
+                let _ = barrier.receive_operation(format!("pending_{}", i), required);
+            }
+
+            // Measure one frontier advance
+            let start = Instant::now();
+            let mut frontier = VectorClock::new();
+            frontier.clocks.insert("node_a".to_string(), 1);
+            barrier.advance_frontier(&frontier);
+            let elapsed = start.elapsed();
+
+            let metrics = barrier.metrics();
+            println!(
+                "Pending={:5} | Cost={:?} | Entries examined={} | Released={}",
+                pending_size, elapsed, metrics.pending_entries_examined, metrics.operations_released
+            );
+        }
+    }
+
+    #[test]
+    fn phase_7_1_release_selectivity_test() {
+        // Test 2: Does readiness % affect cost?
+        println!("\n=== Phase 7.1 Test 2: Release Selectivity ===");
+
+        for ready_percent in [0, 10, 50, 100].iter() {
+            let mut barrier = CausalDependencyBarrier::new();
+            let pending_size = 100;
+
+            let ready_count = (pending_size * ready_percent) / 100;
+            let blocked_count = pending_size - ready_count;
+
+            // Add ready operations
+            for i in 0..ready_count {
+                let mut required = VectorClock::new();
+                required.clocks.insert("node_a".to_string(), 100);
+                let _ = barrier.receive_operation(format!("ready_{}", i), required);
+            }
+
+            // Add blocked operations
+            for i in 0..blocked_count {
+                let mut required = VectorClock::new();
+                required.clocks.insert("node_a".to_string(), 5000);
+                let _ = barrier.receive_operation(format!("blocked_{}", i), required);
+            }
+
+            // Measure frontier advance to release ready operations
+            let start = Instant::now();
+            let mut frontier = VectorClock::new();
+            frontier.clocks.insert("node_a".to_string(), 2000);
+            barrier.advance_frontier(&frontier);
+            let elapsed = start.elapsed();
+
+            let metrics = barrier.metrics();
+            let released_pct = if metrics.pending_entries_examined > 0 {
+                (metrics.operations_released as f64 / metrics.pending_entries_examined as f64) * 100.0
+            } else {
+                0.0
+            };
+
+            println!(
+                "Ready%={:3} | Cost={:?} | Examined={:3} | Released={:3} | Ratio={:.1}%",
+                ready_percent, elapsed, metrics.pending_entries_examined, metrics.operations_released, released_pct
+            );
+        }
+    }
+
+    #[test]
+    fn phase_7_1_release_pathological_simplified() {
+        // Test 3: Simplified pathological test
+        // Creates sequential dependencies but only advances frontier a few times
+        println!("\n=== Phase 7.1 Test 3: Pathological (Simplified) ===");
+
+        let pending_size = 100;
+        let mut barrier = CausalDependencyBarrier::new();
+
+        // Create sequential dependencies
+        for i in 0..pending_size {
+            let mut required = VectorClock::new();
+            required.clocks.insert("node_a".to_string(), (i + 1) as u64);
+            let _ = barrier.receive_operation(format!("seq_{}", i), required);
+        }
+
+        println!("Initial pending: {}", barrier.get_pending_operations().len());
+
+        // Advance frontier multiple times
+        let start = Instant::now();
+        let mut total_entries_examined = 0;
+        let mut total_released = 0;
+
+        for step in 1..=10 {
+            barrier.clear_metrics();
+            let mut frontier = VectorClock::new();
+            frontier.clocks.insert("node_a".to_string(), step as u64);
+            barrier.advance_frontier(&frontier);
+
+            let metrics = barrier.metrics();
+            total_entries_examined += metrics.pending_entries_examined;
+            total_released += metrics.operations_released;
+
+            println!(
+                "Step {:2}: frontier A:{} | examined={:3} | released={} | remaining={:3}",
+                step,
+                step,
+                metrics.pending_entries_examined,
+                metrics.operations_released,
+                barrier.get_pending_operations().len()
+            );
+        }
+
+        let elapsed = start.elapsed();
+        println!(
+            "\nTotal across 10 steps: elapsed={:?} | total_examined={} | total_released={}",
+            elapsed, total_entries_examined, total_released
+        );
+
+        // Analysis
+        if total_entries_examined > 500 {
+            println!("⚠️  WARNING: Examined {} entries for 100 pending (10 advances)", total_entries_examined);
+            println!("   Expected if O(m): ~100-200");
+            println!("   This suggests possible rescanning behavior");
+        } else {
+            println!("✅ GOOD: Linear scaling confirmed");
+            println!("   Examined {} entries total", total_entries_examined);
+        }
+    }
+
+    #[test]
+    fn phase_7_1_release_mixed_advances() {
+        // Test 4: Realistic mixed advances
+        println!("\n=== Phase 7.1 Test 4: Mixed Frontier Advances ===");
+
+        for pending_size in [50, 100].iter() {
+            println!("\nPending size: {}", pending_size);
+            let mut barrier = CausalDependencyBarrier::new();
+
+            // Create mixed dependencies
+            for i in 0..*pending_size {
+                let mut required = VectorClock::new();
+                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);
+            }
+
+            let start = Instant::now();
+            let mut total_examined = 0;
+            let mut total_released = 0;
+
+            // Series of frontier advances
+            for level in (100..=500).step_by(100) {
+                barrier.clear_metrics();
+                let mut frontier = VectorClock::new();
+                frontier.clocks.insert("node_a".to_string(), level as u64);
+                barrier.advance_frontier(&frontier);
+
+                let metrics = barrier.metrics();
+                total_examined += metrics.pending_entries_examined;
+                total_released += metrics.operations_released;
+
+                println!(
+                    "  Advance to A:{} | examined={:2} | released={:2}",
+                    level, metrics.pending_entries_examined, metrics.operations_released
+                );
+            }
+
+            let elapsed = start.elapsed();
+            println!(
+                "Total: elapsed={:?} | examined={} | released={}",
+                elapsed, total_examined, total_released
+            );
+        }
+    }
+}

package/dist/create/server-source/crates/feltdb/src/concurrency_fuzzing.rs

@@ -0,0 +1,427 @@
+/// Concurrency Fuzzing Framework
+///
+/// Generates randomized concurrent transactions with variable:
+/// - Operation count per transaction
+/// - Read/write set sizes
+/// - Conflicts between transactions
+/// - Execution interleaving
+///
+/// Verifies final state matches deterministic reference model.
+
+use crate::convergence::VectorClock;
+use crate::state_hash::StateHash;
+use crate::transactions::*;
+use rand::Rng;
+use std::collections::{HashMap, HashSet};
+
+/// Fuzzing configuration
+#[derive(Clone, Debug)]
+pub struct FuzzingConfig {
+    pub num_transactions: usize,
+    pub max_operations_per_transaction: usize,
+    pub max_records: usize,
+    pub conflict_probability: f32, // 0.0 to 1.0
+    pub seed: u64,
+}
+
+impl Default for FuzzingConfig {
+    fn default() -> Self {
+        Self {
+            num_transactions: 100,
+            max_operations_per_transaction: 5,
+            max_records: 20,
+            conflict_probability: 0.3,
+            seed: 42,
+        }
+    }
+}
+
+/// Generated transaction for fuzzing
+#[derive(Clone, Debug)]
+pub struct FuzzedTransaction {
+    pub transaction_id: String,
+    pub operations: Vec<Operation>,
+    pub write_set: HashSet<String>, // record IDs written
+    pub read_set: HashSet<String>,  // record IDs read
+}
+
+/// Fuzzing statistics
+#[derive(Clone, Debug)]
+pub struct FuzzingStats {
+    pub total_transactions: usize,
+    pub total_operations: usize,
+    pub total_conflicts: usize,
+    pub concurrent_transactions: usize,
+    pub sequential_transactions: usize,
+}
+
+/// Concurrency fuzzer
+pub struct ConcurrencyFuzzer {
+    config: FuzzingConfig,
+    rng: rand::rngs::StdRng,
+}
+
+impl ConcurrencyFuzzer {
+    pub fn new(config: FuzzingConfig) -> Self {
+        use rand::SeedableRng;
+        let rng = rand::rngs::StdRng::seed_from_u64(config.seed);
+
+        Self { config, rng }
+    }
+
+    /// Generate random transaction
+    fn generate_transaction(&mut self, id: usize) -> FuzzedTransaction {
+        let num_ops = self.rng.gen_range(1..=self.config.max_operations_per_transaction);
+        let mut write_set = HashSet::new();
+        let mut read_set = HashSet::new();
+        let mut operations = Vec::new();
+
+        let mut vc = VectorClock::new();
+        vc.increment("fuzzer");
+
+        let base_version = StateVersion::new(vc.clone(), format!("genesis_{}", id));
+
+        for op_idx in 0..num_ops {
+            let record_id = format!(
+                "rec_{}",
+                self.rng.gen_range(0..self.config.max_records)
+            );
+            let value = self.rng.gen_range(0..1000);
+
+            let op_id = OperationId::new("fuzzer".to_string(), ((id * 100) + op_idx) as u64);
+
+            let mut op = Operation::new(
+                op_id,
+                base_version.clone(),
+                format!("FuzzOp_{}", op_idx),
+                OperationCommand {
+                    op_type: "UpdateField".to_string(),
+                    collection: "fuzzing".to_string(),
+                    record_id: record_id.clone(),
+                    fields: {
+                        let mut m = HashMap::new();
+                        m.insert("value".to_string(), serde_json::json!(value));
+                        m
+                    },
+                },
+                "fuzzer".to_string(),
+            );
+
+            // Randomly add read dependencies
+            if self.rng.gen_bool(0.3) {
+                let read_record = format!(
+                    "rec_{}",
+                    self.rng.gen_range(0..self.config.max_records)
+                );
+                op = op.with_read_set(vec![StateDependency::new(
+                    "fuzzing".to_string(),
+                    read_record.clone(),
+                    Some("value".to_string()),
+                    base_version.clone(),
+                )]);
+                read_set.insert(read_record);
+            }
+
+            op = op.with_write_set(vec![StateDependency::new(
+                "fuzzing".to_string(),
+                record_id.clone(),
+                Some("value".to_string()),
+                base_version.clone(),
+            )]);
+
+            write_set.insert(record_id);
+            operations.push(op);
+        }
+
+        FuzzedTransaction {
+            transaction_id: format!("fuzz_txn_{}", id),
+            operations,
+            write_set,
+            read_set,
+        }
+    }
+
+    /// Generate fuzzed transaction workload
+    pub fn generate_workload(&mut self) -> Vec<FuzzedTransaction> {
+        (0..self.config.num_transactions)
+            .map(|i| self.generate_transaction(i))
+            .collect()
+    }
+
+    /// Detect potential conflicts between two transactions
+    pub fn detect_conflict(tx1: &FuzzedTransaction, tx2: &FuzzedTransaction) -> bool {
+        // Write-Write conflict
+        if !tx1.write_set.is_disjoint(&tx2.write_set) {
+            return true;
+        }
+
+        // Read-Write conflict
+        if !tx1.read_set.is_disjoint(&tx2.write_set) {
+            return true;
+        }
+        if !tx1.write_set.is_disjoint(&tx2.read_set) {
+            return true;
+        }
+
+        false
+    }
+
+    /// Compute conflict graph for workload
+    pub fn compute_conflict_graph(workload: &[FuzzedTransaction]) -> HashMap<usize, Vec<usize>> {
+        let mut graph = HashMap::new();
+
+        for (i, tx1) in workload.iter().enumerate() {
+            let mut conflicts = Vec::new();
+            for (j, tx2) in workload.iter().enumerate() {
+                if i != j && Self::detect_conflict(tx1, tx2) {
+                    conflicts.push(j);
+                }
+            }
+            graph.insert(i, conflicts);
+        }
+
+        graph
+    }
+
+    /// Compute statistics
+    pub fn compute_stats(workload: &[FuzzedTransaction]) -> FuzzingStats {
+        let total_transactions = workload.len();
+        let total_operations = workload.iter().map(|t| t.operations.len()).sum();
+        let conflict_graph = Self::compute_conflict_graph(workload);
+        let total_conflicts: usize = conflict_graph.iter().map(|(_, v)| v.len()).sum::<usize>() / 2; // Each edge counted twice
+
+        let concurrent_transactions = workload
+            .iter()
+            .filter(|t| t.operations.len() > 1)
+            .count();
+        let sequential_transactions = total_transactions - concurrent_transactions;
+
+        FuzzingStats {
+            total_transactions,
+            total_operations,
+            total_conflicts,
+            concurrent_transactions,
+            sequential_transactions,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fuzzer_creation() {
+        let config = FuzzingConfig::default();
+        let fuzzer = ConcurrencyFuzzer::new(config.clone());
+
+        assert_eq!(fuzzer.config.num_transactions, 100);
+    }
+
+    #[test]
+    fn test_generate_single_transaction() {
+        let config = FuzzingConfig {
+            num_transactions: 1,
+            max_operations_per_transaction: 3,
+            max_records: 10,
+            conflict_probability: 0.5,
+            seed: 123,
+        };
+
+        let mut fuzzer = ConcurrencyFuzzer::new(config);
+        let tx = fuzzer.generate_transaction(0);
+
+        assert!(!tx.operations.is_empty());
+        assert!(tx.operations.len() <= 3);
+    }
+
+    #[test]
+    fn test_generate_workload() {
+        let config = FuzzingConfig {
+            num_transactions: 10,
+            max_operations_per_transaction: 2,
+            max_records: 5,
+            conflict_probability: 0.3,
+            seed: 456,
+        };
+
+        let mut fuzzer = ConcurrencyFuzzer::new(config);
+        let workload = fuzzer.generate_workload();
+
+        assert_eq!(workload.len(), 10);
+        for tx in &workload {
+            assert!(!tx.operations.is_empty());
+        }
+    }
+
+    #[test]
+    fn test_conflict_detection_no_conflict() {
+        let tx1 = FuzzedTransaction {
+            transaction_id: "tx1".to_string(),
+            operations: Vec::new(),
+            write_set: ["rec1".to_string()].iter().cloned().collect(),
+            read_set: HashSet::new(),
+        };
+
+        let tx2 = FuzzedTransaction {
+            transaction_id: "tx2".to_string(),
+            operations: Vec::new(),
+            write_set: ["rec2".to_string()].iter().cloned().collect(),
+            read_set: HashSet::new(),
+        };
+
+        assert!(!ConcurrencyFuzzer::detect_conflict(&tx1, &tx2));
+    }
+
+    #[test]
+    fn test_conflict_detection_write_write() {
+        let tx1 = FuzzedTransaction {
+            transaction_id: "tx1".to_string(),
+            operations: Vec::new(),
+            write_set: ["rec1".to_string()].iter().cloned().collect(),
+            read_set: HashSet::new(),
+        };
+
+        let tx2 = FuzzedTransaction {
+            transaction_id: "tx2".to_string(),
+            operations: Vec::new(),
+            write_set: ["rec1".to_string()].iter().cloned().collect(),
+            read_set: HashSet::new(),
+        };
+
+        assert!(ConcurrencyFuzzer::detect_conflict(&tx1, &tx2));
+    }
+
+    #[test]
+    fn test_conflict_detection_read_write() {
+        let tx1 = FuzzedTransaction {
+            transaction_id: "tx1".to_string(),
+            operations: Vec::new(),
+            write_set: HashSet::new(),
+            read_set: ["rec1".to_string()].iter().cloned().collect(),
+        };
+
+        let tx2 = FuzzedTransaction {
+            transaction_id: "tx2".to_string(),
+            operations: Vec::new(),
+            write_set: ["rec1".to_string()].iter().cloned().collect(),
+            read_set: HashSet::new(),
+        };
+
+        assert!(ConcurrencyFuzzer::detect_conflict(&tx1, &tx2));
+    }
+
+    #[test]
+    fn test_compute_conflict_graph() {
+        let tx1 = FuzzedTransaction {
+            transaction_id: "tx1".to_string(),
+            operations: Vec::new(),
+            write_set: ["rec1".to_string()].iter().cloned().collect(),
+            read_set: HashSet::new(),
+        };
+
+        let tx2 = FuzzedTransaction {
+            transaction_id: "tx2".to_string(),
+            operations: Vec::new(),
+            write_set: ["rec1".to_string()].iter().cloned().collect(),
+            read_set: HashSet::new(),
+        };
+
+        let tx3 = FuzzedTransaction {
+            transaction_id: "tx3".to_string(),
+            operations: Vec::new(),
+            write_set: ["rec2".to_string()].iter().cloned().collect(),
+            read_set: HashSet::new(),
+        };
+
+        let workload = vec![tx1, tx2, tx3];
+        let graph = ConcurrencyFuzzer::compute_conflict_graph(&workload);
+
+        assert_eq!(graph.len(), 3);
+        assert_eq!(graph[&0].len(), 1); // tx1 conflicts with tx2
+        assert_eq!(graph[&1].len(), 1); // tx2 conflicts with tx1
+        assert_eq!(graph[&2].len(), 0); // tx3 has no conflicts
+    }
+
+    #[test]
+    fn test_compute_stats() {
+        let config = FuzzingConfig {
+            num_transactions: 10,
+            max_operations_per_transaction: 2,
+            max_records: 5,
+            conflict_probability: 0.3,
+            seed: 789,
+        };
+
+        let mut fuzzer = ConcurrencyFuzzer::new(config);
+        let workload = fuzzer.generate_workload();
+        let stats = ConcurrencyFuzzer::compute_stats(&workload);
+
+        assert_eq!(stats.total_transactions, 10);
+        assert!(stats.total_operations >= 10);
+        assert!(stats.total_operations <= 20);
+    }
+
+    #[test]
+    fn test_workload_determinism_same_seed() {
+        let config1 = FuzzingConfig {
+            num_transactions: 5,
+            max_operations_per_transaction: 3,
+            max_records: 10,
+            conflict_probability: 0.3,
+            seed: 999,
+        };
+
+        let config2 = FuzzingConfig {
+            num_transactions: 5,
+            max_operations_per_transaction: 3,
+            max_records: 10,
+            conflict_probability: 0.3,
+            seed: 999,
+        };
+
+        let mut fuzzer1 = ConcurrencyFuzzer::new(config1);
+        let mut fuzzer2 = ConcurrencyFuzzer::new(config2);
+
+        let workload1 = fuzzer1.generate_workload();
+        let workload2 = fuzzer2.generate_workload();
+
+        assert_eq!(workload1.len(), workload2.len());
+        for (tx1, tx2) in workload1.iter().zip(workload2.iter()) {
+            assert_eq!(tx1.operations.len(), tx2.operations.len());
+        }
+    }
+
+    #[test]
+    fn test_workload_variation_different_seed() {
+        let config1 = FuzzingConfig {
+            num_transactions: 10,
+            max_operations_per_transaction: 3,
+            max_records: 10,
+            conflict_probability: 0.3,
+            seed: 111,
+        };
+
+        let config2 = FuzzingConfig {
+            num_transactions: 10,
+            max_operations_per_transaction: 3,
+            max_records: 10,
+            conflict_probability: 0.3,
+            seed: 222,
+        };
+
+        let mut fuzzer1 = ConcurrencyFuzzer::new(config1);
+        let mut fuzzer2 = ConcurrencyFuzzer::new(config2);
+
+        let workload1 = fuzzer1.generate_workload();
+        let workload2 = fuzzer2.generate_workload();
+
+        let diff_count = workload1
+            .iter()
+            .zip(workload2.iter())
+            .filter(|(tx1, tx2)| tx1.write_set != tx2.write_set)
+            .count();
+
+        assert!(diff_count > 0, "Different seeds should produce different workloads");
+    }
+}