@crownpeak/dqm-react-component-dev-mcp 1.2.0

package/data/probe/benches/simd_benchmarks.rs

@@ -0,0 +1,372 @@
+use ahash::AHashMap as HashMap;
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use probe_code::ranking::{
+    rank_documents, rank_documents_simd, rank_documents_simd_simple, RankingParams,
+};
+use probe_code::simd_ranking::SparseVector;
+use rand::prelude::*;
+
+/// Generate synthetic documents for benchmarking
+fn generate_synthetic_docs(num_docs: usize, vocab_size: usize) -> Vec<String> {
+    let mut rng = rand::thread_rng();
+    let mut documents = Vec::with_capacity(num_docs);
+
+    // Create a vocabulary of common programming terms
+    let vocab: Vec<String> = (0..vocab_size)
+        .map(|i| match i % 20 {
+            0..=4 => format!("function_{i}"),
+            5..=9 => format!("class_{i}"),
+            10..=14 => format!("method_{i}"),
+            15..=19 => format!("variable_{i}"),
+            _ => format!("token_{i}"),
+        })
+        .collect();
+
+    for _ in 0..num_docs {
+        let doc_length = rng.gen_range(20..200); // Realistic document lengths
+        let mut doc_tokens = Vec::with_capacity(doc_length);
+
+        for _ in 0..doc_length {
+            let token_idx = rng.gen_range(0..vocab_size);
+            doc_tokens.push(vocab[token_idx].clone());
+        }
+
+        documents.push(doc_tokens.join(" "));
+    }
+
+    documents
+}
+
+/// Generate realistic code-like documents
+fn generate_code_documents(num_docs: usize) -> Vec<String> {
+    let mut rng = rand::thread_rng();
+    let mut documents = Vec::with_capacity(num_docs);
+
+    let functions = [
+        "process",
+        "handle",
+        "execute",
+        "compute",
+        "calculate",
+        "transform",
+        "validate",
+    ];
+    let objects = [
+        "data",
+        "input",
+        "output",
+        "result",
+        "value",
+        "parameter",
+        "config",
+    ];
+    let operations = [
+        "load", "save", "parse", "format", "convert", "merge", "filter",
+    ];
+
+    for _ in 0..num_docs {
+        let mut doc = String::new();
+
+        // Add some function definitions
+        for _ in 0..rng.gen_range(1..5) {
+            let func = functions[rng.gen_range(0..functions.len())];
+            let obj = objects[rng.gen_range(0..objects.len())];
+            let op = operations[rng.gen_range(0..operations.len())];
+
+            doc.push_str(&format!("function {func}{obj}() {{\n"));
+            doc.push_str(&format!("    let {obj} = {op}();\n"));
+            doc.push_str(&format!("    return {obj}.{op}();\n"));
+            doc.push_str("}\n\n");
+        }
+
+        // Add some variable declarations
+        for _ in 0..rng.gen_range(2..8) {
+            let obj = objects[rng.gen_range(0..objects.len())];
+            let val = rng.gen_range(0..1000);
+            doc.push_str(&format!("const {obj} = {val};\n"));
+        }
+
+        documents.push(doc);
+    }
+
+    documents
+}
+
+/// Benchmark sparse vector operations
+fn bench_sparse_vector_ops(c: &mut Criterion) {
+    let mut group = c.benchmark_group("sparse_vector_ops");
+
+    // Create test sparse vectors of different sizes
+    let sizes = [10, 50, 100, 500];
+
+    for &size in &sizes {
+        let mut tf_map1 = HashMap::new();
+        let mut tf_map2 = HashMap::new();
+
+        // Create overlapping sparse vectors
+        for i in 0..size {
+            tf_map1.insert(i as u8, (i % 10) + 1);
+            if i % 3 == 0 {
+                // 33% overlap
+                tf_map2.insert(i as u8, (i % 5) + 1);
+            }
+        }
+
+        let sparse1 = SparseVector::from_tf_map(&tf_map1);
+        let sparse2 = SparseVector::from_tf_map(&tf_map2);
+
+        group.throughput(Throughput::Elements(size as u64));
+        group.bench_with_input(
+            BenchmarkId::new("dot_product", size),
+            &(&sparse1, &sparse2),
+            |b, (v1, v2)| b.iter(|| black_box(v1.dot_product(v2))),
+        );
+
+        group.bench_with_input(
+            BenchmarkId::new("intersection", size),
+            &(&sparse1, &sparse2),
+            |b, (v1, v2)| b.iter(|| black_box(v1.intersect_indices(v2))),
+        );
+    }
+
+    group.finish();
+}
+
+/// Benchmark traditional vs SIMD ranking on synthetic data
+fn bench_ranking_synthetic(c: &mut Criterion) {
+    let mut group = c.benchmark_group("ranking_synthetic");
+
+    let doc_counts = [100, 500, 1000, 2000];
+    let vocab_size = 1000;
+
+    for &num_docs in &doc_counts {
+        let documents = generate_synthetic_docs(num_docs, vocab_size);
+        let doc_refs: Vec<&str> = documents.iter().map(|s| s.as_str()).collect();
+
+        let queries = [
+            "function process data",
+            "class method handle",
+            "variable input output load",
+        ];
+
+        for query in queries {
+            let params = RankingParams {
+                documents: &doc_refs,
+                query,
+                pre_tokenized: None,
+            };
+
+            group.throughput(Throughput::Elements(num_docs as u64));
+
+            let query_id = query.replace(' ', "_");
+            group.bench_with_input(
+                BenchmarkId::new(format!("traditional_{query_id}"), num_docs),
+                &params,
+                |b, params| b.iter(|| black_box(rank_documents(params))),
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new(format!("simd_{query_id}"), num_docs),
+                &params,
+                |b, params| b.iter(|| black_box(rank_documents_simd(params))),
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new(format!("simd_simple_{query_id}"), num_docs),
+                &params,
+                |b, params| b.iter(|| black_box(rank_documents_simd_simple(params))),
+            );
+        }
+    }
+
+    group.finish();
+}
+
+/// Benchmark traditional vs SIMD ranking on realistic code documents
+fn bench_ranking_realistic(c: &mut Criterion) {
+    let mut group = c.benchmark_group("ranking_realistic");
+
+    let doc_counts = [50, 200, 500, 1000];
+
+    for &num_docs in &doc_counts {
+        let documents = generate_code_documents(num_docs);
+        let doc_refs: Vec<&str> = documents.iter().map(|s| s.as_str()).collect();
+
+        let queries = [
+            "function process data load",
+            "class method handle input",
+            "variable config parameter validate",
+            "execute compute transform merge",
+        ];
+
+        for query in queries {
+            let params = RankingParams {
+                documents: &doc_refs,
+                query,
+                pre_tokenized: None,
+            };
+
+            group.throughput(Throughput::Elements(num_docs as u64));
+
+            let query_id = query.replace(' ', "_");
+            group.bench_with_input(
+                BenchmarkId::new(format!("traditional_{query_id}"), num_docs),
+                &params,
+                |b, params| b.iter(|| black_box(rank_documents(params))),
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new(format!("simd_{query_id}"), num_docs),
+                &params,
+                |b, params| b.iter(|| black_box(rank_documents_simd(params))),
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new(format!("simd_simple_{query_id}"), num_docs),
+                &params,
+                |b, params| b.iter(|| black_box(rank_documents_simd_simple(params))),
+            );
+        }
+    }
+
+    group.finish();
+}
+
+/// Benchmark memory usage and allocation patterns
+fn bench_memory_efficiency(c: &mut Criterion) {
+    let mut group = c.benchmark_group("memory_efficiency");
+
+    let num_docs = 1000;
+    let documents = generate_code_documents(num_docs);
+    let doc_refs: Vec<&str> = documents.iter().map(|s| s.as_str()).collect();
+
+    let query = "function process data load validate";
+    let params = RankingParams {
+        documents: &doc_refs,
+        query,
+        pre_tokenized: None,
+    };
+
+    group.bench_function("traditional_memory", |b| {
+        b.iter(|| {
+            let _results = black_box(rank_documents(&params));
+            // Memory will be automatically freed here
+        })
+    });
+
+    group.bench_function("simd_memory", |b| {
+        b.iter(|| {
+            let _results = black_box(rank_documents_simd(&params));
+            // Memory will be automatically freed here
+        })
+    });
+
+    group.bench_function("simd_simple_memory", |b| {
+        b.iter(|| {
+            let _results = black_box(rank_documents_simd_simple(&params));
+            // Memory will be automatically freed here
+        })
+    });
+
+    group.finish();
+}
+
+/// Benchmark with varying query complexities
+fn bench_query_complexity(c: &mut Criterion) {
+    let mut group = c.benchmark_group("query_complexity");
+
+    let num_docs = 500;
+    let documents = generate_code_documents(num_docs);
+    let doc_refs: Vec<&str> = documents.iter().map(|s| s.as_str()).collect();
+
+    let queries = [
+        ("simple", "function"),
+        ("medium", "function process data"),
+        ("complex", "function process data load validate transform"),
+        ("boolean", "+function +process -deprecated"),
+        ("mixed", "function OR method AND (data OR input)"),
+    ];
+
+    for (complexity, query) in queries {
+        let params = RankingParams {
+            documents: &doc_refs,
+            query,
+            pre_tokenized: None,
+        };
+
+        group.bench_with_input(
+            BenchmarkId::new("traditional", complexity),
+            &params,
+            |b, params| b.iter(|| black_box(rank_documents(params))),
+        );
+
+        group.bench_with_input(
+            BenchmarkId::new("simd", complexity),
+            &params,
+            |b, params| b.iter(|| black_box(rank_documents_simd(params))),
+        );
+
+        // Simple SIMD works best with non-boolean queries
+        if !query.contains(['+', '-', '(', ')']) {
+            group.bench_with_input(
+                BenchmarkId::new("simd_simple", complexity),
+                &params,
+                |b, params| b.iter(|| black_box(rank_documents_simd_simple(params))),
+            );
+        }
+    }
+
+    group.finish();
+}
+
+/// Benchmark scalability with increasing document sizes
+fn bench_scalability(c: &mut Criterion) {
+    let mut group = c.benchmark_group("scalability");
+    group.sample_size(20); // Fewer samples for large datasets
+
+    let doc_counts = [100, 500, 1000, 2500, 5000];
+    let query = "function process data load";
+
+    for &num_docs in &doc_counts {
+        let documents = generate_synthetic_docs(num_docs, 500);
+        let doc_refs: Vec<&str> = documents.iter().map(|s| s.as_str()).collect();
+
+        let params = RankingParams {
+            documents: &doc_refs,
+            query,
+            pre_tokenized: None,
+        };
+
+        group.throughput(Throughput::Elements(num_docs as u64));
+
+        group.bench_with_input(
+            BenchmarkId::new("traditional", num_docs),
+            &params,
+            |b, params| b.iter(|| black_box(rank_documents(params))),
+        );
+
+        group.bench_with_input(BenchmarkId::new("simd", num_docs), &params, |b, params| {
+            b.iter(|| black_box(rank_documents_simd(params)))
+        });
+
+        group.bench_with_input(
+            BenchmarkId::new("simd_simple", num_docs),
+            &params,
+            |b, params| b.iter(|| black_box(rank_documents_simd_simple(params))),
+        );
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_sparse_vector_ops,
+    bench_ranking_synthetic,
+    bench_ranking_realistic,
+    bench_memory_efficiency,
+    bench_query_complexity,
+    bench_scalability
+);
+
+criterion_main!(benches);

package/data/probe/benches/timing_benchmarks.rs

@@ -0,0 +1,287 @@
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use probe_code::search::search_runner::{format_duration, SearchTimings};
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+/// Benchmark the timing infrastructure overhead
+fn benchmark_timing_overhead(c: &mut Criterion) {
+    let mut group = c.benchmark_group("timing_overhead");
+
+    // Test timing collection overhead
+    group.bench_function("timing_collection", |b| {
+        b.iter(|| {
+            let start = Instant::now();
+
+            // Simulate work
+            black_box((0..1000).map(|i| i * 2).collect::<Vec<_>>());
+
+            let duration = start.elapsed();
+            black_box(duration)
+        })
+    });
+
+    // Test SearchTimings struct creation
+    group.bench_function("search_timings_creation", |b| {
+        b.iter(|| {
+            let timings = SearchTimings {
+                query_preprocessing: Some(Duration::from_millis(10)),
+                pattern_generation: Some(Duration::from_millis(5)),
+                file_searching: Some(Duration::from_millis(100)),
+                filename_matching: Some(Duration::from_millis(20)),
+                early_filtering: Some(Duration::from_millis(30)),
+                early_caching: Some(Duration::from_millis(15)),
+                early_ranking: Some(Duration::from_millis(22)),
+                result_processing: Some(Duration::from_millis(200)),
+                result_processing_file_io: Some(Duration::from_millis(50)),
+                result_processing_line_collection: Some(Duration::from_millis(25)),
+                result_processing_ast_parsing: Some(Duration::from_millis(75)),
+                result_processing_block_extraction: Some(Duration::from_millis(40)),
+                result_processing_result_building: Some(Duration::from_millis(60)),
+                result_processing_ast_parsing_language_init: Some(Duration::from_millis(5)),
+                result_processing_ast_parsing_parser_init: Some(Duration::from_millis(3)),
+                result_processing_ast_parsing_tree_parsing: Some(Duration::from_millis(45)),
+                result_processing_ast_parsing_line_map_building: Some(Duration::from_millis(8)),
+                result_processing_block_extraction_code_structure: Some(Duration::from_millis(15)),
+                result_processing_block_extraction_filtering: Some(Duration::from_millis(10)),
+                result_processing_block_extraction_result_building: Some(Duration::from_millis(20)),
+                result_processing_term_matching: Some(Duration::from_millis(12)),
+                result_processing_compound_processing: Some(Duration::from_millis(8)),
+                result_processing_line_matching: Some(Duration::from_millis(18)),
+                result_processing_result_creation: Some(Duration::from_millis(25)),
+                result_processing_synchronization: Some(Duration::from_millis(5)),
+                result_processing_uncovered_lines: Some(Duration::from_millis(15)),
+                result_ranking: Some(Duration::from_millis(35)),
+                limit_application: Some(Duration::from_millis(2)),
+                block_merging: Some(Duration::from_millis(8)),
+                final_caching: Some(Duration::from_millis(12)),
+                total_search_time: Some(Duration::from_millis(500)),
+            };
+            black_box(timings)
+        })
+    });
+
+    group.finish();
+}
+
+/// Benchmark duration formatting
+fn benchmark_duration_formatting(c: &mut Criterion) {
+    let durations = [
+        Duration::from_nanos(500),
+        Duration::from_micros(100),
+        Duration::from_millis(50),
+        Duration::from_millis(999),
+        Duration::from_secs(1),
+        Duration::from_secs(10),
+        Duration::from_secs(60),
+    ];
+
+    let mut group = c.benchmark_group("duration_formatting");
+
+    for (i, duration) in durations.iter().enumerate() {
+        group.bench_with_input(
+            BenchmarkId::new("format_duration", i),
+            duration,
+            |b, duration| b.iter(|| black_box(format_duration(*duration))),
+        );
+    }
+
+    group.finish();
+}
+
+/// Benchmark timing aggregation
+fn benchmark_timing_aggregation(c: &mut Criterion) {
+    let mut group = c.benchmark_group("timing_aggregation");
+
+    // Create sample timings data
+    let create_sample_timings = || {
+        vec![
+            Duration::from_millis(10),
+            Duration::from_millis(25),
+            Duration::from_millis(5),
+            Duration::from_millis(50),
+            Duration::from_millis(100),
+            Duration::from_millis(75),
+            Duration::from_millis(30),
+            Duration::from_millis(15),
+            Duration::from_millis(8),
+            Duration::from_millis(45),
+        ]
+    };
+
+    // Test aggregation operations
+    group.bench_function("sum_durations", |b| {
+        b.iter(|| {
+            let durations = create_sample_timings();
+            let total: Duration = durations.iter().sum();
+            black_box(total)
+        })
+    });
+
+    group.bench_function("average_duration", |b| {
+        b.iter(|| {
+            let durations = create_sample_timings();
+            let total: Duration = durations.iter().sum();
+            let avg = total / durations.len() as u32;
+            black_box(avg)
+        })
+    });
+
+    group.bench_function("min_max_duration", |b| {
+        b.iter(|| {
+            let durations = create_sample_timings();
+            let min = *durations.iter().min().unwrap();
+            let max = *durations.iter().max().unwrap();
+            black_box((min, max))
+        })
+    });
+
+    group.finish();
+}
+
+/// Benchmark timing storage and retrieval
+fn benchmark_timing_storage(c: &mut Criterion) {
+    let mut group = c.benchmark_group("timing_storage");
+
+    // Test HashMap storage for timing data
+    group.bench_function("hashmap_storage", |b| {
+        b.iter(|| {
+            let mut timings = HashMap::new();
+            timings.insert("query_preprocessing", Duration::from_millis(10));
+            timings.insert("pattern_generation", Duration::from_millis(5));
+            timings.insert("file_searching", Duration::from_millis(100));
+            timings.insert("filename_matching", Duration::from_millis(20));
+            timings.insert("early_filtering", Duration::from_millis(30));
+            timings.insert("result_processing", Duration::from_millis(200));
+            timings.insert("result_ranking", Duration::from_millis(35));
+            timings.insert("limit_application", Duration::from_millis(2));
+            timings.insert("block_merging", Duration::from_millis(8));
+            timings.insert("final_caching", Duration::from_millis(12));
+
+            // Simulate retrieval
+            let total: Duration = timings.values().sum();
+            black_box(total)
+        })
+    });
+
+    // Test Vec storage for timing data
+    group.bench_function("vec_storage", |b| {
+        b.iter(|| {
+            let timings = vec![
+                ("query_preprocessing", Duration::from_millis(10)),
+                ("pattern_generation", Duration::from_millis(5)),
+                ("file_searching", Duration::from_millis(100)),
+                ("filename_matching", Duration::from_millis(20)),
+                ("early_filtering", Duration::from_millis(30)),
+                ("result_processing", Duration::from_millis(200)),
+                ("result_ranking", Duration::from_millis(35)),
+                ("limit_application", Duration::from_millis(2)),
+                ("block_merging", Duration::from_millis(8)),
+                ("final_caching", Duration::from_millis(12)),
+            ];
+
+            // Simulate retrieval
+            let total: Duration = timings.iter().map(|(_, d)| *d).sum();
+            black_box(total)
+        })
+    });
+
+    group.finish();
+}
+
+/// Benchmark debug mode timing output
+fn benchmark_debug_output(c: &mut Criterion) {
+    let mut group = c.benchmark_group("debug_output");
+
+    // Create sample timings
+    let create_sample_search_timings = || SearchTimings {
+        query_preprocessing: Some(Duration::from_millis(10)),
+        pattern_generation: Some(Duration::from_millis(5)),
+        file_searching: Some(Duration::from_millis(100)),
+        filename_matching: Some(Duration::from_millis(20)),
+        early_filtering: Some(Duration::from_millis(30)),
+        early_caching: Some(Duration::from_millis(15)),
+        early_ranking: Some(Duration::from_millis(22)),
+        result_processing: Some(Duration::from_millis(200)),
+        result_processing_file_io: Some(Duration::from_millis(50)),
+        result_processing_line_collection: Some(Duration::from_millis(25)),
+        result_processing_ast_parsing: Some(Duration::from_millis(75)),
+        result_processing_block_extraction: Some(Duration::from_millis(40)),
+        result_processing_result_building: Some(Duration::from_millis(60)),
+        result_processing_ast_parsing_language_init: Some(Duration::from_millis(5)),
+        result_processing_ast_parsing_parser_init: Some(Duration::from_millis(3)),
+        result_processing_ast_parsing_tree_parsing: Some(Duration::from_millis(45)),
+        result_processing_ast_parsing_line_map_building: Some(Duration::from_millis(8)),
+        result_processing_block_extraction_code_structure: Some(Duration::from_millis(15)),
+        result_processing_block_extraction_filtering: Some(Duration::from_millis(10)),
+        result_processing_block_extraction_result_building: Some(Duration::from_millis(20)),
+        result_processing_term_matching: Some(Duration::from_millis(12)),
+        result_processing_compound_processing: Some(Duration::from_millis(8)),
+        result_processing_line_matching: Some(Duration::from_millis(18)),
+        result_processing_result_creation: Some(Duration::from_millis(25)),
+        result_processing_synchronization: Some(Duration::from_millis(5)),
+        result_processing_uncovered_lines: Some(Duration::from_millis(15)),
+        result_ranking: Some(Duration::from_millis(35)),
+        limit_application: Some(Duration::from_millis(2)),
+        block_merging: Some(Duration::from_millis(8)),
+        final_caching: Some(Duration::from_millis(12)),
+        total_search_time: Some(Duration::from_millis(500)),
+    };
+
+    // Note: We can't actually test print_timings in benchmarks since it uses println!
+    // Instead, we'll benchmark the logic that would be involved
+    group.bench_function("timing_analysis", |b| {
+        b.iter(|| {
+            let timings = create_sample_search_timings();
+
+            // Simulate the work that print_timings would do
+            let mut total_time = Duration::from_secs(0);
+
+            if let Some(d) = timings.query_preprocessing {
+                total_time += d;
+            }
+            if let Some(d) = timings.pattern_generation {
+                total_time += d;
+            }
+            if let Some(d) = timings.file_searching {
+                total_time += d;
+            }
+            if let Some(d) = timings.filename_matching {
+                total_time += d;
+            }
+            if let Some(d) = timings.early_filtering {
+                total_time += d;
+            }
+            if let Some(d) = timings.result_processing {
+                total_time += d;
+            }
+            if let Some(d) = timings.result_ranking {
+                total_time += d;
+            }
+            if let Some(d) = timings.limit_application {
+                total_time += d;
+            }
+            if let Some(d) = timings.block_merging {
+                total_time += d;
+            }
+            if let Some(d) = timings.final_caching {
+                total_time += d;
+            }
+
+            // Simulate formatting
+            let formatted = format_duration(total_time);
+            black_box(formatted)
+        })
+    });
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    benchmark_timing_overhead,
+    benchmark_duration_formatting,
+    benchmark_timing_aggregation,
+    benchmark_timing_storage,
+    benchmark_debug_output
+);
+criterion_main!(benches);