From 3328c69f1d8514c04d5f2b1f2c109fd548d42772 Mon Sep 17 00:00:00 2001 From: matrixarkai Date: Sun, 15 Nov 2026 11:19:28 -0800 Subject: [PATCH] A whole-object read of an appended object reads the chunk once per run of extents An object built by appends has one extent per append, and a whole-object read paid a full chunk-range read for each of them: admission, the page map, the head stats and a replica vote that hashes what it returns. A 400 KB write-ahead log made of a few thousand appends therefore read at about 15 MB/s, against 85-135 MB/s for an object of the same size written in one request. Consecutive extents of one chunk that sit close together are now read as one span and sliced apart, so the fixed price is paid once per run instead of once per extent. Two objects appended in turn share a chunk and interleave, so the extents of one are separated by the other's; a span reads across up to 4 KiB between two extents and at most 1 MiB in all. Only taken when the caller set no payload and no chunk-count budget, because a span reads the bytes between two extents and a budget is a promise about what a read touches. A span that cannot be read falls back to one read per extent, so a read of an object never depends on the bytes of its neighbour. No durable byte changes. Measured, release door, same workload either side, A/B in both orders: whole-object GET, one client 89 / 88 qps -> 360 / 306 qps whole-object GET throughput ~20 MB/s -> 70-82 MB/s write latency and replica read latency unchanged At the store level in a debug build, 4000 extents read in 31 ms against 67 ms and 43 ms against 74 ms in the reversed order. 200 interleaved-append extents are served by 11 chunk reads (204 with the span disabled). Tests: the bytes read equal the bytes appended, including after the interleaved neighbour is deleted; the read-count assertion fails with the span disabled; an ignored bench prices the read at three object sizes. Co-Authored-By: Claude Sonnet 5.5 --- src/object_store_regression_tests.rs | 93 ++++++++++++++++++ .../core/raft_apply_persistence/extent_io.rs | 98 +++++++++++++++++++ 2 files changed, 191 insertions(+) diff --git a/src/object_store_regression_tests.rs b/src/object_store_regression_tests.rs index 0d71692e..44ab25b3 100644 --- a/src/object_store_regression_tests.rs +++ b/src/object_store_regression_tests.rs @@ -55785,3 +55785,96 @@ fn an_append_leaves_every_cached_range_of_the_page_alone() { "the index lost cached ranges that no write intersected" ); } + +fn span_read_options() -> StoreOptions { + StoreOptions { + chunk_size: 1 << 20, + max_extent_bytes: 1 << 12, + page_size: 1 << 12, + ..test_options() + } +} + +/// Two objects appended in turn share a chunk, so each one's extents are separated by the +/// other's. The oracle is the bytes the test appended, not anything the store reports. +fn interleaved_appends(store: &mut MatrixObjectStore, rounds: usize) -> (Vec, Vec) { + store.create_bucket("bucket").unwrap(); + let (mut a, mut b) = (Vec::new(), Vec::new()); + for round in 0..rounds { + let piece_a: Vec = (0..90).map(|i| (round * 7 + i) as u8).collect(); + let piece_b: Vec = (0..130).map(|i| (round * 13 + i + 5) as u8).collect(); + store + .append_object("bucket", "a", piece_a.clone(), "application/octet-stream") + .unwrap(); + store + .append_object("bucket", "b", piece_b.clone(), "application/octet-stream") + .unwrap(); + a.extend_from_slice(&piece_a); + b.extend_from_slice(&piece_b); + } + (a, b) +} + +#[test] +fn a_whole_object_read_of_interleaved_appends_reads_the_chunk_once_per_span() { + let mut store = MatrixObjectStore::new(span_read_options()).unwrap(); + let (a, b) = interleaved_appends(&mut store, 200); + let extents = store.head_object("bucket", "a").unwrap().extents.len(); + assert!(extents >= 200, "one extent per append, got {extents}"); + + let (read, stats) = store.get_object_with_read_stats("bucket", "a").unwrap(); + assert_eq!(read.data, a, "the bytes read are the bytes appended"); + println!("extents={extents} chunk_reads={}", stats.chunk_reads); + assert!( + (stats.chunk_reads as usize) * 4 < extents, + "{extents} extents were read with {} chunk reads: a span should serve many of them", + stats.chunk_reads + ); + assert_eq!(store.get_object("bucket", "b").unwrap().data, b); +} + +#[test] +fn a_span_read_does_not_depend_on_the_bytes_between_its_extents() { + let mut store = MatrixObjectStore::new(span_read_options()).unwrap(); + let (a, _b) = interleaved_appends(&mut store, 120); + store.delete_object("bucket", "b").unwrap(); + assert_eq!( + store.get_object("bucket", "a").unwrap().data, + a, + "deleting the neighbour left this object's own bytes readable" + ); + let (partial, _) = store + .get_object_range("bucket", "a", 1000, 5000) + .map(|o| (o.data, ())) + .unwrap(); + assert_eq!(partial, a[1000..6000].to_vec()); +} + +/// +#[test] +#[ignore] +fn bench_whole_object_read_of_appended_object() { + for rounds in [250usize, 1000, 4000] { + let mut store = MatrixObjectStore::new(StoreOptions { + chunk_size: 64 << 20, + max_extent_bytes: 1 << 16, + page_size: 1 << 20, + ..test_options() + }) + .unwrap(); + let (a, _b) = interleaved_appends(&mut store, rounds); + let extents = store.head_object("bucket", "a").unwrap().extents.len(); + let reps = 20usize; + let start = std::time::Instant::now(); + for _ in 0..reps { + let read = store.get_object("bucket", "a").unwrap(); + assert_eq!(read.data.len(), a.len()); + } + let per = start.elapsed().as_secs_f64() * 1e3 / reps as f64; + println!( + "rounds={rounds} extents={extents} bytes={} get_ms={per:.3} MB/s={:.1}", + a.len(), + a.len() as f64 / 1048576.0 / (per / 1e3) + ); + } +} diff --git a/src/store/core/raft_apply_persistence/extent_io.rs b/src/store/core/raft_apply_persistence/extent_io.rs index 5986b206..eabcd732 100644 --- a/src/store/core/raft_apply_persistence/extent_io.rs +++ b/src/store/core/raft_apply_persistence/extent_io.rs @@ -331,6 +331,23 @@ impl MatrixObjectStore { let mut stats = ChunkReadStats::default(); let mut chunk_reads = 0u64; let mut object_cursor = 0u64; + // A SPAN READ SERVES SEVERAL EXTENTS WITH ONE QUORUM READ. Every extent read pays a whole + // chunk-range read -- admission, the page map, the head stats and a replica vote that + // hashes what it returns -- and an object built by appends has one extent per append, so + // a whole-object read of it was paying that fixed price once per append. It is only + // taken when the caller set no payload or chunk-count budget, because a span reads the + // bytes between two extents and a budget is a promise about what a read touches. + let spans_allowed = max_payload_bytes == 0 && max_chunk_read_count == 0; + let mut pending: Vec<(ObjectExtent, u64, u64)> = Vec::new(); + let mut pending_end = 0u64; + macro_rules! flush_pending { + () => { + if !pending.is_empty() { + let batch = std::mem::take(&mut pending); + self.read_extent_batch(&batch, &mut out, &mut stats, &mut chunk_reads)?; + } + }; + } for extent in extents { let extent_start = object_cursor; let extent_end = object_cursor.checked_add(extent.length()).ok_or_else(|| { @@ -344,6 +361,24 @@ impl MatrixObjectStore { let read_end = range_end.min(extent_end); let local_offset = read_start - extent_start; let local_len = read_end - read_start; + if spans_allowed { + let abs = extent.offset() + local_offset; + let joins = match pending.first() { + Some((first, first_abs, _)) => { + first.chunk_id == extent.chunk_id + && abs >= pending_end + && abs - pending_end <= SPAN_MAX_GAP_BYTES + && abs + local_len - *first_abs <= SPAN_MAX_BYTES + } + None => true, + }; + if !joins { + flush_pending!(); + } + pending.push((extent.clone(), abs, local_len)); + pending_end = abs + local_len; + continue; + } let remaining_budget = if max_payload_bytes == 0 { 0 } else { @@ -365,6 +400,69 @@ impl MatrixObjectStore { merge_page_read_stats(&mut stats, read_stats); out.extend_from_slice(&payload); } + flush_pending!(); Ok((out, stats)) } + + /// Read one batch of consecutive extents of one chunk with a single chunk-range read when + /// that is possible, and one read per extent when it is not. + /// + /// The batch is `(extent, absolute chunk offset, length)` in object order. A batch of one, + /// and a span that cannot be read, take the per-extent path -- the bytes between two extents + /// belong to another object that may since have been discarded, and a failed read of them + /// must not fail a read of this object, whose own bytes are all still there. + fn read_extent_batch( + &self, + batch: &[(ObjectExtent, u64, u64)], + out: &mut Vec, + stats: &mut ChunkReadStats, + chunk_reads: &mut u64, + ) -> Result<(), ObjectError> { + if batch.len() > 1 { + let span_start = batch[0].1; + let (_, last_abs, last_len) = &batch[batch.len() - 1]; + let span_len = last_abs + last_len - span_start; + if let Ok((span, read_stats)) = self.chunk_service.read_chunk_range_bounded_by_chunks( + &batch[0].0.chunk_id, + span_start, + span_len, + 0, + 0, + ) { + let sliced = batch.iter().all(|(_, abs, len)| { + let from = abs - span_start; + usize::try_from(from + len).map_or(false, |end| end <= span.len()) + }); + if sliced { + *chunk_reads = chunk_reads.saturating_add(read_stats.chunk_reads); + merge_page_read_stats(stats, read_stats); + for (_, abs, len) in batch { + let from = (abs - span_start) as usize; + out.extend_from_slice(&span[from..from + *len as usize]); + } + return Ok(()); + } + } + } + for (extent, abs, len) in batch { + let (payload, read_stats) = self.chunk_service.read_chunk_range_bounded_by_chunks( + &extent.chunk_id, + *abs, + *len, + 0, + 0, + )?; + *chunk_reads = chunk_reads.saturating_add(read_stats.chunk_reads); + merge_page_read_stats(stats, read_stats); + out.extend_from_slice(&payload); + } + Ok(()) + } } + +/// The widest gap between two extents of one chunk that a span read will read across. Appends to +/// two objects that share a chunk interleave, so the neighbours of an object's extents are +/// usually another object's appends, a few hundred bytes each. +const SPAN_MAX_GAP_BYTES: u64 = 4096; +/// The longest span one read covers: a page, which is what one replica read already serves. +const SPAN_MAX_BYTES: u64 = 1 << 20;