Skip to content

ProCraft for Android: An Android native painting app written in Rust

Rust

perf(gpu): a remake lets go only what its parts need room for

Joshc2225e99da3c
diff --git a/crates/gpu/src/canvas.rs b/crates/gpu/src/canvas.rs
index 0494962..f481344 100644
--- a/crates/gpu/src/canvas.rs
+++ b/crates/gpu/src/canvas.rs
@@ -4102,10 +4102,24 @@ impl Canvas {
}
/// Lets go of the textures of layers unchanged since parked (their compressed copies kept),
- /// but those in `keep`.
+ /// but those in `keep`, as far as the next part of a remake wants room.
fn let_go_clean(&mut self, keep: &HashSet<LayerId>) {
- let parked = &self.parked;
- self.layers.retain(|id, _| keep.contains(id) || !parked.contains_key(id));
+ // only as many as the next part wants room for, needed least lately first: layers that
+ // fit stay (letting many textures go at once holds a frame up)
+ let most = self.most_resident();
+ let wanted = most.saturating_sub(LET_GO_ROOM);
+ if self.layers.len() <= wanted {
+ return;
+ }
+ let mut clean: Vec<LayerId> =
+ self.layers.keys().filter(|id| !keep.contains(*id) && self.parked.contains_key(*id)).copied().collect();
+ clean.sort_by_key(|id| self.needed_at.get(id).copied().unwrap_or(0));
+ for id in clean {
+ if self.layers.len() <= wanted {
+ break;
+ }
+ self.layers.remove(&id);
+ }
}
/// Sends the work recorded so far (with its uniforms), going on with a new encoder.
@@ -6017,6 +6031,10 @@ struct Caches {
const MOST_PARK_READS: usize = 4;
const PARK_SLICE: std::time::Duration = std::time::Duration::from_millis(6);
+/// The room (in layers' textures) a remake keeps free for its next part, letting go of the
+/// layers it brought back only so far.
+const LET_GO_ROOM: usize = 2 * MOST_PART_ITEMS;
+
/// The most items a part of a remake composites before it is sent (and the time looked at).
const MOST_PART_ITEMS: usize = 8;
diff --git a/crates/gpu/tests/layers.rs b/crates/gpu/tests/layers.rs
index c451caf..93894d2 100644
--- a/crates/gpu/tests/layers.rs
+++ b/crates/gpu/tests/layers.rs
@@ -889,3 +889,39 @@ fn layers_uploaded_with_their_copies_are_let_go_without_reading_them_back() {
assert_eq!(&t.canvases[0].read_layer(&gpu, *id).unwrap(), px, "{id:?} as uploaded");
}
}
+
+#[test]
+fn a_remake_lets_go_only_what_its_parts_need_room_for() {
+ let Some((gpu, _, _)) = setup() else { return };
+ let mut doc = Document::new(W, W);
+ for _ in 0..39 {
+ doc.add_layer();
+ }
+ let ids: Vec<LayerId> = doc.layers().iter().map(|l| l.id).collect();
+ let pixels: Vec<Vec<u8>> = (0..ids.len())
+ .map(|i| {
+ let mut px = vec![0u8; (W * W * 4) as usize];
+ let (y, x0) = (i / 8 * 3 + 1, i % 8 * 2);
+ for x in x0..x0 + 3 {
+ let o = (y * W as usize + x) * 4;
+ px[o..o + 4].copy_from_slice(&[(i * 6) as u8, 200 - (i * 4) as u8, 90, 255]);
+ }
+ px
+ })
+ .collect();
+ let docs = [doc.clone(), doc];
+ let canvases = [Canvas::new(&gpu, &docs[0]).unwrap(), Canvas::new(&gpu, &docs[1]).unwrap()];
+ let mut t = Twins { docs, canvases };
+ // room for 30 of the 40, every one uploaded with its compressed copy: the caches are remade
+ // (40 needed), and of the clean textures only what the parts need room for goes
+ t.canvases[0].set_resident_budget(30 * u64::from(W * W * 4));
+ for (id, px) in ids.iter().zip(&pixels) {
+ let ready = procraft_gpu::ReadyToPark::of(px, W, W);
+ t.canvases[0].upload_layer_kept(&gpu, *id, px, ready).unwrap();
+ t.canvases[1].upload_layer(&gpu, *id, px).unwrap();
+ }
+ t.same(&gpu, 2, "opened");
+ assert!(t.canvases[0].last_remake().is_some(), "remade");
+ let parked = t.canvases[0].parked_layers();
+ assert!(parked <= 26, "parked {parked}: most that fit stay");
+}