#[derive(Debug)]
pub(super) struct Ahead {
first: usize,
hi: u64,
to: usize,
bytes: u64,
}
impl Ahead {
pub(super) fn new(first: usize, hi: u64) -> Self {
Self {
first,
hi,
to: 0,
bytes: 0,
}
}
pub(super) fn before(
&mut self,
k: usize,
at: u64,
declared: impl Fn(usize) -> Option<u64>,
) -> u64 {
let own = declared(k).unwrap_or(0);
if self.to > k {
self.bytes = self.bytes.saturating_sub(own);
} else {
(self.to, self.bytes) = (k + 1, 0);
}
let most = k.saturating_sub(self.first);
while self.to - (k + 1) < most
&& at.saturating_add(own).saturating_add(self.bytes) < self.hi
&& let Some(d) = declared(self.to)
{
self.bytes = self.bytes.saturating_add(d);
self.to += 1;
}
self.bytes
}
}
#[cfg(test)]
mod tests {
use super::Ahead;
const K: u64 = 64 << 10;
#[test]
fn it_holds_as_many_blocks_as_the_run_does() {
let sizes = [K; 12];
let declared = |i: usize| sizes.get(i).copied();
let mut a = Ahead::new(0, 12 * K);
let got: Vec<u64> = (0..12)
.map(|k| a.before(k, k as u64 * K, declared) / K)
.collect();
assert_eq!(got, [0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0]);
}
#[test]
fn rows_that_declare_nothing_are_read_ahead_no_further() {
let sizes = [0_u64; 1000];
let declared = |i: usize| sizes.get(i).copied();
let mut a = Ahead::new(3, u64::MAX);
for k in 3..100 {
assert_eq!(a.before(k, 0, declared), 0);
assert_eq!(a.to, 2 * k - 3 + 1, "{k}");
}
}
#[test]
fn nothing_past_the_reads_end_is_read_ahead() {
let sizes = [K; 16];
let declared = |i: usize| sizes.get(i).copied();
let mut a = Ahead::new(0, 8 * K);
let got: Vec<u64> = (1..8)
.map(|k| a.before(k, k as u64 * K, declared) / K)
.collect();
assert_eq!(got, [1, 2, 3, 3, 2, 1, 0]);
}
}