856f865cf98d
spill.rs
//! Scratch disk: tiles over the budget go to disk and come back unchanged.
//!
//! One test function: the spill manager is process-wide, so its steps must not interleave.
use photocraft_color::{ColorMode, PixelFormat, SampleType};
use photocraft_geom::{Rect, TILE_SIZE, TileCoord};
use photocraft_raster::{Surface, spill};
const TILE_BYTES: usize = (TILE_SIZE * TILE_SIZE) as usize * 4;
fn rgba8() -> PixelFormat {
PixelFormat { mode: ColorMode::Rgb, sample: SampleType::U8, alpha: true }
}
/// Incompressible bytes, different per tile and per seed.
fn noise(seed: u32, len: usize) -> Vec<u8> {
let mut x = seed.wrapping_mul(2_654_435_761).max(1);
(0..len)
.map(|_| {
x ^= x << 13;
x ^= x >> 17;
x ^= x << 5;
x as u8
})
.collect()
}
/// A surface of `n × 1` tiles of noise; tile `i` holds `noise(seed + i)`.
fn surface(seed: u32, n: i32) -> Surface {
let mut s = Surface::new(rgba8());
for i in 0..n {
let r = Rect::from_xywh(i * TILE_SIZE, 0, TILE_SIZE as u32, TILE_SIZE as u32);
s.write_interleaved(r, &noise(seed + i as u32, TILE_BYTES));
}
s
}
fn check(s: &Surface, seed: u32, n: i32) {
for i in 0..n {
let t = s.tile(TileCoord { tx: i, ty: 0 }).unwrap();
assert!(*t.bytes() == *noise(seed + i as u32, TILE_BYTES), "tile {i} of seed {seed} changed");
}
}
#[test]
fn tiles_spill_and_come_back() {
let _scratch = crate::lock(&crate::SCRATCH);
let dir = std::env::temp_dir().join(format!("photocraft-spill-test-{}", std::process::id()));
let budget = 8 * TILE_BYTES;
spill::configure(Some(&dir), budget).unwrap();
assert!(spill::enabled());
// 1. Over budget: the oldest tiles go to disk, resident memory drops to the budget.
let a = surface(1, 32);
let b = surface(1000, 32);
spill::settle();
let st = spill::stats();
assert!(st.resident_bytes <= budget, "resident {} > budget {budget}", st.resident_bytes);
assert!(st.evictions >= 48, "only {} evictions", st.evictions);
assert!(st.scratch_bytes > 0 && st.last_error.is_none(), "{st:?}");
// 2. Every pixel reads back exactly (CRC-checked, LZ4 round trip), through every reader.
check(&a, 1, 32);
check(&b, 1000, 32);
assert!(spill::stats().reloads > 0);
let mut row = vec![[0u8; 4]; TILE_SIZE as usize];
a.read_rgba8_into(Rect::from_xywh(5 * TILE_SIZE, 7, TILE_SIZE as u32, 1), &mut row);
let want = noise(6, TILE_BYTES);
let off = 7 * TILE_SIZE as usize * 4;
assert!(row.iter().flatten().eq(want[off..off + TILE_SIZE as usize * 4].iter()));
// Upstream's fallible readers and clones must reload evicted storage too.
spill::settle();
let rect = Rect::from_xywh(0, 0, TILE_SIZE as u32, TILE_SIZE as u32);
assert_eq!(a.try_to_interleaved(rect).unwrap(), noise(1, TILE_BYTES));
assert_eq!(a.try_read_region(rect).unwrap(), a.read_region(rect));
let copied = a.tile(TileCoord::new(0, 0)).unwrap().try_clone().unwrap();
assert_eq!(&*copied.try_bytes().unwrap(), &noise(1, TILE_BYTES));
drop(copied);
// 3. Copy-on-write still works on spilled tiles: the clone changes, the original doesn't.
spill::settle();
let mut c = a.clone();
c.fill_rect(Rect::from_xywh(0, 0, 10, 10), &[1.0, 0.0, 0.0, 1.0]);
assert_eq!(c.pixel(3, 3), vec![1.0, 0.0, 0.0, 1.0]);
check(&a, 1, 32);
spill::settle();
// The edit survives its own eviction (the stale disk copy was released, a new one written).
assert_eq!(c.pixel(3, 3), vec![1.0, 0.0, 0.0, 1.0]);
check(&a, 1, 32);
// 4. Parallel readers of spilled tiles all see the right bytes.
spill::settle();
std::thread::scope(|scope| {
for k in 0..8 {
let (a, b) = (&a, &b);
scope.spawn(move || {
for round in 0..4 {
let (s, seed) = if (k + round) % 2 == 0 { (a, 1) } else { (b, 1000) };
check(s, seed, 32);
}
});
}
});
// 5. Dropping everything frees memory and scratch space.
drop((a, b, c));
let st = spill::stats();
assert_eq!(st.scratch_bytes, 0, "scratch extents leaked: {st:?}");
// 6. Off: nothing more is evicted, and the budget no longer applies.
spill::configure(None, 0).unwrap();
assert!(!spill::enabled());
let before = spill::stats().evictions;
let d = surface(5000, 32);
assert_eq!(spill::stats().evictions, before);
check(&d, 5000, 32);
drop(d);
// 7. Encoded bytes and COW edits survive eviction at every supported depth.
for sample in [SampleType::U8, SampleType::U16, SampleType::F32] {
let fmt = PixelFormat { mode: ColorMode::Rgb, sample, alpha: true };
let len = (TILE_SIZE * TILE_SIZE) as usize * fmt.bytes_per_pixel();
spill::configure(Some(&dir), len * 2).unwrap();
let mut s = Surface::new(fmt);
for i in 0..12 {
s.tile_mut(TileCoord::new(i, 0)).bytes_mut().copy_from_slice(&noise(8000 + i as u32, len));
}
let original = s.clone();
spill::settle();
assert!(spill::stats().resident_bytes <= len * 2);
s.fill_rect(Rect::from_xywh(0, 0, 4, 4), &[1.0, 0.0, 0.0, 1.0]);
spill::settle();
assert_eq!(s.pixel(1, 1), vec![1.0, 0.0, 0.0, 1.0]);
for i in 0..12 {
assert_eq!(&*original.tile(TileCoord::new(i, 0)).unwrap().bytes(), &noise(8000 + i as u32, len));
}
let mut converted = [[0; 4]; 4];
s.read_rgba8_into(Rect::from_xywh(0, 0, 4, 1), &mut converted);
assert_eq!(converted, [[255, 0, 0, 255]; 4]);
}
// A tiny budget must still allow a pinned reader to finish instead of evicting itself.
spill::configure(Some(&dir), 1).unwrap();
let tiny = surface(9000, 2);
spill::settle();
check(&tiny, 9000, 2);
drop(tiny);
spill::configure(None, 0).unwrap();
let _ = std::fs::remove_dir_all(&dir);
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.