Skip to content

A modern terminal with a built-in multiplexer: close it and your sessions keep running. Run shells and tons of AI agents across your machines, then pick them up from desktop, browser, TUI and more. Written in Rust with no UI framework: interface drawn straight on the GPU. No Electron, GPUI or webview.

term: let the byte budget, not an idle timer, reclaim complete kitty images

RoversX74b64aaedbe7
diff --git a/term/src/terminalstate/kitty.rs b/term/src/terminalstate/kitty.rs
index ea9304f0..41bfc969 100644
--- a/term/src/terminalstate/kitty.rs
+++ b/term/src/terminalstate/kitty.rs
@@ -225,20 +225,10 @@ impl KittyImageState {
self.used_memory
}
- /// Evict unplaced images, oldest transmission first, until the stored
- /// bytes fit `budget`. Placed images and the most recently transmitted
- /// image are never touched.
- /// One sweep of the idle release. Anything that arrived since the last
- /// sweep -- a stored picture, or one more fragment of a transfer still
- /// being delivered -- resets the count; after `ticks_until_release`
- /// quiet sweeps the fragments of the abandoned transfer and every image
- /// no placement refers to are dropped. A frame stream that ended leaves
- /// its last frames within budget and therefore kept for as long as the
- /// pane lives; once it has been quiet this long nobody is going to
- /// place them. Placed images stay: they are content, visible on screen
- /// or further up the scrollback. The newest stored image stays too, for
- /// the same reason the budget spares it: a transmission stores now and
- /// places in a later escape. Returns the bytes released.
+ /// Release fragments of an abandoned transfer after enough quiet sweeps.
+ /// Completed images remain reusable until explicit deletion or byte-budget
+ /// eviction, regardless of whether they currently have placements.
+ /// New image data or another fragment resets the quiet count.
pub(crate) fn idle_tick(&mut self, ticks_until_release: u32) -> usize {
let transfer = (self.accumulator.len(), self.accumulated_bytes);
if self.next_seq != self.idle_seen_seq || transfer != self.idle_seen_transfer {
@@ -255,36 +245,16 @@ impl KittyImageState {
// chunks) would otherwise hold its fragments until the pane closes.
// Discard any late tail just as for an over-limit transfer. Preserve
// an existing latch, but don't arm one when no transfer was pending.
- let mut released = self.accumulated_bytes;
+ let released = self.accumulated_bytes;
self.accumulator_overflowed |= !self.accumulator.is_empty();
self.accumulator = Vec::new();
self.accumulated_bytes = 0;
self.idle_seen_transfer = (0, 0);
- let newest = self.next_seq;
- let referenced: HashSet<u32> = self.placements.keys().map(|(k, _)| *k).collect();
- let victims: Vec<u32> = self
- .id_to_data
- .keys()
- .filter(|id| !referenced.contains(id) && self.id_seq.get(id).copied() != Some(newest))
- .copied()
- .collect();
- if victims.is_empty() {
- return released;
- }
- // Removed in one pass and measured once: `evict` re-measures the
- // whole map on every call, which over a map this size is quadratic.
- let before = self.used_memory;
- for id in &victims {
- self.id_to_data.remove(id);
- self.id_seq.remove(id);
- }
- let gone: HashSet<u32> = victims.into_iter().collect();
- self.number_to_id.retain(|_, id| !gone.contains(id));
- self.recompute_used_memory();
- released += before.saturating_sub(self.used_memory);
released
}
+ /// Evict unplaced images, oldest use first, until the stored bytes fit
+ /// `budget`. Placed images and the most recently used image are spared.
pub(crate) fn prune_unreferenced(&mut self, budget: usize) {
if self.used_memory <= budget {
return;
@@ -332,7 +302,7 @@ mod prune_tests {
}
#[test]
- fn idle_ticks_release_unplaced_images_after_a_quiet_spell() {
+ fn idle_ticks_preserve_completed_images_until_budget_pressure() {
let mut state = KittyImageState::default();
let one = image(16).len();
for id in 1..=3 {
@@ -346,15 +316,15 @@ mod prune_tests {
assert_eq!(state.idle_tick(2), 0);
assert_eq!(state.idle_tick(2), 0);
assert_eq!(state.id_to_data.len(), 4, "still held");
- assert_eq!(
- state.idle_tick(2),
- 3 * one,
- "quiet long enough: the unplaced ones go"
- );
+ for _ in 0..10 {
+ assert_eq!(state.idle_tick(2), 0);
+ }
+ assert_eq!(state.id_to_data.len(), 4, "idle is not a deletion request");
+ state.prune_unreferenced(one);
assert_eq!(
state.id_to_data.keys().copied().collect::<Vec<_>>(),
vec![4],
- "the newest is still waiting to be placed"
+ "the byte budget still evicts older images"
);
assert_eq!(state.used_memory, one);
assert_eq!(state.idle_tick(2), 0, "nothing left to release");
diff --git a/term/src/test/graphics.rs b/term/src/test/graphics.rs
index 5f9ae602..7503c688 100644
--- a/term/src/test/graphics.rs
+++ b/term/src/test/graphics.rs
@@ -930,6 +930,8 @@ fn clearing_the_scrollback_and_viewport_keeps_reusable_image_data() {
let mut term = term(640, 384, true);
term.advance_bytes(XMIT_2X2);
term.advance_bytes("\x1b_Ga=p,i=1\x1b\\");
+ // A second image makes id 1 ineligible for the newest-image exemption.
+ term.advance_bytes("\x1b_Ga=T,i=2,f=32,s=2,v=2;AAAAAAAAAAAAAAAAAAAAAA==\x1b\\");
assert!(term.kitty_used_memory() > 0);
term.erase_scrollback_and_viewport();
@@ -943,6 +945,14 @@ fn clearing_the_scrollback_and_viewport_keeps_reusable_image_data() {
"clearing must remove the painted placement"
);
+ for _ in 0..4 {
+ term.idle_image_tick(2);
+ }
+ assert!(
+ term.kitty_image_data_for_id(1).is_some(),
+ "cleared image data must survive the idle sweep even when not newest"
+ );
+ assert!(term.kitty_image_data_for_id(2).is_some());
term.advance_bytes("\x1b[H");
term.advance_bytes("\x1b_Ga=p,i=1\x1b\\");
assert!(
@@ -955,6 +965,45 @@ fn clearing_the_scrollback_and_viewport_keeps_reusable_image_data() {
);
}
+#[test]
+fn deleting_one_or_all_placements_keeps_idle_image_data_reusable() {
+ for delete_placements in ["\x1b_Ga=d,d=i,i=1\x1b\\", "\x1b_Ga=d,d=a\x1b\\"] {
+ let mut term = term(640, 384, true);
+ term.advance_bytes(XMIT_2X2);
+ term.advance_bytes("\x1b_Ga=p,i=1\x1b\\");
+ term.advance_bytes("\x1b_Ga=T,i=2,f=32,s=2,v=2;AAAAAAAAAAAAAAAAAAAAAA==\x1b\\");
+ term.advance_bytes(delete_placements);
+ assert!(
+ term.screen_mut()
+ .line_mut(0)
+ .get_cell(0)
+ .and_then(|c| c.attrs().images())
+ .is_none()
+ );
+
+ for _ in 0..6 {
+ term.idle_image_tick(2);
+ }
+ assert!(term.kitty_image_data_for_id(1).is_some());
+ assert!(term.kitty_image_data_for_id(2).is_some());
+ term.advance_bytes("\x1b[H\x1b_Ga=p,i=1\x1b\\");
+ assert!(
+ term.screen_mut()
+ .line_mut(0)
+ .get_cell(0)
+ .and_then(|c| c.attrs().images())
+ .is_some(),
+ "deleting placements must not expire the reusable data: {:?}",
+ delete_placements
+ );
+
+ // Explicit data deletion still releases the image immediately.
+ term.advance_bytes("\x1b_Ga=d,d=I,i=1\x1b\\");
+ assert!(term.kitty_image_data_for_id(1).is_none());
+ assert!(term.kitty_image_data_for_id(2).is_some());
+ }
+}
+
#[test]
fn eviction_reaches_a_placement_on_the_inactive_screen() {
// Budget: two 2x2 frames. Image 1 is placed on the primary screen;