@feltdb/core 0.13.0 → 0.16.0

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

@@ -1,212 +0,0 @@
-/// 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

@@ -1,422 +0,0 @@
-/// 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"
-        );
-    }
-}