fix(bench): stabilize random access timing modes (#9631)

PR #9385 added an OS cache drop before each random-access benchmark
combination. That change exposed page-cache state in cached mode. It
caused large run-to-run variance, especially for Lance
`feature-vectors/correlated`.

This PR defines the two random-access modes explicitly. Cached mode
performs a one-second untimed warm-up before measurements. The warm-up
establishes a consistent cached baseline after each OS cache drop.

Reopen mode includes file open and metadata parsing inside every timed
iteration. Both modes prepare missing benchmark data before timing. This
also fixes `-footer` measurements that previously excluded their
advertised open cost.

---------

Signed-off-by: Will Manning <will@willmanning.io>

Author: lwwmanning

benchmarks/random-access-bench/README.md

@@ -17,8 +17,9 @@ Two access patterns are generated with a fixed seed (see [`src/main.rs`](./src/m
   simulating lookups with no locality.
 
 Each pattern runs over four datasets (`taxi`, `feature-vectors`, `nested-lists`,
-`nested-structs`) in Arrow IPC, Parquet, Lance, and Vortex. Each format uses a cached open file
-handle and a per-lookup reopen mode. CI drives the full matrix via
+`nested-structs`) in Arrow IPC, Parquet, Lance, and Vortex. Cached mode performs a one-second
+untimed warm-up, then reuses the open file handle. Reopen mode includes file open and metadata
+work in each timed iteration. CI drives the full matrix via
 [`scripts/random-access-split.py`](../../scripts/random-access-split.py).
 
 ## Running locally

benchmarks/random-access-bench/src/lib.rs

@@ -66,6 +66,9 @@ const CLUSTER_SIZE: usize = 20;
 /// Expected number of indices for the Poisson (uniform) pattern.
 const POISSON_EXPECTED_COUNT: usize = 100;
 
+/// Untimed warm-up duration for cached accessors.
+const CACHED_WARMUP_DURATION: Duration = Duration::from_secs(1);
+
 /// Generate indices for the given dataset and access pattern.
 fn generate_indices(dataset: &dyn BenchDataset, pattern: AccessPattern) -> Vec<u64> {
     let row_count = dataset.row_count();
@@ -115,7 +118,7 @@ fn generate_indices(dataset: &dyn BenchDataset, pattern: AccessPattern) -> Vec<u
 /// Controls whether the file handle is reused or reopened each iteration.
 #[derive(ValueEnum, Clone, Copy, Debug, PartialEq, Eq)]
 pub enum OpenMode {
-    /// Reuse the file handle across iterations (cached metadata).
+    /// Warm and reuse the file handle across timed iterations.
     #[clap(name = "cached")]
     Cached,
     /// Reopen the file each iteration (includes footer parsing).
@@ -132,10 +135,11 @@ pub enum OpenMode {
 
 /// Run a random access benchmark.
 ///
-/// Runs the take operation repeatedly until the time limit is reached,
-/// collecting timing for each run. When `reopen` is true, the accessor is
-/// recreated from scratch before each iteration so that file metadata
-/// parsing is included in the timing.
+/// Runs the take operation repeatedly until the time limit is reached and
+/// collects timing for each run. Cached mode performs an untimed warm-up first
+/// so that host page-cache state does not affect the recorded measurements.
+/// Both modes prepare the format file before timing starts. Reopen mode creates
+/// the accessor inside each timed iteration.
 #[expect(clippy::too_many_arguments)]
 async fn benchmark_random_access(
     dataset: &dyn BenchDataset,
@@ -148,23 +152,35 @@ async fn benchmark_random_access(
     reopen: bool,
 ) -> Result<RandomAccessRun> {
     let time_limit = Duration::from_secs(time_limit_secs);
-    let overall_start = Instant::now();
     let mut runs = Vec::new();
-    let mut accessor = open_accessor(dataset, format).await?;
+    let prepared_accessor = open_accessor(dataset, format).await?;
+    let cached_accessor = (!reopen).then_some(prepared_accessor);
+
+    if let Some(accessor) = &cached_accessor {
+        let warmup_start = Instant::now();
+        loop {
+            drop(accessor.take(indices).await?);
+            if warmup_start.elapsed() >= CACHED_WARMUP_DURATION {
+                break;
+            }
+        }
+    }
+
+    let overall_start = Instant::now();
 
     loop {
         let start = Instant::now();
-        let arr = accessor.take(indices).await?;
+        let arr = if let Some(accessor) = &cached_accessor {
+            accessor.take(indices).await?
+        } else {
+            open_accessor(dataset, format).await?.take(indices).await?
+        };
         runs.push(start.elapsed());
         drop(arr);
 
         if overall_start.elapsed() >= time_limit {
             break;
         }
-
-        if reopen {
-            accessor = open_accessor(dataset, format).await?;
-        }
     }
 
     let timing = TimingMeasurement {