perf: Reduce memory footprint of grep index

Author: dmtrKovalenko

crates/fff-c/src/lib.rs

@@ -606,7 +606,7 @@ pub unsafe extern "C" fn fff_wait_for_scan(
         Err(e) => return e,
     };
 
-    let completed = FilePicker::wait_for_scan(&picker, Duration::from_millis(timeout_ms));
+    let completed = FilePicker::wait_for_scan(picker, Duration::from_millis(timeout_ms));
     FffResult::ok_int(completed as i64)
 }
 

crates/fff-core/benches/bigram_bench.rs

@@ -23,11 +23,9 @@ fn bench_bigram_query(c: &mut Criterion) {
     for &file_count in &file_counts {
         let index = build_test_index(file_count);
         eprintln!(
-            "Index ({} files): {} columns ({} dense, {} sparse)",
+            "Index ({} files): {} columns",
             file_count,
             index.columns_used(),
-            index.dense_columns(),
-            index.sparse_columns(),
         );
 
         let mut group = c.benchmark_group(format!("bigram_query_{file_count}"));

crates/fff-core/src/file_picker.rs

@@ -1172,6 +1172,7 @@ pub fn build_bigram_index(
     let start = std::time::Instant::now();
     info!("Building bigram index for {} files...", files.len());
     let builder = BigramIndexBuilder::new(files.len());
+    let skip_builder = BigramIndexBuilder::new(files.len());
     let max_file_size = budget.max_file_size;
 
     // Collect indices of files that passed the extension heuristic but are
@@ -1208,21 +1209,25 @@ pub fn build_bigram_index(
 
         let content = data.unwrap_or_else(|| owned.as_ref().unwrap());
         builder.add_file_content(i, content);
+        skip_builder.add_file_content_skip(i, content);
     });
 
     let cols = builder.columns_used();
-    let index = builder.compress();
+    let mut index = builder.compress();
+    // Skip index: skip bigrams are inherently less specific than consecutive
+    // bigrams, so relevant columns are almost always dense. Dense-only saves
+    // ~20% memory vs all columns with no loss in filtering.
+    let skip_index = skip_builder.compress();
+    index.set_skip_index(skip_index);
 
     // The builder just freed ~276 MB (for 500k files) of atomic bitsets.
     // Hint the allocator to return those pages to the OS.
     hint_allocator_collect();
 
     info!(
-        "Bigram index built in {:.2}s — {} columns ({} sparse, {} dense) for {} files",
+        "Bigram index built in {:.2}s — {} dense columns for {} files",
         start.elapsed().as_secs_f64(),
         cols,
-        index.sparse_columns(),
-        index.dense_columns(),
         files.len(),
     );
 

crates/fff-core/src/grep.rs

@@ -1786,7 +1786,7 @@ pub fn grep_search<'a>(
     // it is important that this step is coming as early as possible
     let (files_to_search, filtered_file_count) = match bigram_candidates {
         Some(ref candidates) if constraints_from_query.is_empty() => {
-            // this call is essentially free and much more efficient than alowing a recollection
+            // this call is essentially free and much more efficient than allowing a recollection
             let cap = BigramFilter::count_candidates(candidates);
             let mut result: Vec<&FileItem> = Vec::with_capacity(cap);
             for (word_idx, &word) in candidates.iter().enumerate() {
@@ -1875,20 +1875,15 @@ pub fn grep_search<'a>(
     }
     .build();
 
-    // Dispatch to the appropriate sink type at the boundary — zero runtime
-    // branching inside the per-line hot path.
-    //
-    // When not in regex mode, pass the memmem finder as a whole-file prefilter.
-    // A single SIMD memmem scan rejects non-matching files before the
-    // grep-searcher allocates state and splits lines — ~0.3us vs ~7us per file.
-    let prefilter = if regex.is_none() { Some(&finder) } else { None };
+    // prefilter looks for the literal occurrence if the search is case insensitive
+    let should_perfilter = regex.is_none() && !case_insensitive;
     let mut result = perform_grep(
         &files_to_search,
         options,
         total_files,
         filtered_file_count,
         budget,
-        prefilter,
+        should_perfilter.then_some(&finder),
         |file_bytes: &[u8], max_matches: usize| {
             let state = SinkState {
                 file_index: 0, // set by run_file_search