From 81990718c63eeff9ec25fda70aedd9f20bbc2861 Mon Sep 17 00:00:00 2001 From: Kovid Goyal Date: Fri, 6 Nov 2026 21:53:08 +0530 Subject: [PATCH] Speed up drawing of cells with many combining chars - Add runs of plain combining chars to a cell with a single lookup in the text cache, rather than one for each char, which also added the intermediate texts of the cell to the cache. - Also collect garbage in the text cache when starting a new line, not just when starting to draw text, as a single draw can add a great many entries, making the cache slower to use the larger it grows. - Size the hash map of the text cache for the expected number of entries after garbage collection, to avoid repeatedly rehashing it as it grows. This makes the unique multi-codepoint cells benchmark ~80% faster. The differential test of batched drawing now compares cells by content, since cells with multiple codepoints store indices into the text cache, which change as intermediate texts are no longer added to it. --- kitty/screen.c | 68 +++++++++++++++++++++++++++++++++++++++---- kitty/text-cache.c | 8 +++++ kitty_tests/screen.py | 16 ++++++++-- 3 files changed, 84 insertions(+), 8 deletions(-) diff --git a/kitty/screen.c b/kitty/screen.c index 799b82499..0005868bf 100644 --- a/kitty/screen.c +++ b/kitty/screen.c @@ -1103,6 +1103,11 @@ init_segmentation_state(Screen *self, text_loop_state *s) { static void init_text_loop_line(Screen *self, text_loop_state *s) { + // Also collect garbage in the text cache when starting a new line, not just + // when starting to draw text, as a single draw can add a great many entries, + // for example, when drawing a long stream of unique multi-codepoint cells, + // making the cache slower to use the larger it grows. + if (tc_should_gc(self->text_cache)) screen_garbage_collect_text_cache(self); linebuf_init_cells(self->linebuf, self->cursor->y, &s->cp, &s->gp); clear_intersecting_selections(self, self->cursor->y); linebuf_mark_line_dirty(self->linebuf, self->cursor->y); @@ -1300,7 +1305,8 @@ screen_garbage_collect_text_cache(Screen *self) { } static bool -add_combining_char(Screen *self, char_type ch, index_type x, index_type y) { +add_combining_chars(Screen *self, const char_type *chars, size_t num_chars, index_type x, index_type y) { + // Adds num_chars combining chars to the cell at x, y with a single lookup in the text cache CPUCell *cpu_cells = linebuf_cpu_cells_for_line(self->linebuf, y); CPUCell *cell = cpu_cells + x; if (!cell_has_text(cell) || (cell->is_multicell && cell->y)) return false; // don't allow adding combining chars to a null cell @@ -1308,8 +1314,10 @@ add_combining_char(Screen *self, char_type ch, index_type x, index_type y) { if (self->lc->count >= MAX_NUM_CODEPOINTS_PER_CELL) return false; // don't allow too many combining chars to prevent DoS attacks // must be computed before the char is changed const MulticellRows rows = cell->is_multicell ? multicell_char_rows(self, x, y) : (MulticellRows){0}; - ensure_space_for_chars(self->lc, self->lc->count + 1); - self->lc->chars[self->lc->count++] = ch; + num_chars = MIN(num_chars, MAX_NUM_CODEPOINTS_PER_CELL - self->lc->count); + ensure_space_for_chars(self->lc, self->lc->count + num_chars); + memcpy(self->lc->chars + self->lc->count, chars, num_chars * sizeof(chars[0])); + self->lc->count += num_chars; cell->ch_or_idx = tc_get_or_insert_chars(self->text_cache, self->lc); cell->ch_is_idx = true; if (cell->is_multicell) { @@ -1326,6 +1334,11 @@ add_combining_char(Screen *self, char_type ch, index_type x, index_type y) { return true; } +static bool +add_combining_char(Screen *self, char_type ch, index_type x, index_type y) { + return add_combining_chars(self, &ch, 1, x, y); +} + static bool has_multiline_cells_in_span(const CPUCell *cells, const index_type start, const index_type count) { @@ -1531,6 +1544,51 @@ map_char(Screen *self, const uint32_t ch) { return UNLIKELY(self->charset.current && ch < 256) ? self->charset.current[ch] : ch; } +static bool batched_non_ascii_draw_disabled_for_tests = false; + +static bool +is_plain_combining_char(char_type ch, GraphemeSegmentationResult seg, CharProps props) { + // A combining char that only adds to the text of a cell, see draw_combining_char() + return ch != VS15 && ch != VS16 && !(seg.grapheme_break == GBP_SpacingMark && wcwidth_std(props) > 0); +} + +static size_t +draw_combining_char_run(Screen *self, text_loop_state *s, char_type ch, CharProps props, const uint32_t *rest, size_t num_rest) { + // ch has been through grapheme segmentation, which added it to the previous + // cell. Plain combining chars directly following it are added along with it, + // with a single lookup in the text cache, rather than one for each char. + // Returns the number of chars from rest that were drawn. +#define MAX_RUN 32u + char_type run[MAX_RUN]; + size_t n = 0; + GraphemeSegmentationResult seg = s->seg; + if (!batched_non_ascii_draw_disabled_for_tests && is_plain_combining_char(ch, seg, props)) { + run[n++] = ch; + for (size_t k = 0; k < num_rest && n < MAX_RUN; k++) { + const char_type c = map_char(self, rest[k]); + const CharProps p = char_props_for(c); + if (p.is_invalid) break; + const GraphemeSegmentationResult next = grapheme_segmentation_step(seg, p); + if (!next.add_to_current_cell || !is_plain_combining_char(c, next, p)) break; + seg = next; + run[n++] = c; + } + } +#undef MAX_RUN + if (n < 2) { + draw_combining_char(self, s, ch); + return 0; + } + CPUCell *cp; + GPUCell *gp; + linebuf_init_cells(self->linebuf, s->prev.y, &cp, &gp); + index_type xpos = s->prev.x; + while (xpos && cp[xpos].is_multicell && cp[xpos].x) xpos--; + add_combining_chars(self, run, n, xpos, s->prev.y); + s->seg = seg; + return n - 1; +} + static void draw_control_char(Screen *self, text_loop_state *s, uint32_t ch) { switch (ch) { @@ -1574,8 +1632,6 @@ draw_control_char(Screen *self, text_loop_state *s, uint32_t ch) { } } -static bool batched_non_ascii_draw_disabled_for_tests = false; - static_assert(sizeof(CPUCell) == 3 * sizeof(uint32_t), "draw_non_ascii_run() needs updating"); static inline uint32_t @@ -1793,7 +1849,7 @@ draw_text_loop(Screen *self, const uint32_t *chars, size_t num_chars, text_loop_ } s->seg = grapheme_segmentation_step(s->seg, cp); if (UNLIKELY(s->seg.add_to_current_cell && s->prev.cc)) { - draw_combining_char(self, s, ch); + i += draw_combining_char_run(self, s, ch, cp, chars + i + 1, num_chars - i - 1); continue; } char_width = wcwidth_std(cp); diff --git a/kitty/text-cache.c b/kitty/text-cache.c index 3681c66b3..177e961fe 100644 --- a/kitty/text-cache.c +++ b/kitty/text-cache.c @@ -220,6 +220,10 @@ tc_gc_begin(TextCache *self) { zero_at_ptr(&self->arena); vt_cleanup(&self->map); vt_init(&self->map); + // Avoid rehashing repeatedly as the live entries are re-inserted, the live + // set of the previous collection is the best estimate of their number. + // Failing to do so is harmless, the map grows as needed. + if (self->adds_between_gcs) (void)vt_reserve(&self->map, self->adds_between_gcs); return gc; } @@ -241,6 +245,10 @@ tc_gc_end(TextCache *self, TextCacheGCData *gc) { self->adds_since_last_gc = 0; // scale with the live set so remapping cost stays amortized self->adds_between_gcs = self->array.count; + // Size the map for the entries that will be added before the next + // collection, to avoid rehashing repeatedly as it grows. Failing to do so + // is harmless, the map grows as needed. + (void)vt_reserve(&self->map, self->array.count + MAX(TEXT_CACHE_ADDS_BETWEEN_GCS, self->array.count)); free(gc->map); free(gc->old_items); Chars_free_all(&gc->old_arena); diff --git a/kitty_tests/screen.py b/kitty_tests/screen.py index 3e9a4f058..9c3e779e0 100644 --- a/kitty_tests/screen.py +++ b/kitty_tests/screen.py @@ -975,6 +975,15 @@ class TestScreen(BaseTest): '\x9b', '￿', '\U000e0001', + # runs of combining chars, including more than fit in a cell + 'a\u0300\u0301', + 'e\u0301\u0302\u0303\u0304', + 'x' + '\u0300\u0310\u0320' * 10, + '日\u0300\u0301', + '\u0301\u0302', + '\u0300\ufe0f\u0301', + '👍\u0300\u200d', + 'ก\u0e33\u0300', ) def ops_for(seed, cols): @@ -1027,13 +1036,16 @@ class TestScreen(BaseTest): return s def compare(a, b, msg): + # Cells are compared by content rather than raw value, as cells with + # multiple codepoints store indices into the text cache, which can + # differ, since batched drawing does not add the intermediate texts + # of runs of combining chars to the cache. self.ae((a.cursor.x, a.cursor.y), (b.cursor.x, b.cursor.y), msg) self.ae(a.historybuf.count, b.historybuf.count, msg) for i in range(a.historybuf.count): - self.assertTrue(a.historybuf.line(i) == b.historybuf.line(i), f'{msg} history line {i}') self.ae(a.historybuf.line(i).as_ansi(), b.historybuf.line(i).as_ansi(), f'{msg} history line {i}') + self.ae(a.cpu_cells(-1 - i), b.cpu_cells(-1 - i), f'{msg} history line {i}') for i in range(a.lines): - self.assertTrue(a.linebuf.line(i) == b.linebuf.line(i), f'{msg} line {i}') self.ae(a.linebuf.line(i).as_ansi(), b.linebuf.line(i).as_ansi(), f'{msg} line {i}') self.ae(a.cpu_cells(i), b.cpu_cells(i), f'{msg} line {i}') self.ae(a.linebuf.is_continued(i), b.linebuf.is_continued(i), f'{msg} line {i}')