perf(graph): avoid duplicate pathname stat and time segment opens

crates/tracedecay-code-index/src/production/graph_page_store.rs

@@ -1,7 +1,7 @@
 //! Independently readable code-graph output pages.
 
 use std::fs::File;
-use std::io::{Read, Seek, SeekFrom, Write};
+use std::io::{BufReader, Read, Seek, SeekFrom, Write};
 use std::path::Path;
 
 use serde::{Deserialize, Serialize};
@@ -15,6 +15,7 @@ use super::{
 
 const CODE_GRAPH_PAGE_STORE_MAGIC_V1: &[u8; 8] = b"TDGRAPH1";
 const CODE_GRAPH_PAGE_STORE_REVISION_V1: u32 = 1;
+const CODE_GRAPH_HEADER_READ_BYTES: usize = 64 * 1024;
 
 fn store_error(context: &str, error: impl std::fmt::Display) -> CodeIndexProductionErrorV1 {
     CodeIndexProductionErrorV1::Contract(format!("code graph page store {context}: {error}"))
@@ -254,9 +255,18 @@ fn read_attachment_bytes(
     Ok(encoded)
 }
 
+#[tracing::instrument(
+    name = "code_index.graph.page_store.decode_header",
+    level = "trace",
+    skip_all
+)]
 fn decode_attachment_header(
     reader: impl Read,
 ) -> Result<CodeGraphPageStoreHeaderV1, CodeIndexProductionErrorV1> {
+    // serde_json does not buffer reader input. Keep the caller's header-only
+    // Take inside the buffer so refills neither issue one file read per byte
+    // nor consume page payloads that belong to subsequent reads.
+    let reader = BufReader::with_capacity(CODE_GRAPH_HEADER_READ_BYTES, reader);
     serde_json::from_reader(reader).map_err(|error| store_error("header decode", error))
 }
 
@@ -434,6 +444,21 @@ mod tests {
         }
     }
 
+    struct CountedFileReader {
+        file: File,
+        calls: usize,
+        bytes_read: u64,
+    }
+
+    impl Read for CountedFileReader {
+        fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
+            self.calls += 1;
+            let read = self.file.read(buffer)?;
+            self.bytes_read += read as u64;
+            Ok(read)
+        }
+    }
+
     fn fixture_page() -> PersistedCodeGraphPageV1 {
         let occurrence = FileOccurrenceId::new("file.fixture.0").expect("file occurrence");
         PersistedCodeGraphPageV1 {
@@ -511,6 +536,86 @@ mod tests {
         );
     }
 
+    #[test]
+    fn real_attachment_header_batches_reads_and_preserves_page_boundaries() {
+        let scratch = tempfile::tempdir().expect("scratch");
+        let path = scratch.path().join("many-pages");
+        let generation =
+            CodeGenerationId::new("generation.v1.fixture.00000001.aaaaaaaa").expect("generation");
+        let pages = (0..256_u32)
+            .map(|index| {
+                let mut page = fixture_page();
+                page.file.file_occurrence_id =
+                    FileOccurrenceId::new(format!("file.fixture.{index}")).unwrap();
+                page.file.logical_path = format!("src/module_{index:04}.rs");
+                page
+            })
+            .collect::<Vec<_>>();
+        let descriptors = pages
+            .iter()
+            .enumerate()
+            .map(|(index, page)| {
+                let mut descriptor = descriptor_with_decode_bytes(page, |size| size * 2);
+                descriptor.file_key = u32::try_from(index).unwrap();
+                descriptor
+            })
+            .collect::<Vec<_>>();
+        let mut writer =
+            CodeGraphPageStoreWriterV1::create(&path, &generation, PROJECTOR, &descriptors)
+                .expect("create real attachment");
+        for (descriptor, page) in descriptors.iter().zip(&pages) {
+            writer.write_page(descriptor, page).expect("write page");
+        }
+        writer.finish().expect("finish real attachment");
+
+        let mut file = File::open(&path).unwrap();
+        let mut prefix = [0_u8; 16];
+        file.read_exact(&mut prefix).unwrap();
+        let header_size = u64::from_le_bytes(prefix[8..].try_into().unwrap());
+        assert!(header_size > CODE_GRAPH_HEADER_READ_BYTES as u64);
+        let mut reader = CountedFileReader {
+            file,
+            calls: 0,
+            bytes_read: 0,
+        };
+        let header = decode_attachment_header((&mut reader).take(header_size)).unwrap();
+        assert_eq!(header.generation, generation);
+        assert_eq!(header.pages, descriptors);
+        assert_eq!(reader.bytes_read, header_size);
+        assert_eq!(reader.file.stream_position().unwrap(), 16 + header_size);
+        let read_bound = header_size.div_ceil(CODE_GRAPH_HEADER_READ_BYTES as u64) + 1;
+        assert!(reader.calls > 1, "the header must span real file reads");
+        assert!(
+            reader.calls as u64 <= read_bound,
+            "header decoding made {} file reads for {header_size} bytes",
+            reader.calls
+        );
+
+        // A positive read control observes the next page, not buffered data
+        // lost past the header boundary when its reader is dropped.
+        let header_reads = reader.calls;
+        let mut first_page_byte = [0_u8; 1];
+        reader.read_exact(&mut first_page_byte).unwrap();
+        assert_eq!(first_page_byte, [b'{']);
+        assert_eq!(reader.calls, header_reads + 1);
+        reader.file.seek(SeekFrom::Start(16)).unwrap();
+        assert!(decode_attachment_header((&mut reader).take(header_size - 1)).is_err());
+        assert_eq!(reader.file.stream_position().unwrap(), 16 + header_size - 1);
+        drop(reader);
+
+        let mut store = FileCodeGraphPageStoreV1::open(&path, PROJECTOR)
+            .expect("open the production attachment")
+            .expect("current revision");
+        assert_eq!(store.pages(), descriptors.as_slice());
+        for (descriptor, page) in descriptors.iter().zip(&pages) {
+            let recovered = store.read_page(descriptor).expect("verify every page");
+            assert_eq!(
+                serde_json::to_vec(&recovered).unwrap(),
+                serde_json::to_vec(page).unwrap()
+            );
+        }
+    }
+
     #[test]
     fn opening_refuses_a_page_larger_than_its_admitted_decode_bytes() {
         let scratch = tempfile::tempdir().expect("scratch");