perf(provider): lazily refresh static file jar cache

Pass the writer's live segment header into static file index updates so the steady-state append path can reuse in-memory range metadata instead of reloading the jar from disk on every commit.

Only reopen and remap a jar when that segment and range are already cached by a reader, while preserving the disk-backed fallback for callers that update indexes without a live writer header. Add a regression test that covers lazy uncached updates and cache refresh for an active reader.

Amp-Thread-ID: https://ampcode.com/threads/T-019df228-9b31-759c-9b1d-a426d6bb6808
Co-authored-by: Amp <[email protected]>

Author: amp

crates/storage/provider/src/providers/static_file/manager.rs

@@ -1070,8 +1070,7 @@ impl<N: NodePrimitives> StaticFileProvider<N> {
                 {
                     segment_header.clone()
                 } else {
-                    let jar =
-                        NippyJar::<SegmentHeader>::load(&path).map_err(ProviderError::other)?;
+                    let jar = NippyJar::<SegmentHeader>::load(&path).map_err(ProviderError::other)?;
                     let header = jar.user_header().clone();
                     loaded_jar = Some(jar);
                     header
@@ -1080,16 +1079,10 @@ impl<N: NodePrimitives> StaticFileProvider<N> {
                 let index = indexes
                     .entry(segment)
                     .and_modify(|index| {
-                        // Update max block
                         index.max_block = segment_max_block;
-
-                        // Update expected block range index
-
-                        // Remove all expected block ranges that are less than the new max block
                         index
                             .expected_block_ranges_by_max_block
                             .retain(|_, block_range| block_range.start() < fixed_range.start());
-                        // Insert new expected block range
                         index
                             .expected_block_ranges_by_max_block
                             .insert(fixed_range.end(), fixed_range);
@@ -1121,8 +1114,6 @@ impl<N: NodePrimitives> StaticFileProvider<N> {
                 //    this update, it would incorrectly return 0 (stale)
                 if let Some(current_block_range) = current_header.block_range() {
                     if let Some(min_block_range) = index.min_block_range.as_mut() {
-                        // delete_jar WILL ALWAYS re-initialize all indexes, so we are always
-                        // sure that current_min is always the lowest.
                         if current_block_range.start() == min_block_range.start() {
                             *min_block_range = current_block_range;
                         }
@@ -1131,22 +1122,10 @@ impl<N: NodePrimitives> StaticFileProvider<N> {
                     }
                 }
 
-                // Updates the tx index by first removing all entries which have a higher
-                // block_start than our current static file.
                 if let Some(tx_range) = current_header.tx_range() {
-                    // Current block range has the same block start as `fixed_range``, but block end
-                    // might be different if we are still filling this static file.
                     if let Some(current_block_range) = current_header.block_range() {
                         let tx_end = tx_range.end();
 
-                        // Considering that `update_index` is called when we either append/truncate,
-                        // we are sure that we are handling the latest data
-                        // points.
-                        //
-                        // Here we remove every entry of the index that has a block start higher or
-                        // equal than our current one. This is important in the case
-                        // that we prune a lot of rows resulting in a file (and thus
-                        // a higher block range) deletion.
                         if let Some(index) = index.available_block_ranges_by_max_tx.as_mut() {
                             index
                                 .retain(|_, block_range| block_range.start() < fixed_range.start());
@@ -1157,14 +1136,10 @@ impl<N: NodePrimitives> StaticFileProvider<N> {
                         }
                     }
                 } else if segment.is_tx_based() {
-                    // The unwinded file has no more transactions/receipts. However, the highest
-                    // block is within this files' block range. We only retain
-                    // entries with block ranges before the current one.
                     if let Some(index) = index.available_block_ranges_by_max_tx.as_mut() {
                         index.retain(|_, block_range| block_range.start() < fixed_range.start());
                     }
 
-                    // If the index is empty, just remove it.
                     index.available_block_ranges_by_max_tx.take_if(|index| index.is_empty());
                 }
 
@@ -1179,7 +1154,6 @@ impl<N: NodePrimitives> StaticFileProvider<N> {
                     self.map.insert(key, LoadedJar::new(jar)?);
                 }
 
-                // Delete any cached provider that no longer has an associated jar.
                 debug!(target: "providers::static_file", ?segment, "Cleaning up jar map");
                 self.map.retain(|(end, seg), _| !(*seg == segment && *end > fixed_range.end()));
             }
@@ -3048,7 +3022,9 @@ mod tests {
     use reth_db::test_utils::create_test_static_files_dir;
     use reth_static_file_types::{SegmentRangeInclusive, StaticFileSegment};
 
-    use crate::{providers::StaticFileProvider, StaticFileProviderBuilder, StaticFileWriter};
+    use crate::{
+        providers::StaticFileProvider, HeaderProvider, StaticFileProviderBuilder, StaticFileWriter,
+    };
 
     #[test]
     fn test_find_fixed_range_with_block_index() -> eyre::Result<()> {
@@ -3170,40 +3146,37 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn update_index_only_refreshes_cached_jars() -> eyre::Result<()> {
+    fn test_update_index_only_refreshes_cached_jar() -> eyre::Result<()> {
         let (static_dir, _) = create_test_static_files_dir();
-        let sf_rw: StaticFileProvider<EthPrimitives> =
+        let provider: StaticFileProvider<EthPrimitives> =
             StaticFileProviderBuilder::read_write(&static_dir).with_blocks_per_file(10).build()?;
 
-        {
-            let mut writer = sf_rw.latest_writer(StaticFileSegment::Headers)?;
-            let mut header = Header::default();
-            for number in 0..=4 {
-                header.number = number;
-                writer.append_header(&header, &BlockHash::default())?;
-            }
-            writer.commit()?;
+        let mut writer = provider.latest_writer(StaticFileSegment::Headers)?;
+        let mut header = Header::default();
+        for number in 0..=4 {
+            header.number = number;
+            writer.append_header(&header, &BlockHash::default())?;
         }
+        writer.commit()?;
 
-        assert!(sf_rw.map.is_empty(), "uncached writes should not populate the jar cache");
+        assert!(provider.map.is_empty(), "uncached updates should stay lazy");
 
-        {
-            let _provider =
-                sf_rw.get_segment_provider_for_block(StaticFileSegment::Headers, 0, None)?;
-        }
-        assert!(sf_rw.map.contains_key(&(9, StaticFileSegment::Headers)));
+        let cached =
+            provider.get_segment_provider_for_block(StaticFileSegment::Headers, 0, None)?;
+        assert_eq!(cached.header_by_number(4)?.unwrap().number, 4);
+        assert_eq!(provider.map.len(), 1, "reader access should populate the cache");
+        drop(cached);
 
-        {
-            let mut writer = sf_rw.latest_writer(StaticFileSegment::Headers)?;
-            let mut header = Header::default();
-            header.number = 5;
+        for number in 5..=6 {
+            header.number = number;
             writer.append_header(&header, &BlockHash::default())?;
-            writer.commit()?;
         }
+        writer.commit()?;
 
-        let cached = sf_rw.map.get(&(9, StaticFileSegment::Headers)).expect("cached jar exists");
-        assert_eq!(cached.user_header().block_range(), Some(SegmentRangeInclusive::new(0, 5)));
+        assert_eq!(provider.map.len(), 1, "refreshing should reuse the existing cache slot");
+        let refreshed =
+            provider.get_segment_provider_for_block(StaticFileSegment::Headers, 0, None)?;
+        assert_eq!(refreshed.header_by_number(6)?.unwrap().number, 6);
 
         Ok(())
     }