perf: Improve macos indexing wall time

Author: dmtrKovalenko

autoresearch.jsonl

@@ -0,0 +1 @@
+{"type":"config","name":"Reduce bigram build time by grouping files per parent dir for openat","metricName":"post_scan_s","metricUnit":"s","bestDirection":"lower"}

crates/fff-core/src/bigram_filter.rs

@@ -631,34 +631,76 @@ pub(crate) fn build_bigram_index(
     budget: &crate::types::ContentCacheBudget,
     base_path: &std::path::Path,
     arena: crate::simd_path::ArenaPtr,
+    warmup: bool,
 ) -> (BigramFilter, Vec<usize>) {
     let start = std::time::Instant::now();
-    tracing::info!("Building bigram index for {} files...", files.len());
+    tracing::info!(
+        "Building bigram index for {} files (warmup={})",
+        files.len(),
+        warmup,
+    );
 
     let builder = BigramIndexBuilder::new(files.len());
     let skip_builder = BigramIndexBuilder::new(files.len());
 
-    // this does remove a memcpy for every single file + actually reducing open time on macos
     #[cfg(unix)]
     let base_fd: libc::c_int = open_base_dir_fd(base_path);
     #[cfg(not(unix))]
     let base_fd: i32 = -1;
 
-    // `content_binary` is only touched from the Binary branch below, so
-    // the mutex is cold in practice. A lock-free collector wasn't worth
-    // the complexity.
     let content_binary: std::sync::Mutex<Vec<usize>> = std::sync::Mutex::new(Vec::new());
 
-    crate::file_picker::BACKGROUND_THREAD_POOL.install(|| {
-        files
-            .par_chunks(BIGRAM_CHUNK_FILES)
-            .enumerate()
-            .for_each(|(chunk_idx, chunk)| {
-                let base_idx = chunk_idx * BIGRAM_CHUNK_FILES;
-                for (offset, file) in chunk.iter().enumerate() {
-                    let file_idx = base_idx + offset;
+    // When warmup is enabled, process high-frecency files first so they
+    // fill the limited cache budget before lower-priority files consume it.
+    // This replaces the separate warmup_mmaps pass with zero extra syscalls.
+    if warmup {
+        let max_files = budget.max_files;
+        // Partition indices: top `max_files` by frecency go first.
+        let mut indices: Vec<usize> = (0..files.len()).collect();
+        if indices.len() > max_files {
+            indices.select_nth_unstable_by(max_files, |&a, &b| {
+                let fa = &files[a];
+                let fb = &files[b];
+                let a_ok = !fa.is_binary() && fa.size > 0;
+                let b_ok = !fb.is_binary() && fb.size > 0;
+                match (a_ok, b_ok) {
+                    (true, false) => std::cmp::Ordering::Less,
+                    (false, true) => std::cmp::Ordering::Greater,
+                    (false, false) => std::cmp::Ordering::Equal,
+                    (true, true) => fb.total_frecency_score().cmp(&fa.total_frecency_score()),
+                }
+            });
+        }
+
+        // Process priority files first (fills cache), then the rest.
+        let priority_count = max_files.min(indices.len());
+        let (priority, rest) = indices.split_at(priority_count);
+
+        crate::file_picker::BACKGROUND_THREAD_POOL.install(|| {
+            // Phase 1: high-frecency files fill the cache budget.
+            priority.par_chunks(BIGRAM_CHUNK_FILES).for_each(|chunk| {
+                for &file_idx in chunk {
+                    let outcome = process_file(
+                        &files[file_idx],
+                        file_idx,
+                        &builder,
+                        &skip_builder,
+                        base_fd,
+                        base_path,
+                        arena,
+                        budget,
+                    );
+                    if matches!(outcome, FileOutcome::Binary) {
+                        content_binary.lock().unwrap().push(file_idx);
+                    }
+                }
+            });
+
+            // Phase 2: remaining files (cache budget likely exhausted, uses openat).
+            rest.par_chunks(BIGRAM_CHUNK_FILES).for_each(|chunk| {
+                for &file_idx in chunk {
                     let outcome = process_file(
-                        file,
+                        &files[file_idx],
                         file_idx,
                         &builder,
                         &skip_builder,
@@ -672,12 +714,37 @@ pub(crate) fn build_bigram_index(
                     }
                 }
             });
-    });
+        });
+    } else {
+        // No warmup: process in natural order (no cache priority needed).
+        crate::file_picker::BACKGROUND_THREAD_POOL.install(|| {
+            files
+                .par_chunks(BIGRAM_CHUNK_FILES)
+                .enumerate()
+                .for_each(|(chunk_idx, chunk)| {
+                    let base_idx = chunk_idx * BIGRAM_CHUNK_FILES;
+                    for (offset, file) in chunk.iter().enumerate() {
+                        let file_idx = base_idx + offset;
+                        let outcome = process_file(
+                            file,
+                            file_idx,
+                            &builder,
+                            &skip_builder,
+                            base_fd,
+                            base_path,
+                            arena,
+                            budget,
+                        );
+                        if matches!(outcome, FileOutcome::Binary) {
+                            content_binary.lock().unwrap().push(file_idx);
+                        }
+                    }
+                });
+        });
+    }
 
     #[cfg(unix)]
     if base_fd >= 0 {
-        // SAFETY: we opened `base_fd` at the top of this function and
-        // no worker still references it once the rayon pool joined.
         unsafe { libc::close(base_fd) };
     }
 
@@ -688,9 +755,6 @@ pub(crate) fn build_bigram_index(
     let skip_index = skip_builder.compress(Some(SKIP_INDEX_MIN_DENSITY_PCT));
     index.set_skip_index(skip_index);
 
-    // Builder buffers were freed by `compress()` above (one deallocation
-    // each); nudge mimalloc to return them (and any transient allocs)
-    // to the OS.
     crate::file_picker::hint_allocator_collect();
 
     tracing::info!(

crates/fff-core/src/file_picker.rs

@@ -74,11 +74,10 @@ pub(crate) static BACKGROUND_THREAD_POOL: LazyLock<rayon::ThreadPool> = LazyLock
     let total = std::thread::available_parallelism()
         .map(|p| p.get())
         .unwrap_or(4);
-    let bg_threads = total.saturating_sub(2).max(1);
-    info!(
-        "Background pool: {} threads (system has {})",
-        bg_threads, total
-    );
+
+    // benchmarks show that most of the work backgound tasks spend on waiting for syscalls,
+    // by halfing avialable parallelism we loose some performance, but it is mostly nothing
+    let bg_threads = (total / 2).max(2);
     rayon::ThreadPoolBuilder::new()
         .num_threads(bg_threads)
         .thread_name(|i| format!("fff-bg-{i}"))
@@ -745,6 +744,17 @@ impl FilePicker {
 
         {
             let mut guard = shared_picker.write()?;
+            // If the old picker has a post-scan in flight, wait for it to
+            // finish. cancel() was already called so the rayon loop exits
+            // within microseconds (each worker checks cancelled per item).
+            if let Some(ref old_picker) = *guard {
+                let flag = Arc::clone(&old_picker.signals.post_scan_indexing_active);
+                drop(guard);
+                while flag.load(Ordering::Acquire) {
+                    std::thread::sleep(std::time::Duration::from_millis(1));
+                }
+                guard = shared_picker.write()?;
+            }
             *guard = Some(picker);
         }
 
@@ -1288,6 +1298,7 @@ impl FilePicker {
             arena: self.sync_data.arena_base_ptr(),
             budget: &*self.cache_budget as *const _,
             base_path: self.base_path.clone(),
+            cancelled: Arc::clone(&self.signals.cancelled),
             post_scan_flag: Arc::clone(&self.signals.post_scan_indexing_active),
         })
     }
@@ -1655,8 +1666,7 @@ pub(crate) struct PostScanUnsafeSnapshot {
     pub arena: ArenaPtr,
     pub budget: *const crate::types::ContentCacheBudget,
     pub base_path: PathBuf,
-    /// Holds the flag reference so it is automatically flips
-    /// when the pointsr
+    pub cancelled: Arc<AtomicBool>,
     post_scan_flag: Arc<AtomicBool>,
 }
 

crates/fff-core/src/scan.rs

@@ -217,14 +217,24 @@ impl ScanJob {
             rescubscribe_watcher_post_scan(&shared_picker);
         }
 
-        // 3. Apply git status + frecency off-lock.
+        // 3. Post-scan warmup + bigram build.
+        // Run BEFORE git status join so bigram I/O overlaps with the
+        // git-status thread (which can take 10+ seconds on huge repos).
+        // Frecency scores are already populated during walk_filesystem,
+        // so warmup cache priority works correctly without git status.
+        if (config.warmup || config.content_indexing) && !signals.cancelled.load(Ordering::Acquire)
+        {
+            Self::run_post_scan(&shared_picker, &signals, &config);
+        }
+
+        // 4. Apply git status + frecency off-lock (joins the git thread).
         if !signals.cancelled.load(Ordering::Acquire)
             && let Some(status_handle) = status_handle
         {
             apply_git_status_and_frecency(&shared_picker, &shared_frecency, status_handle, mode);
         }
 
-        // 4. Install filesystem watcher (initial scan only).
+        // 5. Install filesystem watcher (initial scan only).
         if config.install_watcher && config.watch && !signals.cancelled.load(Ordering::Acquire) {
             let shared_picker: &SharedFilePicker = &shared_picker;
             let shared_frecency: &SharedFrecency = &shared_frecency;
@@ -248,12 +258,6 @@ impl ScanJob {
             };
         }
 
-        // 5. Post-scan warmup + bigram build.
-        if (config.warmup || config.content_indexing) && !signals.cancelled.load(Ordering::Acquire)
-        {
-            Self::run_post_scan(&shared_picker, &signals, &config);
-        }
-
         // 6. Drain any rescan that arrived while we were busy.
         //
         // `trigger_full_rescan_async` sets `rescan_pending` whenever a
@@ -312,22 +316,17 @@ impl ScanJob {
         };
         let budget: &ContentCacheBudget = unsafe { &*unsafe_snapshot.budget };
 
-        if config.warmup && !signals.cancelled.load(Ordering::Acquire) {
-            warmup_mmaps(
-                files,
-                budget,
-                &unsafe_snapshot.base_path,
-                unsafe_snapshot.arena,
-            );
-        }
-
         if config.content_indexing && !signals.cancelled.load(Ordering::Acquire) {
+            // Unified pass: bigram indexing + warmup cache fill in one sweep.
+            // When warmup is enabled, high-frecency files are processed first
+            // so they fill the cache budget before it's exhausted.
             let indexable_files = &files[..unsafe_snapshot.indexable_count.min(files.len())];
             let (index, content_binary) = build_bigram_index(
                 indexable_files,
                 budget,
                 &unsafe_snapshot.base_path,
                 unsafe_snapshot.arena,
+                config.warmup,
             );
 
             if let Ok(mut guard) = shared_picker.write()
@@ -340,28 +339,14 @@ impl ScanJob {
                 }
                 picker.set_bigram_index(index, BigramOverlay::new(unsafe_snapshot.indexable_count));
             }
-        }
-
-        if config.content_indexing && !signals.cancelled.load(Ordering::Acquire) {
-            let indexable_files = &files[..unsafe_snapshot.indexable_count.min(files.len())];
-            let (index, content_binary) = build_bigram_index(
-                indexable_files,
+        } else if config.warmup && !signals.cancelled.load(Ordering::Acquire) {
+            // Warmup-only: no bigram indexing, just fill the mmap cache.
+            warmup_mmaps(
+                files,
                 budget,
                 &unsafe_snapshot.base_path,
                 unsafe_snapshot.arena,
             );
-
-            if let Ok(mut guard) = shared_picker.write()
-                && let Some(picker) = guard.as_mut()
-            {
-                for &idx in &content_binary {
-                    if let Some(file) = picker.get_file_mut(idx) {
-                        file.set_binary(true);
-                    }
-                }
-
-                picker.set_bigram_index(index, BigramOverlay::new(unsafe_snapshot.indexable_count));
-            }
         }
     }
 }
@@ -453,6 +438,10 @@ fn apply_git_status_and_frecency(
 
     BACKGROUND_THREAD_POOL.install(|| {
         files.par_iter_mut().for_each(|file| {
+            if unsafe_snapshot.cancelled.load(Ordering::Relaxed) {
+                return;
+            }
+
             let mut buf = [0u8; crate::simd_path::PATH_BUF_SIZE];
             let absolute_path = file.write_absolute_path(
                 unsafe_snapshot.arena,

crates/fff-core/src/shared.rs

@@ -113,6 +113,44 @@ impl SharedFilePicker {
             .is_some_and(|p| p.has_mmap_cache() || p.has_content_indexing())
     }
 
+    /// Block until post-scan indexing (bigram + warmup) finishes.
+    pub fn wait_for_post_scan(&self, timeout: Duration) -> bool {
+        let signal = {
+            let guard = self.0.picker.read();
+            match &*guard {
+                Some(picker) => Arc::clone(&picker.signals.post_scan_indexing_active),
+                None => return true,
+            }
+        };
+
+        let start = std::time::Instant::now();
+        // The post_scan_indexing_active flag cycles twice:
+        // once for git+frecency, once for warmup+bigram. We need to wait for
+        // both cycles. Strategy: keep waiting until it's been inactive for a
+        // sustained period indicating no more work is coming.
+        let mut saw_active = false;
+        let mut last_inactive_at: Option<std::time::Instant> = None;
+
+        loop {
+            if start.elapsed() >= timeout {
+                return false;
+            }
+
+            let active = signal.load(std::sync::atomic::Ordering::Acquire);
+            if active {
+                saw_active = true;
+                last_inactive_at = None;
+            } else if saw_active {
+                // Flag went inactive. Wait 200ms to confirm it doesn't reactivate.
+                let inactive_since = last_inactive_at.get_or_insert_with(std::time::Instant::now);
+                if inactive_since.elapsed() > Duration::from_millis(200) {
+                    return true;
+                }
+            }
+            std::thread::sleep(Duration::from_millis(10));
+        }
+    }
+
     /// Block until the background filesystem scan finishes.
     /// Returns `true` if scan completed, `false` on timeout.
     pub fn wait_for_scan(&self, timeout: Duration) -> bool {

crates/fff-nvim/Cargo.toml

@@ -105,3 +105,7 @@ harness = false
 [[bench]]
 name = "query_tracker_bench"
 harness = false
+
+[[bench]]
+name = "post_scan_bench"
+harness = false