siftdb_core/

bench.rs

use crate::{SiftDB, ingest::{Ingester, IngestOptions}};
use std::time::{Duration, Instant, SystemTime};
use std::path::Path;
use std::fs;
use anyhow::Result;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct BenchmarkResults {
    pub name: String,
    pub duration: Duration, 
    pub files_processed: u64,
    pub bytes_processed: u64,
    pub queries_per_second: Option<f64>,
    pub throughput_mbps: Option<f64>,
}

#[derive(Serialize, Deserialize)]
pub struct BenchmarkSuite {
    pub version: String,
    pub timestamp: String,
    pub git_commit: Option<String>,
    pub test_environment: TestEnvironment,
    pub benchmarks: Vec<BenchmarkResults>,
}

#[derive(Serialize, Deserialize)]
pub struct TestEnvironment {
    pub os: String,
    pub cpu: String,
    pub memory: String,
}

impl BenchmarkResults {
    pub fn print(&self) {
        println!("=== {} ===", self.name);
        println!("Duration: {:.2}s", self.duration.as_secs_f64());
        if self.files_processed > 0 {
            println!("Files processed: {}", self.files_processed);
            println!("Files/sec: {:.1}", self.files_processed as f64 / self.duration.as_secs_f64());
        }
        if self.bytes_processed > 0 {
            let mb = self.bytes_processed as f64 / (1024.0 * 1024.0);
            println!("Data processed: {:.2} MB", mb);
            if let Some(throughput) = self.throughput_mbps {
                println!("Throughput: {:.2} MB/s", throughput);
            }
        }
        if let Some(qps) = self.queries_per_second {
            println!("Queries/sec: {:.1}", qps);
        }
        println!();
    }
}

pub struct SiftDBBenchmark {
    collection_path: std::path::PathBuf,
    source_path: std::path::PathBuf,
}

impl SiftDBBenchmark {
    pub fn new<P1: AsRef<Path>, P2: AsRef<Path>>(collection_path: P1, source_path: P2) -> Self {
        Self {
            collection_path: collection_path.as_ref().to_path_buf(),
            source_path: source_path.as_ref().to_path_buf(),
        }
    }

    pub fn run_all(&mut self) -> Vec<BenchmarkResults> {
        println!("🚀 SiftDB Performance Benchmark");
        println!("================================");
        println!();
        
        let mut results = Vec::new();
        
        // Initialize collection
        results.push(self.bench_init());
        
        // Import benchmark
        results.push(self.bench_import());
        
        // Search benchmarks
        results.extend(self.bench_searches());
        
        self.print_summary(&results);
        
        // Save results to file
        if let Err(e) = self.save_results(&results) {
            eprintln!("Warning: Failed to save benchmark results: {}", e);
        }
        
        results
    }

    fn bench_init(&self) -> BenchmarkResults {
        let start = Instant::now();
        
        SiftDB::init(&self.collection_path).expect("Failed to initialize collection");
        
        let duration = start.elapsed();
        
        BenchmarkResults {
            name: "Collection Initialization".to_string(),
            duration,
            files_processed: 0,
            bytes_processed: 0,
            queries_per_second: None,
            throughput_mbps: None,
        }
    }

    fn bench_import(&mut self) -> BenchmarkResults {
        println!("📁 Starting import benchmark...");
        
        let start = Instant::now();
        
        let _db = SiftDB::open(&self.collection_path).expect("Failed to open collection");
        
        let mut options = IngestOptions::default();
        options.include_patterns = vec!["**/*.rs".to_string(), "**/*.md".to_string(), "**/*.toml".to_string(), "**/*.json".to_string()];
        
        let mut ingester = Ingester::new(self.collection_path.clone(), options);
        
        // Count source files and bytes before import
        let (source_files, source_bytes) = self.count_source_files();
        println!("  Source files found: {}", source_files);  
        println!("  Source data: {:.2} MB", source_bytes as f64 / (1024.0 * 1024.0));
        
        let stats = ingester.ingest_from_fs(&self.source_path).expect("Failed to ingest");
        
        let duration = start.elapsed();
        
        // Calculate storage efficiency
        let storage_bytes = self.calculate_total_bytes();
        let compression_ratio = if source_bytes > 0 {
            storage_bytes as f64 / source_bytes as f64
        } else {
            1.0
        };
        
        println!("  ✅ Import completed in {:.2}s", duration.as_secs_f64());
        println!("  📊 Files ingested: {} ({} skipped, {} errors)", 
                 stats.ingested, stats.skipped, stats.errors);
        println!("  💾 Storage size: {:.2} MB (ratio: {:.2}x)", 
                 storage_bytes as f64 / (1024.0 * 1024.0), compression_ratio);
        
        BenchmarkResults {
            name: "File Import".to_string(),
            duration,
            files_processed: stats.ingested,
            bytes_processed: source_bytes,
            queries_per_second: None,
            throughput_mbps: Some(source_bytes as f64 / (1024.0 * 1024.0) / duration.as_secs_f64()),
        }
    }

    fn bench_searches(&self) -> Vec<BenchmarkResults> {
        let mut results = Vec::new();
        
        let db = SiftDB::open(&self.collection_path).expect("Failed to open collection");
        let snapshot = db.snapshot().expect("Failed to create snapshot");
        
        // Common search patterns
        let queries = vec![
            ("fn", "Function definitions"),
            ("println", "Print statements"),
            ("use", "Import statements"),
            ("struct", "Struct definitions"),
            ("impl", "Implementation blocks"),
            ("pub", "Public items"),
            ("let", "Variable declarations"),
            ("match", "Pattern matching"),
            ("async", "Async code"),
            ("Result", "Result types"),
        ];

        for (query, description) in queries {
            results.push(self.bench_single_search(&snapshot, query, description));
        }

        results
    }

