pagebench: fixup after is_rel_block_key changes in #6266

PR #6266 broke the getpage_latest_lsn benchmark.

Before this patch, we'd fail with

```
not implemented: split up range
```

because `r.start = rel size key` and `r.end = rel size key + 1`.

libs/pageserver_api/src/key.rs

@@ -77,6 +77,11 @@ impl Key {
         key
     }
 
+    pub fn sub_unoptimized_checked_panicking(&self, x: u32) -> Key {
+        let key = self.to_i128();
+        Self::from_i128(key.checked_sub(x.into()).unwrap())
+    }
+
     pub fn from_slice(b: &[u8]) -> Self {
         Key {
             field1: b[0],
@@ -141,6 +146,7 @@ impl Key {
     }
 }
 
+#[inline(always)]
 pub fn is_rel_block_key(key: &Key) -> bool {
     key.field1 == 0x00 && key.field4 != 0 && key.field6 != 0xffffffff
 }

libs/pageserver_api/src/keyspace.rs

@@ -114,10 +114,12 @@ impl KeySpaceAccum {
         }
     }
 
+    #[inline(always)]
     pub fn add_key(&mut self, key: Key) {
         self.add_range(singleton_range(key))
     }
 
+    #[inline(always)]
     pub fn add_range(&mut self, range: Range<Key>) {
         match self.accum.as_mut() {
             Some(accum) => {

pageserver/pagebench/src/cmd/getpage_latest_lsn.rs

@@ -3,6 +3,7 @@ use futures::future::join_all;
 use pageserver::pgdatadir_mapping::key_to_rel_block;
 use pageserver::repository;
 use pageserver_api::key::is_rel_block_key;
+use pageserver_api::keyspace::KeySpaceAccum;
 use pageserver_api::models::PagestreamGetPageRequest;
 
 use utils::id::TenantTimelineId;
@@ -116,31 +117,26 @@ async fn main_impl(
                     .keyspace(timeline.tenant_id, timeline.timeline_id)
                     .await?;
                 let lsn = partitioning.at_lsn;
-
-                let ranges = partitioning
-                    .keys
-                    .ranges
-                    .iter()
-                    .filter_map(|r| {
-                        let start = r.start;
-                        let end = r.end;
-                        // filter out non-relblock keys
-                        match (is_rel_block_key(&start), is_rel_block_key(&end)) {
-                            (true, true) => Some(KeyRange {
-                                timeline,
-                                timeline_lsn: lsn,
-                                start: start.to_i128(),
-                                end: end.to_i128(),
-                            }),
-                            (true, false) | (false, true) => {
-                                unimplemented!("split up range")
-                            }
-                            (false, false) => None,
+                let mut filtered = KeySpaceAccum::new();
+                // let's hope this is inlined and vectorized...
+                // TODO: turn this loop into a is_rel_block_range() function.
+                for r in partitioning.keys.ranges.iter() {
+                    let mut i = r.start;
+                    while i != r.end {
+                        if is_rel_block_key(&i) {
+                            filtered.add_key(i);
                         }
-                    })
-                    .collect::<Vec<_>>();
+                        i = i.next();
+                    }
+                }
+                let filtered = filtered.to_keyspace();
 
-                anyhow::Ok(ranges)
+                anyhow::Ok(filtered.ranges.into_iter().map(move |r| KeyRange {
+                    timeline,
+                    timeline_lsn: lsn,
+                    start: r.start.to_i128(),
+                    end: r.end.to_i128(),
+                }))
             }
         });
     }
@@ -256,6 +252,7 @@ async fn main_impl(
                             let r = &ranges[weights.sample(&mut rng)];
                             let key: i128 = rng.gen_range(r.start..r.end);
                             let key = repository::Key::from_i128(key);
+                            assert!(is_rel_block_key(&key));
                             let (rel_tag, block_no) = key_to_rel_block(key)
                                 .expect("we filter non-rel-block keys out above");
                             PagestreamGetPageRequest {