prefetch the text as well

Author: tibvdm

sa-index/src/sa_searcher.rs

@@ -426,9 +426,23 @@ impl Searcher {
             if let BoundSearchResult::SearchResult((min_bound, max_bound)) = search_bound_result {
                 // try all the partially matched suffixes and store the matching suffixes in an
                 // array (stop when our max number of matches is reached)
+                const ITER_PREFETCH_DISTANCE: usize = 16;
                 let mut sa_index = min_bound;
                 let t_iter = Instant::now();
                 while sa_index < max_bound {
+                    // Look ITER_PREFETCH_DISTANCE steps ahead in the SA to find the future
+                    // suffix position, then prefetch the text at (future_suffix - skip).
+                    // The SA read is sequential (hardware prefetcher already handles it),
+                    // so this is cheap. The text prefetch hides the DRAM latency for the
+                    // random text access that check_prefix/check_suffix will make N iterations later.
+                    let future_sa_index = sa_index + ITER_PREFETCH_DISTANCE;
+                    if future_sa_index < max_bound {
+                        let future_suffix = self.sa.get(future_sa_index) as usize;
+                        if future_suffix >= skip {
+                            self.proteins.text().prefetch(future_suffix - skip);
+                        }
+                    }
+
                     let suffix = self.sa.get(sa_index) as usize;
 
                     if suffix >= skip {

text-compression/src/lib.rs

@@ -16,6 +16,18 @@ pub use traits::{WriteBinary, ReadBinary, ReadBinaryMmap};
 /// The 5-bit-to-char lookup table for mmap-backed ProteinText.
 const BIT5_TO_CHAR: &[u8; 27] = b"ABCDEFGHIKLMNOPQRSTUVWXYZ-$";
 
+/// Non-blocking hardware prefetch hint: move the cache line containing `ptr` into L1.
+/// No-op on unsupported architectures.
+#[inline(always)]
+fn prefetch_read(ptr: *const u8) {
+    #[cfg(target_arch = "x86_64")]
+    unsafe { std::arch::x86_64::_mm_prefetch(ptr as *const i8, std::arch::x86_64::_MM_HINT_T0) }
+    #[cfg(target_arch = "aarch64")]
+    unsafe { std::arch::asm!("prfm pldl1keep, [{p}]", p = in(reg) ptr, options(nostack, preserves_flags, readonly)) }
+    #[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
+    let _ = ptr;
+}
+
 /// Returns the number of bytes the BitArray data occupies for a given text length at 5 bits/value.
 pub fn bit_array_byte_size(text_length: usize) -> usize {
     let extra = if (text_length * 5).is_multiple_of(64) { 0 } else { 1 };
@@ -188,6 +200,20 @@ impl ProteinText {
         ProteinTextSlice::new(self, start, end)
     }
 
+    /// Non-blocking hardware prefetch hint for the cache line covering character `index`.
+    /// At 5 bits/char a 64-byte cache line holds 102 characters, so a single hint covers
+    /// the entire peptide window starting at `index`.
+    /// No-op for in-memory text and on unsupported platforms.
+    #[inline]
+    pub fn prefetch(&self, index: usize) {
+        if let ProteinText::MmapBacked { mmap, data_offset, .. } = self {
+            let byte_off = data_offset + (index * 5 / 64) * 8;
+            if byte_off + 8 <= mmap.len() {
+                prefetch_read(&mmap[byte_off] as *const u8);
+            }
+        }
+    }
+
 }
 
 impl WriteBinary for ProteinText {