    fn bench_single_search(&self, snapshot: &crate::Snapshot, query: &str, description: &str) -> BenchmarkResults {
        let iterations = 10;
        let mut total_duration = Duration::new(0, 0);
        let mut total_hits = 0;

        // Warm up
        snapshot.find(query, None, Some(1000)).ok();

        // Run benchmark iterations
        for _ in 0..iterations {
            let start = Instant::now();
            if let Ok(hits) = snapshot.find(query, None, Some(1000)) {
                total_hits = hits.len();
            }
            total_duration += start.elapsed();
        }

        let avg_duration = total_duration / iterations as u32;
        let qps = iterations as f64 / total_duration.as_secs_f64();

        BenchmarkResults {
            name: format!("Search: '{}' ({})", query, description),
            duration: avg_duration,
            files_processed: total_hits as u64,
            bytes_processed: 0,
            queries_per_second: Some(qps),
            throughput_mbps: None,
        }
    }

    fn count_source_files(&self) -> (u64, u64) {
        let mut file_count = 0;
        let mut byte_count = 0;
        
        let walker = ignore::WalkBuilder::new(&self.source_path)
            .hidden(false)
            .git_ignore(true)
            .build();
            
        for entry in walker {
            if let Ok(entry) = entry {
                let path = entry.path();
                if path.is_file() {
                    // Check if file matches our patterns
                    let path_str = path.to_string_lossy();
                    if path_str.ends_with(".rs") || path_str.ends_with(".md") || 
                       path_str.ends_with(".toml") || path_str.ends_with(".json") {
                        file_count += 1;
                        if let Ok(metadata) = path.metadata() {
                            byte_count += metadata.len();
                        }
                    }
                }
            }
        }
        
        (file_count, byte_count)
    }

    fn calculate_total_bytes(&self) -> u64 {
        let mut total = 0;
        
        if let Ok(entries) = fs::read_dir(&self.collection_path.join("store")) {
            for entry in entries.flatten() {
                if let Ok(metadata) = entry.metadata() {
                    total += metadata.len();
                }
            }
        }
        
        total
    }
    
    fn save_results(&self, results: &[BenchmarkResults]) -> Result<(), Box<dyn std::error::Error>> {
        let suite = BenchmarkSuite {
            version: env!("CARGO_PKG_VERSION").to_string(),
            timestamp: SystemTime::now()
                .duration_since(SystemTime::UNIX_EPOCH)?
                .as_secs().to_string(),
            git_commit: self.get_git_commit(),
            test_environment: TestEnvironment {
                os: std::env::consts::OS.to_string(),
                cpu: "unknown".to_string(), // Could use sysinfo crate later
                memory: "unknown".to_string(),
            },
            benchmarks: results.to_vec(),
        };
        
        let benchmarks_dir = self.collection_path.parent()
            .unwrap_or(&self.collection_path)
            .join("benchmarks/results");
            
        std::fs::create_dir_all(&benchmarks_dir)?;
        
        let filename = format!("benchmark-{}.json", suite.timestamp);
        let filepath = benchmarks_dir.join(filename);
        
        let json = serde_json::to_string_pretty(&suite)?;
        std::fs::write(filepath, json)?;
        
        Ok(())
    }
    
    fn get_git_commit(&self) -> Option<String> {
        std::process::Command::new("git")
            .arg("rev-parse")
            .arg("--short")
            .arg("HEAD")
            .current_dir(self.collection_path.parent().unwrap_or(&self.collection_path))
            .output()
            .ok()
            .and_then(|output| {
                if output.status.success() {
                    String::from_utf8(output.stdout).ok()
                        .map(|s| s.trim().to_string())
                } else {
                    None
                }
            })
    }

    fn print_summary(&self, results: &[BenchmarkResults]) {
        println!("📊 Benchmark Summary");
        println!("===================");
        
        for result in results {
            result.print();
        }

        // Overall stats
        let import_result = results.iter().find(|r| r.name.contains("Import"));
        
        if let Some(import) = import_result {
            println!("🎯 Key Performance Metrics:");
            println!("- Import Rate: {:.0} files/sec", import.files_processed as f64 / import.duration.as_secs_f64());
            if let Some(throughput) = import.throughput_mbps {
                println!("- Import Throughput: {:.1} MB/s", throughput);
            }
            
            let search_results: Vec<_> = results.iter()
                .filter(|r| r.name.contains("Search"))
                .collect();
            
            if !search_results.is_empty() {
                let avg_qps: f64 = search_results.iter()
                    .filter_map(|r| r.queries_per_second)
                    .sum::<f64>() / search_results.len() as f64;
                println!("- Average Search Rate: {:.1} queries/sec", avg_qps);
            }
        }
        
        println!("✅ Benchmark completed successfully!");
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    #[test]
    #[ignore] // Run with: cargo test --release bench_test -- --ignored
    fn bench_test() {
        let temp_dir = TempDir::new().unwrap();
        let collection_path = temp_dir.path().join("test-bench.sift");
        
        let mut benchmark = SiftDBBenchmark::new(&collection_path, ".");
        let _results = benchmark.run_full_benchmark();
    }
}