From 396a5ff79b6d59e1f187ba8d0a99d3aa58870fcd Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Fri, 2 Jul 2021 16:29:08 +0200 Subject: allow-overflowing-double-width-glyphs: take glyph offset into account A narrow, but offset:ed glyph should still be considered double width. This patch also fixes a crash, when the maybe-double width glyph is in the last column. This is a regression. --- render.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 499303f0..dbca64aa 100644 --- a/render.c +++ b/render.c @@ -618,13 +618,13 @@ render_cell(struct terminal *term, pixman_image_t *pix, if (term->conf->tweak.allow_overflowing_double_width_glyphs && ((glyph_count > 0 && cell_cols == 1 && - glyphs[0]->width >= term->cell_width * 15 / 10 && - glyphs[0]->width < 3 * term->cell_width && - col < term->cols - 1) || + glyphs[0]->x + glyphs[0]->width >= term->cell_width * 15 / 10 && + glyphs[0]->x + glyphs[0]->width < 3 * term->cell_width) || (term->conf->tweak.pua_double_width && ((base >= 0x00e000 && base <= 0x00f8ff) || (base >= 0x0f0000 && base <= 0x0ffffd) || (base >= 0x100000 && base <= 0x10fffd)))) && + col < term->cols - 1 && (row->cells[col + 1].wc == 0 || row->cells[col + 1].wc == L' ')) { cell_cols = 2; -- cgit v1.3 From 85b63b5e4a774b2c6f04859fd2a202ad362c6a5e Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Fri, 2 Jul 2021 16:48:46 +0200 Subject: render: require glyph count > 0 and cell-cols also for forced double-width PUAs --- render.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index dbca64aa..80d5efb5 100644 --- a/render.c +++ b/render.c @@ -616,15 +616,15 @@ render_cell(struct terminal *term, pixman_image_t *pix, * - *this* cells is followed by an empty cell, or a space */ if (term->conf->tweak.allow_overflowing_double_width_glyphs && - ((glyph_count > 0 && - cell_cols == 1 && - glyphs[0]->x + glyphs[0]->width >= term->cell_width * 15 / 10 && + glyph_count > 0 && + cell_cols == 1 && + col < term->cols - 1 && + ((glyphs[0]->x + glyphs[0]->width >= term->cell_width * 15 / 10 && glyphs[0]->x + glyphs[0]->width < 3 * term->cell_width) || (term->conf->tweak.pua_double_width && ((base >= 0x00e000 && base <= 0x00f8ff) || (base >= 0x0f0000 && base <= 0x0ffffd) || (base >= 0x100000 && base <= 0x10fffd)))) && - col < term->cols - 1 && (row->cells[col + 1].wc == 0 || row->cells[col + 1].wc == L' ')) { cell_cols = 2; -- cgit v1.3 From 9b4796e996a6b524718591df8d8ea1ebe3b9bbbd Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Tue, 13 Jul 2021 20:28:21 +0200 Subject: render: don’t assume PIXMAN_a8r8g8b8 for color glyphs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit We may want to use PIXMAN_b8g8r8a8 on big-endian in the future. --- render.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 80d5efb5..81fe481d 100644 --- a/render.c +++ b/render.c @@ -682,7 +682,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, if (i > 0 && glyph->x >= 0) g_x -= term->cell_width; - if (unlikely(pixman_image_get_format(glyph->pix) == PIXMAN_a8r8g8b8)) { + if (unlikely(PIXMAN_FORMAT_BPP(pixman_image_get_format(glyph->pix)) == 32)) { /* Glyph surface is a pre-rendered image (typically a color emoji...) */ if (!(cell->attrs.blink && term->blink.state == BLINK_OFF)) { pixman_image_composite32( @@ -2801,7 +2801,7 @@ render_search_box(struct terminal *term) continue; } - if (unlikely(pixman_image_get_format(glyph->pix) == PIXMAN_a8r8g8b8)) { + if (unlikely(PIXMAN_FORMAT_BPP(pixman_image_get_format(glyph->pix)) == 32)) { /* Glyph surface is a pre-rendered image (typically a color emoji...) */ pixman_image_composite32( PIXMAN_OP_OVER, glyph->pix, NULL, buf->pix[0], 0, 0, 0, 0, -- cgit v1.3 From 0c777d825da92778233cbec1a9c659429ee1e20c Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Wed, 14 Jul 2021 19:55:23 +0200 Subject: Revert "render: don’t assume PIXMAN_a8r8g8b8 for color glyphs" MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 9b4796e996a6b524718591df8d8ea1ebe3b9bbbd. Sub-pixel anti-aliasing also uses 32-bit glyphs (but x8r8g8b8, instead of a8r8g8b8)... --- render.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 81fe481d..80d5efb5 100644 --- a/render.c +++ b/render.c @@ -682,7 +682,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, if (i > 0 && glyph->x >= 0) g_x -= term->cell_width; - if (unlikely(PIXMAN_FORMAT_BPP(pixman_image_get_format(glyph->pix)) == 32)) { + if (unlikely(pixman_image_get_format(glyph->pix) == PIXMAN_a8r8g8b8)) { /* Glyph surface is a pre-rendered image (typically a color emoji...) */ if (!(cell->attrs.blink && term->blink.state == BLINK_OFF)) { pixman_image_composite32( @@ -2801,7 +2801,7 @@ render_search_box(struct terminal *term) continue; } - if (unlikely(PIXMAN_FORMAT_BPP(pixman_image_get_format(glyph->pix)) == 32)) { + if (unlikely(pixman_image_get_format(glyph->pix) == PIXMAN_a8r8g8b8)) { /* Glyph surface is a pre-rendered image (typically a color emoji...) */ pixman_image_composite32( PIXMAN_OP_OVER, glyph->pix, NULL, buf->pix[0], 0, 0, 0, 0, -- cgit v1.3 From 9658e9cc18cd671d6016479280796510e42b23a4 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Wed, 14 Jul 2021 20:14:10 +0200 Subject: render: tiocswinsz: don’t remove/close the fd passed as argument MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit There’s a chance the resize timeout FD was closed, and *reused*, after epoll() told us the FD is readable, but before our callback runs. Thus, closing the FD provided as an argument is dangerous, as it may refer to something completely different. --- render.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 80d5efb5..c50988fd 100644 --- a/render.c +++ b/render.c @@ -3119,8 +3119,10 @@ fdm_tiocswinsz(struct fdm *fdm, int fd, int events, void *data) if (events & EPOLLIN) tiocswinsz(term); - fdm_del(fdm, fd); - term->window->resize_timeout_fd = -1; + if (term->window->resize_timeout_fd >= 0) { + fdm_del(fdm, term->window->resize_timeout_fd); + term->window->resize_timeout_fd = -1; + } return true; } -- cgit v1.3 From fcc2e62a7d9a38ab5818815e1f7c52267653f096 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 15 Jul 2021 18:23:49 +0200 Subject: render: track alpha directly, rather whether to use it or not --- render.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index c50988fd..7dcad297 100644 --- a/render.c +++ b/render.c @@ -458,7 +458,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, uint32_t _fg = 0; uint32_t _bg = 0; - bool apply_alpha = false; + uint16_t alpha = 0xffff; if (is_selected && term->colors.use_custom_selection) { _fg = term->colors.selection_fg; @@ -472,14 +472,14 @@ render_cell(struct terminal *term, pixman_image_t *pix, uint32_t swap = _fg; _fg = _bg; _bg = swap; - } else - apply_alpha = !cell->attrs.have_bg; + } else if (!cell->attrs.have_bg) + alpha = term->colors.alpha; } if (unlikely(is_selected && _fg == _bg)) { /* Invert bg when selected/highlighted text has same fg/bg */ _bg = ~_bg; - apply_alpha = false; + alpha = 0xffff; } if (cell->attrs.dim) @@ -491,8 +491,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, _fg = color_dim(_fg); pixman_color_t fg = color_hex_to_pixman(_fg); - pixman_color_t bg = color_hex_to_pixman_with_alpha( - _bg, apply_alpha ? term->colors.alpha : 0xffff); + pixman_color_t bg = color_hex_to_pixman_with_alpha(_bg, alpha); if (term->is_searching && !is_selected) { color_dim_for_search(&fg); -- cgit v1.3 From e259f460f3f39d67be2bd6a218d0348fa73a2e02 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 15 Jul 2021 18:24:27 +0200 Subject: render: margins: use correct background color * Sync actual color used, with how render_cell() selects the background color * Use color_dim_for_search(), not color_dim() --- render.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 7dcad297..b404f2f5 100644 --- a/render.c +++ b/render.c @@ -815,13 +815,10 @@ render_margin(struct terminal *term, struct buffer *buf, const int line_count = end_line - start_line; uint32_t _bg = !term->reverse ? term->colors.bg : term->colors.fg; - if (term->is_searching) - _bg = color_dim(_bg); + pixman_color_t bg = color_hex_to_pixman_with_alpha(_bg, term->colors.alpha); - pixman_color_t bg = color_hex_to_pixman_with_alpha( - _bg, - (_bg == (term->reverse ? term->colors.fg : term->colors.bg) - ? term->colors.alpha : 0xffff)); + if (term->is_searching) + color_dim_for_search(&bg); pixman_image_fill_rectangles( PIXMAN_OP_SRC, buf->pix[0], &bg, 4, -- cgit v1.3 From 628fd3909873433be34db5da80b0fedc714f69b6 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 15 Jul 2021 18:26:26 +0200 Subject: render: scrollback indicator: improve handling of very small window sizes --- CHANGELOG.md | 2 ++ render.c | 27 +++++++++++++++++---------- 2 files changed, 19 insertions(+), 10 deletions(-) (limited to 'render.c') diff --git a/CHANGELOG.md b/CHANGELOG.md index 590c5aa5..a5aa84d9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -57,6 +57,8 @@ rows. * Some box-drawing characters were rendered incorrectly on big-endian architectures. +* Scrollback indicator being incorrectly rendered when window size is + very small. ### Security diff --git a/render.c b/render.c index b404f2f5..a8809513 100644 --- a/render.c +++ b/render.c @@ -2047,10 +2047,6 @@ render_scrollback_position(struct terminal *term) const int height = (2 * margin + term->cell_height + scale - 1) / scale * scale; - unsigned long cookie = shm_cookie_scrollback_indicator(term); - struct buffer *buf = shm_get_buffer( - term->wl->shm, width, height, cookie, false, 1); - /* *Where* to render - parent relative coordinates */ int surf_top = 0; switch (term->conf->scrollback.indicator.position) { @@ -2068,18 +2064,30 @@ render_scrollback_position(struct terminal *term) /* Make sure we don't collide with the scrollback search box */ lines--; } - xassert(lines > 0); - int pixels = lines * term->cell_height - height + 2 * margin; + lines = max(lines, 0); + + int pixels = max(lines * term->cell_height - height + 2 * margin, 0); surf_top = term->cell_height - margin + (int)(percent * pixels); break; } } + const int x = (term->width - margin - width) / scale * scale; + const int y = (term->margins.top + surf_top) / scale * scale; + + if (y + height > term->height) { + wl_surface_attach(win->scrollback_indicator.surf, NULL, 0, 0); + wl_surface_commit(win->scrollback_indicator.surf); + return; + } + + unsigned long cookie = shm_cookie_scrollback_indicator(term); + struct buffer *buf = shm_get_buffer( + term->wl->shm, width, height, cookie, false, 1); + wl_subsurface_set_position( - win->scrollback_indicator.sub, - (term->width - margin - width) / scale, - (term->margins.top + surf_top) / scale); + win->scrollback_indicator.sub, x / scale, y / scale); render_osd( term, @@ -2088,7 +2096,6 @@ render_scrollback_position(struct terminal *term) buf, text, term->colors.table[0], term->colors.table[8 + 4], width - margin - wcslen(text) * term->cell_width, margin); - } static void -- cgit v1.3 From 5e64c67c252bcc475fa4b155c0480f4da112dda4 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 15 Jul 2021 18:27:10 +0200 Subject: render: search: set clip region Fixes crash when the search box has been reduced in height, due to limited window space. --- CHANGELOG.md | 2 ++ render.c | 6 ++++++ 2 files changed, 8 insertions(+) (limited to 'render.c') diff --git a/CHANGELOG.md b/CHANGELOG.md index a5aa84d9..67cbc32a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -57,6 +57,8 @@ rows. * Some box-drawing characters were rendered incorrectly on big-endian architectures. +* Crash when resizing the window to the smallest possible size while + scrollback search is active. * Scrollback indicator being incorrectly rendered when window size is very small. diff --git a/render.c b/render.c index a8809513..7d365643 100644 --- a/render.c +++ b/render.c @@ -2626,6 +2626,12 @@ render_search_box(struct terminal *term) unsigned long cookie = shm_cookie_search(term); struct buffer *buf = shm_get_buffer(term->wl->shm, width, height, cookie, false, 1); + pixman_region32_t clip; + pixman_region32_init_rect(&clip, 0, 0, width, height); + pixman_image_set_clip_region32(buf->pix[0], &clip); + pixman_region32_fini(&clip); + + #define WINDOW_X(x) (margin + x) #define WINDOW_Y(y) (term->height - margin - height + y) -- cgit v1.3 From 7533684d8fa85c33756d18841f2bac5379f40f8b Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 15 Jul 2021 18:32:19 +0200 Subject: shm: add shm_get_many() - allows buffers to share a single pool MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit shm_get_many() always returns new buffers (i.e. never old, cached ones). The newly allocated buffers are also marked for immediate purging, meaning they’ll be destroyed on the next call to either shm_get_buffer(), or shm_get_many(). Furthermore, we add a new attribute, ‘locked’, to the buffer struct. When auto purging buffers, look at this instead of comparing cookies. Buffer consumers are expected to set ‘locked’ while they hold a reference to it, and don’t want it destroyed behind their back. --- render.c | 4 + shm.c | 338 ++++++++++++++++++++++++++++++++++++++++----------------------- shm.h | 61 ++++++++++-- 3 files changed, 274 insertions(+), 129 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 7d365643..37766232 100644 --- a/render.c +++ b/render.c @@ -2322,6 +2322,7 @@ grid_render(struct terminal *term) } if (term->render.last_buf != NULL) { + term->render.last_buf->locked = false; free(term->render.last_buf->scroll_damage); term->render.last_buf->scroll_damage = NULL; } @@ -2330,6 +2331,7 @@ grid_render(struct terminal *term) term->render.was_flashing = term->flash.active; term->render.was_searching = term->is_searching; + buf->locked = true; buf->age = 0; xassert(buf->scroll_damage == NULL); @@ -3416,6 +3418,8 @@ damage_view: tll_free(term->normal.scroll_damage); tll_free(term->alt.scroll_damage); + if (term->render.last_buf != NULL) + term->render.last_buf->locked = false; term->render.last_buf = NULL; term_damage_view(term); render_refresh_csd(term); diff --git a/shm.c b/shm.c index cad60aae..17b9c15d 100644 --- a/shm.c +++ b/shm.c @@ -88,20 +88,37 @@ buffer_destroy_dont_close(struct buffer *buf) buf->mmapped = NULL; } +static void +pool_unref(struct buffer_pool *pool) +{ + if (pool == NULL) + return; + + xassert(pool->ref_count > 0); + pool->ref_count--; + + if (pool->ref_count > 0) + return; + + if (pool->real_mmapped != MAP_FAILED) + munmap(pool->real_mmapped, pool->mmap_size); + if (pool->wl_pool != NULL) + wl_shm_pool_destroy(pool->wl_pool); + if (pool->fd >= 0) + close(pool->fd); + + pool->real_mmapped = MAP_FAILED; + pool->wl_pool = NULL; + pool->fd = -1; + free(pool); +} + static void buffer_destroy(struct buffer *buf) { buffer_destroy_dont_close(buf); - if (buf->real_mmapped != MAP_FAILED) - munmap(buf->real_mmapped, buf->mmap_size); - if (buf->pool != NULL) - wl_shm_pool_destroy(buf->pool); - if (buf->fd >= 0) - close(buf->fd); - - buf->real_mmapped = MAP_FAILED; + pool_unref(buf->pool); buf->pool = NULL; - buf->fd = -1; free(buf->scroll_damage); pixman_region32_fini(&buf->dirty); @@ -124,7 +141,10 @@ static void buffer_release(void *data, struct wl_buffer *wl_buffer) { struct buffer *buffer = data; - LOG_DBG("release: cookie=%lx (buf=%p)", buffer->cookie, (void *)buffer); + + LOG_DBG("release: cookie=%lx (buf=%p, total buffer count: %zu)", + buffer->cookie, (void *)buffer, tll_length(buffers)); + xassert(buffer->wl_buf == wl_buffer); xassert(buffer->busy); buffer->busy = false; @@ -159,15 +179,20 @@ instantiate_offset(struct wl_shm *shm, struct buffer *buf, off_t new_offset) xassert(buf->mmapped == NULL); xassert(buf->wl_buf == NULL); xassert(buf->pix == NULL); + xassert(buf->pool != NULL); + + const struct buffer_pool *pool = buf->pool; void *mmapped = MAP_FAILED; struct wl_buffer *wl_buf = NULL; pixman_image_t **pix = xcalloc(buf->pix_instances, sizeof(*pix)); - mmapped = (uint8_t *)buf->real_mmapped + new_offset; + mmapped = (uint8_t *)pool->real_mmapped + new_offset; wl_buf = wl_shm_pool_create_buffer( - buf->pool, new_offset, buf->width, buf->height, buf->stride, WL_SHM_FORMAT_ARGB8888); + pool->wl_pool, new_offset, buf->width, buf->height, buf->stride, + WL_SHM_FORMAT_ARGB8888); + if (wl_buf == NULL) { LOG_ERR("failed to create SHM buffer"); goto err; @@ -183,8 +208,8 @@ instantiate_offset(struct wl_shm *shm, struct buffer *buf, off_t new_offset) } } - buf->offset = new_offset; buf->mmapped = mmapped; + buf->offset = new_offset; buf->wl_buf = wl_buf; buf->pix = pix; @@ -205,18 +230,19 @@ err: return false; } -struct buffer * -shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, bool scrollable, size_t pix_instances) +static void NOINLINE +destroy_all_purgeables(void) { /* Purge buffers marked for purging */ tll_foreach(buffers, it) { - if (it->item.cookie != cookie) + if (it->item.locked) continue; if (!it->item.purge) continue; - xassert(!it->item.busy); + if (it->item.busy) + continue; LOG_DBG("cookie=%lx: purging buffer %p (width=%d, height=%d): %zu KB", cookie, (void *)&it->item, it->item.width, it->item.height, @@ -225,56 +251,15 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, buffer_destroy(&it->item); tll_remove(buffers, it); } +} - struct buffer *cached = NULL; - - tll_foreach(buffers, it) { - if (it->item.width != width) - continue; - if (it->item.height != height) - continue; - if (it->item.cookie != cookie) - continue; - - if (it->item.busy) - it->item.age++; - else -#if FORCED_DOUBLE_BUFFERING - if (it->item.age == 0) - it->item.age++; - else -#endif - { - LOG_DBG("cookie=%lx: re-using buffer from cache (buf=%p)", - cookie, (void *)&it->item); - it->item.busy = true; - it->item.purge = false; - pixman_region32_clear(&it->item.dirty); - free(it->item.scroll_damage); - it->item.scroll_damage = NULL; - xassert(it->item.pix_instances == pix_instances); - cached = &it->item; - } - } - - if (cached != NULL) - return cached; - - /* Purge old buffers associated with this cookie */ - tll_foreach(buffers, it) { - if (it->item.cookie != cookie) - continue; - - if (it->item.busy) - continue; - - if (it->item.width == width && it->item.height == height) - continue; - - LOG_DBG("cookie=%lx: marking buffer %p for purging", cookie, (void *)&it->item); - it->item.purge = true; - } - +static void NOINLINE +get_new_buffers(struct wl_shm *shm, size_t count, + struct buffer_description info[static count], + struct buffer *bufs[static count], + size_t pix_instances, bool scrollable, bool immediate_purge) +{ + xassert(count == 1 || !scrollable); /* * No existing buffer available. Create a new one by: * @@ -285,14 +270,21 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, * The pixman image and the wayland buffer are now sharing memory. */ + int stride[count]; + int sizes[count]; + + size_t total_size = 0; + for (size_t i = 0; i < count; i++) { + stride[i] = stride_for_format_and_width(PIXMAN_a8r8g8b8, info[i].width); + sizes[i] = stride[i] * info[i].height; + total_size += sizes[i]; + } + int pool_fd = -1; - const int stride = stride_for_format_and_width(PIXMAN_a8r8g8b8, width); - const size_t size = stride * height; void *real_mmapped = MAP_FAILED; - struct wl_shm_pool *pool = NULL; - - LOG_DBG("cookie=%lx: allocating new buffer: %zu KB", cookie, size / 1024); + struct wl_shm_pool *wl_pool = NULL; + struct buffer_pool *pool = NULL; /* Backing memory for SHM */ #if defined(MEMFD_CREATE) @@ -311,14 +303,16 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, } #if __SIZEOF_POINTER__ == 8 - off_t initial_offset = scrollable && max_pool_size > 0 ? (max_pool_size / 4) & ~(page_size() - 1) : 0; - off_t memfd_size = scrollable && max_pool_size > 0 ? max_pool_size : size; + off_t offset = scrollable && max_pool_size > 0 ? (max_pool_size / 4) & ~(page_size() - 1) : 0; + off_t memfd_size = scrollable && max_pool_size > 0 ? max_pool_size : total_size; #else - off_t initial_offset = 0; - off_t memfd_size = size; + off_t offset = 0; + off_t memfd_size = total_size; #endif - LOG_DBG("memfd-size: %lu, initial offset: %lu", memfd_size, initial_offset); + xassert(scrollable || (offset == 0 && memfd_size == total_size)); + + LOG_DBG("memfd-size: %lu, initial offset: %lu", memfd_size, offset); if (ftruncate(pool_fd, memfd_size) == -1) { LOG_ERRNO("failed to set size of SHM backing memory file"); @@ -344,8 +338,8 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, } if (scrollable && !can_punch_hole) { - initial_offset = 0; - memfd_size = size; + offset = 0; + memfd_size = total_size; scrollable = false; if (ftruncate(pool_fd, memfd_size) < 0) { @@ -374,37 +368,55 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, } #endif - pool = wl_shm_create_pool(shm, pool_fd, memfd_size); - if (pool == NULL) { + wl_pool = wl_shm_create_pool(shm, pool_fd, memfd_size); + if (wl_pool == NULL) { LOG_ERR("failed to create SHM pool"); goto err; } - /* Push to list of available buffers, but marked as 'busy' */ - tll_push_back( - buffers, - ((struct buffer){ - .cookie = cookie, - .width = width, - .height = height, - .stride = stride, - .busy = true, - .size = size, - .pix_instances = pix_instances, - .fd = pool_fd, - .pool = pool, - .scrollable = scrollable, - .real_mmapped = real_mmapped, - .mmap_size = memfd_size, - .offset = 0, - .age = 1234, /* Force a full repaint */ - })); - - struct buffer *ret = &tll_back(buffers); - if (!instantiate_offset(shm, ret, initial_offset)) + pool = malloc(sizeof(*pool)); + if (pool == NULL) { + LOG_ERRNO("failed to allocate buffer pool"); goto err; + } + + *pool = (struct buffer_pool){ + .fd = pool_fd, + .wl_pool = wl_pool, + .real_mmapped = real_mmapped, + .mmap_size = memfd_size, + .ref_count = 0, + }; + + for (size_t i = 0; i < count; i++) { + + /* Push to list of available buffers, but marked as 'busy' */ + tll_push_front( + buffers, + ((struct buffer){ + .cookie = info[i].cookie, + .width = info[i].width, + .height = info[i].height, + .stride = stride[i], + .busy = true, + .purge = immediate_purge, + .size = sizes[i], + .pix_instances = pix_instances, + .pool = pool, + .scrollable = scrollable, + .offset = 0, + .age = 1234, /* Force a full repaint */ + })); + + struct buffer *buf = &tll_front(buffers); + if (!instantiate_offset(shm, buf, offset)) + goto err; - pixman_region32_init(&ret->dirty); + pixman_region32_init(&buf->dirty); + pool->ref_count++; + offset += buf->size; + bufs[i] = buf; + } #if defined(MEASURE_SHM_ALLOCS) && MEASURE_SHM_ALLOCS { @@ -416,18 +428,19 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, } #endif - if (!shm_can_scroll(ret)) { + if (!shm_can_scroll(bufs[0])) { /* We only need to keep the pool FD open if we’re going to SHM * scroll it */ close(pool_fd); - ret->fd = -1; + pool->fd = -1; } - return ret; + return; err: - if (pool != NULL) - wl_shm_pool_destroy(pool); + pool_unref(pool); + if (wl_pool != NULL) + wl_shm_pool_destroy(wl_pool); if (real_mmapped != MAP_FAILED) munmap(real_mmapped, memfd_size); if (pool_fd != -1) @@ -435,7 +448,78 @@ err: /* We don't handle this */ abort(); - return NULL; +} + +void +shm_get_many(struct wl_shm *shm, size_t count, + struct buffer_description info[static count], + struct buffer *bufs[static count], + size_t pix_instances) +{ + destroy_all_purgeables(); + get_new_buffers(shm, count, info, bufs, pix_instances, false, true); +} + +struct buffer * +shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, + bool scrollable, size_t pix_instances) +{ + destroy_all_purgeables(); + + struct buffer *cached = NULL; + tll_foreach(buffers, it) { + if (it->item.width != width) + continue; + if (it->item.height != height) + continue; + if (it->item.cookie != cookie) + continue; + + if (it->item.busy) + it->item.age++; + else +#if FORCED_DOUBLE_BUFFERING + if (it->item.age == 0) + it->item.age++; + else +#endif + { + if (cached == NULL) { + LOG_DBG("cookie=%lx: re-using buffer from cache (buf=%p)", + cookie, (void *)&it->item); + it->item.busy = true; + it->item.purge = false; + pixman_region32_clear(&it->item.dirty); + free(it->item.scroll_damage); + it->item.scroll_damage = NULL; + xassert(it->item.pix_instances == pix_instances); + cached = &it->item; + } + } + } + + if (cached != NULL) + return cached; + + /* Mark old buffers associated with this cookie for purging */ + tll_foreach(buffers, it) { + if (it->item.cookie != cookie) + continue; + + if (it->item.busy) + continue; + + if (it->item.width == width && it->item.height == height) + continue; + + LOG_DBG("cookie=%lx: marking buffer %p for purging", cookie, (void *)&it->item); + it->item.purge = true; + } + + struct buffer *ret; + get_new_buffers(shm, 1, &(struct buffer_description){width, height, cookie}, + &ret, pix_instances, scrollable, false); + return ret; } bool @@ -453,12 +537,15 @@ shm_can_scroll(const struct buffer *buf) static bool wrap_buffer(struct wl_shm *shm, struct buffer *buf, off_t new_offset) { + struct buffer_pool *pool = buf->pool; + xassert(pool->ref_count == 1); + /* We don't allow overlapping offsets */ off_t UNUSED diff = new_offset < buf->offset ? buf->offset - new_offset : new_offset - buf->offset; xassert(diff > buf->size); - memcpy((uint8_t *)buf->real_mmapped + new_offset, buf->mmapped, buf->size); + memcpy((uint8_t *)pool->real_mmapped + new_offset, buf->mmapped, buf->size); off_t trim_ofs, trim_len; if (new_offset > buf->offset) { @@ -468,11 +555,11 @@ wrap_buffer(struct wl_shm *shm, struct buffer *buf, off_t new_offset) } else { /* Trim everything *after* the new buffer location */ trim_ofs = new_offset + buf->size; - trim_len = buf->mmap_size - trim_ofs; + trim_len = pool->mmap_size - trim_ofs; } if (fallocate( - buf->fd, + pool->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, trim_ofs, trim_len) < 0) { @@ -490,11 +577,15 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer *buf, int rows, int top_margin, int top_keep_rows, int bottom_margin, int bottom_keep_rows) { + struct buffer_pool *pool = buf->pool; + xassert(can_punch_hole); xassert(buf->busy); xassert(buf->pix); xassert(buf->wl_buf); - xassert(buf->fd >= 0); + xassert(pool != NULL); + xassert(pool->ref_count == 1); + xassert(pool->fd >= 0); LOG_DBG("scrolling %d rows (%d bytes)", rows, rows * buf->stride); @@ -541,7 +632,7 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer *buf, int rows, const off_t trim_len = new_offset; if (fallocate( - buf->fd, + pool->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, trim_ofs, trim_len) < 0) { @@ -596,6 +687,9 @@ shm_scroll_reverse(struct wl_shm *shm, struct buffer *buf, int rows, { xassert(rows > 0); + struct buffer_pool *pool = buf->pool; + xassert(pool->ref_count == 1); + const off_t diff = rows * buf->stride; if (diff > buf->offset) { LOG_DBG("memfd offset reverse wrap-around"); @@ -634,10 +728,10 @@ shm_scroll_reverse(struct wl_shm *shm, struct buffer *buf, int rows, /* Free unused memory - everything after the relocated buffer */ const off_t trim_ofs = new_offset + buf->size; - const off_t trim_len = buf->mmap_size - trim_ofs; + const off_t trim_len = pool->mmap_size - trim_ofs; if (fallocate( - buf->fd, + pool->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, trim_ofs, trim_len) < 0) { @@ -712,9 +806,13 @@ shm_purge(struct wl_shm *shm, unsigned long cookie) if (it->item.cookie != cookie) continue; - xassert(!it->item.busy); - - buffer_destroy(&it->item); - tll_remove(buffers, it); + if (it->item.busy) { + LOG_WARN("deferring purge of 'busy' buffer (width=%d, height=%d)", + it->item.width, it->item.height); + it->item.purge = true; + } else { + buffer_destroy(&it->item); + tll_remove(buffers, it); + } } } diff --git a/shm.h b/shm.h index 385a0e30..610f0311 100644 --- a/shm.h +++ b/shm.h @@ -9,6 +9,16 @@ #include "terminal.h" +struct buffer_pool { + int fd; /* memfd */ + struct wl_shm_pool *wl_pool; + + void *real_mmapped; /* Address returned from mmap */ + size_t mmap_size; /* Size of mmap (>= size) */ + + size_t ref_count; +}; + struct buffer { unsigned long cookie; @@ -16,7 +26,8 @@ struct buffer { int height; int stride; - bool busy; + bool locked; /* Caller owned, shm won’t destroy it */ + bool busy; /* Owned by compositor */ size_t size; /* Buffer size */ void *mmapped; /* Raw data (TODO: rename) */ @@ -25,11 +36,7 @@ struct buffer { size_t pix_instances; /* Internal */ - int fd; /* memfd */ - struct wl_shm_pool *pool; - - void *real_mmapped; /* Address returned from mmap */ - size_t mmap_size; /* Size of mmap (>= size) */ + struct buffer_pool *pool; off_t offset; /* Offset into memfd where data begins */ bool scrollable; @@ -41,11 +48,47 @@ struct buffer { pixman_region32_t dirty; }; -struct buffer *shm_get_buffer( - struct wl_shm *shm, int width, int height, unsigned long cookie, bool scrollable, size_t pix_instances); -void shm_fini(void); +struct buffer_description { + int width; + int height; + unsigned long cookie; +}; +void shm_fini(void); void shm_set_max_pool_size(off_t max_pool_size); + +/* + * Returns a single buffer. + * + * May returned a cached buffer. If so, the buffer’s age indicates how + * many shm_get_buffer() calls have been made for the same + * width/height/cookie while the buffer was still busy. + * + * A newly allocated buffer has an age of 1234. + */ +struct buffer *shm_get_buffer( + struct wl_shm *shm, int width, int height, unsigned long cookie, + bool scrollable, size_t pix_instances); + +/* + * Returns many buffers, described by ‘info’, all sharing the same SHM + * buffer pool. + * + * Never returns cached buffers. However, the newly created buffers + * are all inserted into the regular buffer cache, and are treated + * just like buffers created by shm_get_buffer(). + * + * This function is useful when allocating many small buffers, with + * (roughly) the same life time. + * + * Buffers are tagged for immediate purging, and will be destroyed as + * soon as the compositor releases them. + */ +void shm_get_many( + struct wl_shm *shm, size_t count, + struct buffer_description info[static count], + struct buffer *bufs[static count], size_t pix_instances); + bool shm_can_scroll(const struct buffer *buf); bool shm_scroll(struct wl_shm *shm, struct buffer *buf, int rows, int top_margin, int top_keep_rows, -- cgit v1.3 From 31fad5846516ee1e6135bd35f0478b93928a3759 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 15 Jul 2021 18:39:41 +0200 Subject: url-mode: use shm_get_many() If we have lots of URLs, we use up a *lot* of SHM buffers (and thus pools). Each and every one is a single mmap(), of at least 4K. Since all URL labels are created and destroyed at the same time, it makes sense to use a single pool for all buffers. To do this, we must now do two passes; first one to generate the actual string (label content), and to calculate the label sizes. Then we use this information to allocate all SHM buffers at once, from the same pool. Finally, we iterate the URLs again, this time to actually render them. --- CHANGELOG.md | 1 + render.c | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++--------- url-mode.c | 3 -- 3 files changed, 79 insertions(+), 17 deletions(-) (limited to 'render.c') diff --git a/CHANGELOG.md b/CHANGELOG.md index 67cbc32a..b66079fc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -61,6 +61,7 @@ scrollback search is active. * Scrollback indicator being incorrectly rendered when window size is very small. +* Reduced memory usage in URL mode. ### Security diff --git a/render.c b/render.c index 37766232..8e66bf00 100644 --- a/render.c +++ b/render.c @@ -2886,6 +2886,10 @@ render_urls(struct terminal *term) struct wl_window *win = term->window; xassert(tll_length(win->urls) > 0); + const int scale = term->scale; + const int x_margin = 2 * scale; + const int y_margin = 1 * scale; + /* Calculate view start, counted from the *current* scrollback start */ const int scrollback_end = (term->grid->offset + term->rows) & (term->grid->num_rows - 1); @@ -2897,6 +2901,44 @@ render_urls(struct terminal *term) const bool show_url = term->urls_show_uri_on_jump_label; + /* + * There can potentially be a lot of URLs. + * + * Since each URL is a separate sub-surface, and requires its own + * SHM buffer, we may be allocating a lot of buffers. + * + * SHM buffers normally have their own, private SHM buffer + * pool. Each pool is mmapped, and thus allocates *at least* + * 4K. Since URL labels are typically small, we end up using an + * excessive amount of both virtual and physical memory. + * + * For this reason, we instead use shm_get_many(), which uses a + * single, shared pool for all buffers. + * + * To be able to use it, we need to have all the *all* the buffer + * dimensions up front. + * + * Thus, the first iteration through the URLs do the heavy + * lifting: builds the label contents and calculates both its + * position and size. But instead of rendering the label + * immediately, we store the calculated data, and then do a second + * pass, where we first get all our buffers, and then render to + * them. + */ + + /* Positioning data + label contents */ + struct { + const struct wl_url *url; + wchar_t *text; + int x; + int y; + } info[tll_length(win->urls)]; + + /* For shm_get_many() */ + struct buffer_description shm_desc[tll_length(win->urls)]; + + size_t render_count = 0; + tll_foreach(win->urls, it) { const struct url *url = it->item.url; const wchar_t *key = url->key; @@ -2953,6 +2995,7 @@ render_urls(struct terminal *term) /* Maximum width of label, in pixels */ const int max_width = term->width - term->margins.left - term->margins.right - x; + const int max_cols = max_width / term->cell_width; const size_t key_len = wcslen(key); @@ -2990,10 +3033,6 @@ render_urls(struct terminal *term) * Do it in a way such that we don’t cut the label in the * middle of a double-width character. */ - const int scale = term->scale; - const int x_margin = 2 * scale; - const int y_margin = 1 * scale; - const int max_cols = max_width / term->cell_width; int cols = 0; @@ -3021,23 +3060,48 @@ render_urls(struct terminal *term) const int height = (2 * y_margin + term->cell_height + scale - 1) / scale * scale; - struct buffer *buf = shm_get_buffer( - term->wl->shm, width, height, shm_cookie_url(url), false, 1); + info[render_count].url = &it->item; + info[render_count].text = xwcsdup(label); + info[render_count].x = x; + info[render_count].y = y; + + shm_desc[render_count].width = width; + shm_desc[render_count].height = height; + shm_desc[render_count].cookie = shm_cookie_url(url); + + render_count++; + } + + struct buffer *bufs[render_count]; + shm_get_many(term->wl->shm, render_count, shm_desc, bufs, 1); + + uint32_t fg = term->conf->colors.use_custom.jump_label + ? term->conf->colors.jump_label.fg + : term->colors.table[0]; + uint32_t bg = term->conf->colors.use_custom.jump_label + ? term->conf->colors.jump_label.bg + : term->colors.table[3]; + + for (size_t i = 0; i < render_count; i++) { + struct wl_surface *surf = info[i].url->surf.surf; + struct wl_subsurface *sub_surf = info[i].url->surf.sub; + + const wchar_t *label = info[i].text; + const int x = info[i].x; + const int y = info[i].y; + + xassert(surf != NULL); + xassert(sub_surf != NULL); wl_subsurface_set_position( sub_surf, (term->margins.left + x) / term->scale, (term->margins.top + y) / term->scale); - uint32_t fg = term->conf->colors.use_custom.jump_label - ? term->conf->colors.jump_label.fg - : term->colors.table[0]; - uint32_t bg = term->conf->colors.use_custom.jump_label - ? term->conf->colors.jump_label.bg - : term->colors.table[3]; - render_osd( - term, surf, sub_surf, buf, label, fg, bg, x_margin, y_margin); + term, surf, sub_surf, bufs[i], label, fg, bg, x_margin, y_margin); + + free(info[i].text); } } diff --git a/url-mode.c b/url-mode.c index 524b8d1b..a802cc6c 100644 --- a/url-mode.c +++ b/url-mode.c @@ -14,7 +14,6 @@ #include "grid.h" #include "render.h" #include "selection.h" -#include "shm.h" #include "spawn.h" #include "terminal.h" #include "uri.h" @@ -738,9 +737,7 @@ urls_reset(struct terminal *term) if (term->window != NULL) { tll_foreach(term->window->urls, it) { - const struct url *url = it->item.url; wayl_win_subsurface_destroy(&it->item.surf); - shm_purge(term->wl->shm, shm_cookie_url(url)); tll_remove(term->window->urls, it); } } -- cgit v1.3 From 91801ae55da017c2dd0f44c04b8d316a9a2090ef Mon Sep 17 00:00:00 2001 From: Timur Celik Date: Tue, 15 Jun 2021 11:45:27 +0200 Subject: render: Allow cells to bleed into their neighbor This patch adds a `confined` flag to each cell to track if the last rendered glyph bled into it's right neighbor. To keep things simple, bleeding into any other neighbor cell than the immediate right one is not allowed. This should cover most use cases. Before rendering a row we now do a prepass and mark all cells unclean that are affected by a bleeding neighbor. If there are consecutive bleeding cells, the whole group must be re-rendered even if only a single cell has changed. The patch also deprecates both old overflowing glyph options *allow-overflowing-double-width-glyphs* and *pua-double-width* in favor of a single new one named *overflowing-glyphs*. --- CHANGELOG.md | 11 ++++++++ config.c | 17 ++++-------- config.h | 3 +-- doc/foot.ini.5.scd | 34 +++++++++--------------- render.c | 78 ++++++++++++++++++++++++++++-------------------------- terminal.h | 3 ++- 6 files changed, 71 insertions(+), 75 deletions(-) (limited to 'render.c') diff --git a/CHANGELOG.md b/CHANGELOG.md index 9c2ed336..f12a8b53 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -33,6 +33,9 @@ * `locked-title=no|yes` to `foot.ini` (https://codeberg.org/dnkl/foot/issues/386). +* `tweak.overflowing-glyphs` option, which can be enabled to fix rendering + issues with glyphs of any width that appear cut-off + (https://codeberg.org/dnkl/foot/issues/592). ### Changed @@ -45,6 +48,12 @@ ### Deprecated ### Removed + +* The `tweak.allow-overflowing-double-width-glyphs` and + `tweak.pua-double-width` options (which have been superseded by + `tweak.overflowing-glyphs`). + + ### Fixed * Glyph offset not being taken into account when applying @@ -69,6 +78,8 @@ ### Security ### Contributors +* [clktmr](https://codeberg.org/clktmr) + ## 1.8.1 diff --git a/config.c b/config.c index 92582f2c..a9acb58e 100644 --- a/config.c +++ b/config.c @@ -2213,16 +2213,10 @@ parse_section_tweak( return false; } - else if (strcmp(key, "allow-overflowing-double-width-glyphs") == 0) { - conf->tweak.allow_overflowing_double_width_glyphs = str_to_bool(value); - if (!conf->tweak.allow_overflowing_double_width_glyphs) - LOG_WARN("tweak: disabled overflowing double-width glyphs"); - } - - else if (strcmp(key, "pua-double-width") == 0) { - conf->tweak.pua_double_width = str_to_bool(value); - if (conf->tweak.pua_double_width) - LOG_WARN("tweak: PUA double width glyphs enabled"); + else if (strcmp(key, "overflowing-glyphs") == 0) { + conf->tweak.overflowing_glyphs = str_to_bool(value); + if (!conf->tweak.overflowing_glyphs) + LOG_WARN("tweak: disabled overflowing glyphs"); } else if (strcmp(key, "damage-whole-window") == 0) { @@ -2833,7 +2827,7 @@ config_load(struct config *conf, const char *conf_path, .tweak = { .fcft_filter = FCFT_SCALING_FILTER_LANCZOS3, - .allow_overflowing_double_width_glyphs = true, + .overflowing_glyphs = true, .grapheme_shaping = false, .grapheme_width_method = GRAPHEME_WIDTH_DOUBLE, .delayed_render_lower_ns = 500000, /* 0.5ms */ @@ -2844,7 +2838,6 @@ config_load(struct config *conf, const char *conf_path, .damage_whole_window = false, .box_drawing_base_thickness = 0.04, .box_drawing_solid_shades = true, - .pua_double_width = false, }, .notifications = tll_init(), diff --git a/config.h b/config.h index 190ea427..729eba3e 100644 --- a/config.h +++ b/config.h @@ -245,7 +245,7 @@ struct config { struct { enum fcft_scaling_filter fcft_filter; - bool allow_overflowing_double_width_glyphs; + bool overflowing_glyphs; bool grapheme_shaping; enum {GRAPHEME_WIDTH_WCSWIDTH, GRAPHEME_WIDTH_DOUBLE} grapheme_width_method; bool render_timer_osd; @@ -256,7 +256,6 @@ struct config { off_t max_shm_pool_size; float box_drawing_base_thickness; bool box_drawing_solid_shades; - bool pua_double_width; } tweak; user_notifications_t notifications; diff --git a/doc/foot.ini.5.scd b/doc/foot.ini.5.scd index 6ceaf3b9..8b2f1dc8 100644 --- a/doc/foot.ini.5.scd +++ b/doc/foot.ini.5.scd @@ -847,34 +847,24 @@ any of these options. Default: _lanczos3_. -*allow-overflowing-double-width-glyphs* - Boolean. When enabled, double width glyphs with a character width - of 1 are allowed to overflow into the neighbouring cell. +*overflowing-glyphs* + Boolean. When enabled, glyphs wider than their cell(s) are allowed + to render into one additional neighbouring cell. - One use case for this is fonts "icon" characters in the Unicode - private usage area, e.g. Nerd Fonts, or Powerline Fonts. Without - this option, such glyphs will appear "cut off". + One use case for this are fonts with wide italic characters that + "bend" into the next cell. Without this option, such glyphs will + appear "cut off". - Another use case are legacy emoji characters like *WHITE FROWNING - FACE*. + Another use case are fonts with "icon" characters in the Unicode + private usage area, e.g. Nerd Fonts, or Powerline Fonts and legacy + emoji characters like *WHITE FROWNING FACE*. - Note: this feature uses _heuristics_ to determine *which* glyphs - should be allowed to overflow. - - See also: *pua-double-width* + Note: might impact performance depending on the font used. + Especially small font sizes can cause many overflowing glyphs + because of subpixel rendering. Default: _yes_. -*pua-double-width* - Boolean. When enabled, Unicode code points from the private usage - area (PUA) are always considered to be double width, regardless of - the actual glyph width. - - Ignored if *allow-overflowing-double-width-glyphs* has been - disabled. - - Default: _no_. - *render-timer* Enables a frame rendering timer, that prints the time it takes to render each frame, in microseconds, either on-screen, to stderr, diff --git a/render.c b/render.c index 8e66bf00..41a20226 100644 --- a/render.c +++ b/render.c @@ -437,6 +437,20 @@ draw_cursor(const struct terminal *term, const struct cell *cell, } } +static inline void +render_cell_prepass(struct terminal *term, struct row *row, int col) +{ + for (; col < term->cols - 1; col++) { + if (row->cells[col].attrs.confined || + (row->cells[col].attrs.clean == row->cells[col + 1].attrs.clean)) { + break; + } + + row->cells[col].attrs.clean = 0; + row->cells[col + 1].attrs.clean = 0; + } +} + static int render_cell(struct terminal *term, pixman_image_t *pix, struct row *row, int col, int row_no, bool has_cursor) @@ -446,6 +460,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, return 0; cell->attrs.clean = 1; + cell->attrs.confined = true; int width = term->cell_width; int height = term->cell_height; @@ -597,51 +612,32 @@ render_cell(struct terminal *term, pixman_image_t *pix, cell_cols = max(1, min(cell_cols, cols_left)); /* - * Hack! - * - * Deal with double-width glyphs for which wcwidth() returns - * 1. Typically Unicode private usage area characters, - * e.g. powerline, or nerd hack fonts. - * - * Users can enable a tweak option that lets this glyphs - * overflow/bleed into the neighbouring cell. - * - * We only apply this workaround if: - * - the user has explicitly enabled this feature - * - the *character* width is 1 - * - the *glyph* width is at least 1.5 cells - * - the *glyph* width is less than 3 cells - * - *this* column isn’t the last column - * - *this* cells is followed by an empty cell, or a space + * Determine cells that will bleed into their right neighbor and remember + * them for cleanup in the next frame. */ - if (term->conf->tweak.allow_overflowing_double_width_glyphs && - glyph_count > 0 && - cell_cols == 1 && - col < term->cols - 1 && - ((glyphs[0]->x + glyphs[0]->width >= term->cell_width * 15 / 10 && - glyphs[0]->x + glyphs[0]->width < 3 * term->cell_width) || - (term->conf->tweak.pua_double_width && - ((base >= 0x00e000 && base <= 0x00f8ff) || - (base >= 0x0f0000 && base <= 0x0ffffd) || - (base >= 0x100000 && base <= 0x10fffd)))) && - (row->cells[col + 1].wc == 0 || row->cells[col + 1].wc == L' ')) + int render_width = cell_cols * width; + if (term->conf->tweak.overflowing_glyphs && + glyph_count > 0) { - cell_cols = 2; + int glyph_width = 0, advance = 0; + for (size_t i = 0; i < glyph_count; i++) { + glyph_width = max(glyph_width, + advance + glyphs[i]->x + glyphs[i]->width); + advance += glyphs[i]->advance.x; + } - /* - * Ensure the cell we’re overflowing into gets re-rendered, to - * ensure it is erased if *this* cell is erased. Note that we - * do *not* mark the row as dirty - we don’t need to re-render - * the cell if nothing else on the row has changed. - */ - row->cells[col].attrs.clean = 0; - row->cells[col + 1].attrs.clean = 0; + if (glyph_width > render_width) { + render_width = min(glyph_width, render_width + width); + + for (int i = 0; i < cell_cols; i++) + row->cells[col + i].attrs.confined = false; + } } pixman_region32_t clip; pixman_region32_init_rect( &clip, x, y, - cell_cols * term->cell_width, term->cell_height); + render_width, term->cell_height); pixman_image_set_clip_region32(pix, &clip); /* Background */ @@ -771,6 +767,10 @@ static void render_row(struct terminal *term, pixman_image_t *pix, struct row *row, int row_no, int cursor_col) { + if (term->conf->tweak.overflowing_glyphs) + for (int col = term->cols - 1; col >= 0; col--) + render_cell_prepass(term, row, col); + for (int col = term->cols - 1; col >= 0; col--) render_cell(term, pix, row, col, row_no, cursor_col == col); } @@ -1192,8 +1192,10 @@ render_sixel(struct terminal *term, pixman_image_t *pix, (last_col_needs_erase && last_col)) { render_cell(term, pix, row, col, term_row_no, cursor_col == col); - } else + } else { cell->attrs.clean = 1; + cell->attrs.confined = 1; + } } } } diff --git a/terminal.h b/terminal.h index 12a637a0..5ffa6154 100644 --- a/terminal.h +++ b/terminal.h @@ -42,11 +42,12 @@ struct attributes { uint32_t fg:24; bool clean:1; + bool confined:1; bool have_fg:1; bool have_bg:1; uint32_t selected:2; bool url:1; - uint32_t reserved:2; + uint32_t reserved:1; uint32_t bg:24; }; static_assert(sizeof(struct attributes) == 8, "VT attribute struct too large"); -- cgit v1.3 From 9b6cee825beb927ec24ef28f0f162623db218fe2 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 15 Jul 2021 22:18:09 +0200 Subject: shm: rename buffer.mmapped to buffer.data --- render.c | 6 +++--- shm.c | 18 ++++++++++-------- shm.h | 2 +- 3 files changed, 14 insertions(+), 12 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 41a20226..076a8d54 100644 --- a/render.c +++ b/render.c @@ -954,7 +954,7 @@ grid_render_scroll(struct terminal *term, struct buffer *buf, term, buf, dmg->region.end - dmg->lines, term->rows, false); } else { /* Fallback for when we either cannot do SHM scrolling, or it failed */ - uint8_t *raw = buf->mmapped; + uint8_t *raw = buf->data; memmove(raw + dst_y * buf->stride, raw + src_y * buf->stride, height * buf->stride); @@ -1019,7 +1019,7 @@ grid_render_scroll_reverse(struct terminal *term, struct buffer *buf, term, buf, dmg->region.start, dmg->region.start + dmg->lines, false); } else { /* Fallback for when we either cannot do SHM scrolling, or it failed */ - uint8_t *raw = buf->mmapped; + uint8_t *raw = buf->data; memmove(raw + dst_y * buf->stride, raw + src_y * buf->stride, height * buf->stride); @@ -2162,7 +2162,7 @@ reapply_old_damage(struct terminal *term, struct buffer *new, struct buffer *old } if (new->age > 1) { - memcpy(new->mmapped, old->mmapped, new->size); + memcpy(new->data, old->data, new->size); return; } diff --git a/shm.c b/shm.c index 12688445..26d1b839 100644 --- a/shm.c +++ b/shm.c @@ -108,7 +108,7 @@ buffer_destroy_dont_close(struct buffer *buf) free(buf->pix); buf->pix = NULL; buf->wl_buf = NULL; - buf->mmapped = NULL; + buf->data = NULL; } static void @@ -150,6 +150,8 @@ buffer_destroy(struct buffer_private *buf) void shm_fini(void) { + xassert(tll_length(buffers) == 0); + tll_foreach(buffers, it) { buffer_destroy(&it->item); tll_remove(buffers, it); @@ -199,7 +201,7 @@ page_size(void) static bool instantiate_offset(struct wl_shm *shm, struct buffer_private *buf, off_t new_offset) { - xassert(buf->public.mmapped == NULL); + xassert(buf->public.data == NULL); xassert(buf->public.pix == NULL); xassert(buf->public.wl_buf == NULL); xassert(buf->pool != NULL); @@ -233,7 +235,7 @@ instantiate_offset(struct wl_shm *shm, struct buffer_private *buf, off_t new_off } } - buf->public.mmapped = mmapped; + buf->public.data = mmapped; buf->public.wl_buf = wl_buf; buf->public.pix = pix; buf->offset = new_offset; @@ -584,7 +586,7 @@ wrap_buffer(struct wl_shm *shm, struct buffer_private *buf, off_t new_offset) xassert(diff > buf->public.size); memcpy((uint8_t *)pool->real_mmapped + new_offset, - buf->public.mmapped, + buf->public.data, buf->public.size); off_t trim_ofs, trim_len; @@ -653,7 +655,7 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer_private *buf, int rows, if (top_keep_rows > 0) { /* Copy current 'top' region to its new location */ const int stride = buf->public.stride; - uint8_t *base = buf->public.mmapped; + uint8_t *base = buf->public.data; memmove( base + (top_margin + rows) * stride, @@ -704,7 +706,7 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer_private *buf, int rows, /* Copy 'bottom' region to its new location */ const size_t size = buf->public.size; const int stride = buf->public.stride; - uint8_t *base = buf->public.mmapped; + uint8_t *base = buf->public.data; memmove( base + size - (bottom_margin + bottom_keep_rows) * stride, @@ -760,7 +762,7 @@ shm_scroll_reverse(struct wl_shm *shm, struct buffer_private *buf, int rows, /* Copy 'bottom' region to its new location */ const size_t size = buf->public.size; const int stride = buf->public.stride; - uint8_t *base = buf->public.mmapped; + uint8_t *base = buf->public.data; memmove( base + size - (bottom_margin + rows + bottom_keep_rows) * stride, @@ -809,7 +811,7 @@ shm_scroll_reverse(struct wl_shm *shm, struct buffer_private *buf, int rows, if (ret && top_keep_rows > 0) { /* Copy current 'top' region to its new location */ const int stride = buf->public.stride; - uint8_t *base = buf->public.mmapped; + uint8_t *base = buf->public.data; memmove( base + (top_margin + 0) * stride, diff --git a/shm.h b/shm.h index 01f1a711..43398cc9 100644 --- a/shm.h +++ b/shm.h @@ -17,7 +17,7 @@ struct buffer { int stride; size_t size; /* Buffer size */ - void *mmapped; /* Raw data (TODO: rename) */ + void *data; /* Raw data (TODO: rename) */ struct wl_buffer *wl_buf; pixman_image_t **pix; -- cgit v1.3 From 99ea47c97ac6884e469d1d2cdb76220f3398a737 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 15 Jul 2021 22:30:08 +0200 Subject: shm: move ‘size’ to the private buffer struct MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- render.c | 2 +- shm.c | 31 ++++++++++++++++--------------- shm.h | 3 +-- 3 files changed, 18 insertions(+), 18 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 076a8d54..c48c515a 100644 --- a/render.c +++ b/render.c @@ -2162,7 +2162,7 @@ reapply_old_damage(struct terminal *term, struct buffer *new, struct buffer *old } if (new->age > 1) { - memcpy(new->data, old->data, new->size); + memcpy(new->data, old->data, new->height * new->stride); return; } diff --git a/shm.c b/shm.c index 26d1b839..cd26c62e 100644 --- a/shm.c +++ b/shm.c @@ -71,14 +71,15 @@ struct buffer_pool { struct buffer_private { struct buffer public; - bool busy; /* Owned by compositor */ + size_t size; + bool busy; /* Owned by compositor */ unsigned long cookie; struct buffer_pool *pool; - off_t offset; /* Offset into memfd where data begins */ + off_t offset; /* Offset into memfd where data begins */ bool scrollable; - bool purge; /* True if this buffer should be destroyed */ + bool purge; /* True if this buffer should be destroyed */ }; static tll(struct buffer_private) buffers; @@ -425,11 +426,11 @@ get_new_buffers(struct wl_shm *shm, size_t count, .width = info[i].width, .height = info[i].height, .stride = stride[i], - .size = sizes[i], .pix_instances = pix_instances, .age = 1234, /* Force a full repaint */ }, .cookie = info[i].cookie, + .size = sizes[i], .busy = true, .purge = immediate_purge, .pool = pool, @@ -443,7 +444,7 @@ get_new_buffers(struct wl_shm *shm, size_t count, pixman_region32_init(&buf->public.dirty); pool->ref_count++; - offset += buf->public.size; + offset += buf->size; bufs[i] = &buf->public; } @@ -583,11 +584,11 @@ wrap_buffer(struct wl_shm *shm, struct buffer_private *buf, off_t new_offset) off_t UNUSED diff = new_offset < buf->offset ? buf->offset - new_offset : new_offset - buf->offset; - xassert(diff > buf->public.size); + xassert(diff > buf->size); memcpy((uint8_t *)pool->real_mmapped + new_offset, buf->public.data, - buf->public.size); + buf->size); off_t trim_ofs, trim_len; if (new_offset > buf->offset) { @@ -596,7 +597,7 @@ wrap_buffer(struct wl_shm *shm, struct buffer_private *buf, off_t new_offset) trim_len = new_offset; } else { /* Trim everything *after* the new buffer location */ - trim_ofs = new_offset + buf->public.size; + trim_ofs = new_offset + buf->size; trim_len = pool->mmap_size - trim_ofs; } @@ -633,9 +634,9 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer_private *buf, int rows, const off_t diff = rows * buf->public.stride; xassert(rows > 0); - xassert(diff < buf->public.size); + xassert(diff < buf->size); - if (buf->offset + diff + buf->public.size > max_pool_size) { + if (buf->offset + diff + buf->size > max_pool_size) { LOG_DBG("memfd offset wrap around"); if (!wrap_buffer(shm, buf, 0)) goto err; @@ -643,7 +644,7 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer_private *buf, int rows, off_t new_offset = buf->offset + diff; xassert(new_offset > buf->offset); - xassert(new_offset + buf->public.size <= max_pool_size); + xassert(new_offset + buf->size <= max_pool_size); #if TIME_SCROLL struct timeval time1; @@ -704,7 +705,7 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer_private *buf, int rows, if (ret && bottom_keep_rows > 0) { /* Copy 'bottom' region to its new location */ - const size_t size = buf->public.size; + const size_t size = buf->size; const int stride = buf->public.stride; uint8_t *base = buf->public.data; @@ -742,7 +743,7 @@ shm_scroll_reverse(struct wl_shm *shm, struct buffer_private *buf, int rows, const off_t diff = rows * buf->public.stride; if (diff > buf->offset) { LOG_DBG("memfd offset reverse wrap-around"); - if (!wrap_buffer(shm, buf, (max_pool_size - buf->public.size) & ~(page_size() - 1))) + if (!wrap_buffer(shm, buf, (max_pool_size - buf->size) & ~(page_size() - 1))) goto err; } @@ -760,7 +761,7 @@ shm_scroll_reverse(struct wl_shm *shm, struct buffer_private *buf, int rows, if (bottom_keep_rows > 0) { /* Copy 'bottom' region to its new location */ - const size_t size = buf->public.size; + const size_t size = buf->size; const int stride = buf->public.stride; uint8_t *base = buf->public.data; @@ -780,7 +781,7 @@ shm_scroll_reverse(struct wl_shm *shm, struct buffer_private *buf, int rows, buffer_destroy_dont_close(&buf->public); /* Free unused memory - everything after the relocated buffer */ - const off_t trim_ofs = new_offset + buf->public.size; + const off_t trim_ofs = new_offset + buf->size; const off_t trim_len = pool->mmap_size - trim_ofs; if (fallocate( diff --git a/shm.h b/shm.h index dc37f1b7..435f9de4 100644 --- a/shm.h +++ b/shm.h @@ -16,8 +16,7 @@ struct buffer { int height; int stride; - size_t size; /* Buffer size */ - void *data; /* Raw data (TODO: rename) */ + void *data; struct wl_buffer *wl_buf; pixman_image_t **pix; -- cgit v1.3 From 69260dd9604f39f5e7270ac44502c7e60618500b Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Fri, 16 Jul 2021 16:47:15 +0200 Subject: shm: we may exit with busy buffers remaining (seen on KDE) --- render.c | 2 +- shm.c | 28 +++++++++++++++++++++------- 2 files changed, 22 insertions(+), 8 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index c48c515a..90fdae7b 100644 --- a/render.c +++ b/render.c @@ -2311,7 +2311,7 @@ grid_render(struct terminal *term) } else if (buf->age > 0) { - LOG_DBG("buffer age: %u", buf->age); + LOG_DBG("buffer age: %u (%p)", buf->age, (void *)buf); xassert(term->render.last_buf != NULL); xassert(term->render.last_buf != buf); diff --git a/shm.c b/shm.c index cd26c62e..87900f01 100644 --- a/shm.c +++ b/shm.c @@ -151,13 +151,26 @@ buffer_destroy(struct buffer_private *buf) void shm_fini(void) { - xassert(tll_length(buffers) == 0); + size_t busy_count UNUSED = 0; + size_t non_busy_count UNUSED = 0; tll_foreach(buffers, it) { + if (it->item.busy) + busy_count++; + else + non_busy_count++; + buffer_destroy(&it->item); tll_remove(buffers, it); } + LOG_DBG("buffers left: busy=%zu, non-busy=%zu", busy_count, non_busy_count); + + if (non_busy_count > 0) { + BUG("%zu non-busy buffers remaining (%zu buffers in total)", + non_busy_count, busy_count + non_busy_count); + } + #if defined(MEASURE_SHM_ALLOCS) && MEASURE_SHM_ALLOCS LOG_INFO("max total allocations was: %zu MB", max_alloced / 1024 / 1024); #endif @@ -272,8 +285,9 @@ destroy_all_purgeables(void) if (it->item.busy) continue; - LOG_DBG("cookie=%lx: purging buffer %p (width=%d, height=%d): %zu KB", - cookie, (void *)&it->item, it->item.width, it->item.height, + LOG_DBG("purging buffer %p (width=%d, height=%d): %zu KB", + (void *)&it->item, + it->item.public.width, it->item.public.height, it->item.size / 1024); buffer_destroy(&it->item); @@ -630,7 +644,7 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer_private *buf, int rows, xassert(pool->ref_count == 1); xassert(pool->fd >= 0); - LOG_DBG("scrolling %d rows (%d bytes)", rows, rows * buf->stride); + LOG_DBG("scrolling %d rows (%d bytes)", rows, rows * buf->public.stride); const off_t diff = rows * buf->public.stride; xassert(rows > 0); @@ -865,9 +879,9 @@ shm_purge(struct wl_shm *shm, unsigned long cookie) if (it->item.cookie != cookie) continue; - if (it->item.busy) { - LOG_WARN("deferring purge of 'busy' buffer (width=%d, height=%d)", - it->item.public.width, it->item.public.height); + if (it->item.busy) { + LOG_DBG("deferring purge of 'busy' buffer (width=%d, height=%d)", + it->item.public.width, it->item.public.height); it->item.purge = true; } else { buffer_destroy(&it->item); -- cgit v1.3 From 232fb20269b68157874f57d676c1b0b95c2386aa Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Fri, 16 Jul 2021 16:47:57 +0200 Subject: shm: replace 'locked' attribute with a ref-counter The initial ref-count is either 1 or 0, depending on whether the buffer is supposed to be released "immeidately" (meaning, as soon as the compositor releases it). Two new user facing functions have been added: shm_addref() and shm_unref(). Our renderer now uses these two functions instead of manually setting and clearing the 'locked' attribute. shm_unref() will decrement the ref-counter, and destroy the buffer when the counter reaches zero. Except if the buffer is currently "busy" (compositor owned), in which case destruction is deferred to the release event. The buffer is still removed from the list though. --- render.c | 12 ++++---- shm.c | 94 +++++++++++++++++++++++++++++++++----------------------------- shm.h | 5 ++-- terminal.c | 2 ++ 4 files changed, 60 insertions(+), 53 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 90fdae7b..c6835664 100644 --- a/render.c +++ b/render.c @@ -2324,19 +2324,18 @@ grid_render(struct terminal *term) } if (term->render.last_buf != NULL) { - term->render.last_buf->locked = false; - free(term->render.last_buf->scroll_damage); - term->render.last_buf->scroll_damage = NULL; + shm_unref(term->render.last_buf); + term->render.last_buf = NULL; } term->render.last_buf = buf; term->render.was_flashing = term->flash.active; term->render.was_searching = term->is_searching; - buf->locked = true; + shm_addref(buf); buf->age = 0; - xassert(buf->scroll_damage == NULL); + free(term->render.last_buf->scroll_damage); buf->scroll_damage_count = tll_length(term->grid->scroll_damage); buf->scroll_damage = xmalloc( buf->scroll_damage_count * sizeof(buf->scroll_damage[0])); @@ -3484,8 +3483,7 @@ damage_view: tll_free(term->normal.scroll_damage); tll_free(term->alt.scroll_damage); - if (term->render.last_buf != NULL) - term->render.last_buf->locked = false; + shm_unref(term->render.last_buf); term->render.last_buf = NULL; term_damage_view(term); render_refresh_csd(term); diff --git a/shm.c b/shm.c index 87900f01..a2f8cffe 100644 --- a/shm.c +++ b/shm.c @@ -71,6 +71,7 @@ struct buffer_pool { struct buffer_private { struct buffer public; + size_t ref_count; size_t size; bool busy; /* Owned by compositor */ @@ -79,7 +80,6 @@ struct buffer_private { off_t offset; /* Offset into memfd where data begins */ bool scrollable; - bool purge; /* True if this buffer should be destroyed */ }; static tll(struct buffer_private) buffers; @@ -148,6 +148,19 @@ buffer_destroy(struct buffer_private *buf) pixman_region32_fini(&buf->public.dirty); } +static bool +buffer_unref_no_remove_from_cache(struct buffer_private *buf) +{ + if (buf->ref_count > 0) + buf->ref_count--; + + if (buf->ref_count > 0 || buf->busy) + return false; + + buffer_destroy(buf); + return true; +} + void shm_fini(void) { @@ -187,6 +200,9 @@ buffer_release(void *data, struct wl_buffer *wl_buffer) xassert(buffer->public.wl_buf == wl_buffer); xassert(buffer->busy); buffer->busy = false; + + if (buffer->ref_count == 0) + shm_unref(&buffer->public); } static const struct wl_buffer_listener buffer_listener = { @@ -271,30 +287,6 @@ err: return false; } -static void NOINLINE -destroy_all_purgeables(void) -{ - /* Purge buffers marked for purging */ - tll_foreach(buffers, it) { - if (it->item.public.locked) - continue; - - if (!it->item.purge) - continue; - - if (it->item.busy) - continue; - - LOG_DBG("purging buffer %p (width=%d, height=%d): %zu KB", - (void *)&it->item, - it->item.public.width, it->item.public.height, - it->item.size / 1024); - - buffer_destroy(&it->item); - tll_remove(buffers, it); - } -} - static void NOINLINE get_new_buffers(struct wl_shm *shm, size_t count, struct buffer_description info[static count], @@ -444,9 +436,9 @@ get_new_buffers(struct wl_shm *shm, size_t count, .age = 1234, /* Force a full repaint */ }, .cookie = info[i].cookie, + .ref_count = immediate_purge ? 0 : 1, .size = sizes[i], .busy = true, - .purge = immediate_purge, .pool = pool, .scrollable = scrollable, .offset = 0, @@ -500,7 +492,6 @@ shm_get_many(struct wl_shm *shm, size_t count, struct buffer *bufs[static count], size_t pix_instances) { - destroy_all_purgeables(); get_new_buffers(shm, count, info, bufs, pix_instances, false, true); } @@ -508,8 +499,6 @@ struct buffer * shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, bool scrollable, size_t pix_instances) { - destroy_all_purgeables(); - struct buffer_private *cached = NULL; tll_foreach(buffers, it) { if (it->item.public.width != width) @@ -532,7 +521,6 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, LOG_DBG("cookie=%lx: re-using buffer from cache (buf=%p)", cookie, (void *)&it->item); it->item.busy = true; - it->item.purge = false; pixman_region32_clear(&it->item.public.dirty); free(it->item.public.scroll_damage); it->item.public.scroll_damage = NULL; @@ -543,10 +531,12 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, * re-use. Pick the “youngest” one, and mark the * other one for purging */ if (it->item.public.age < cached->public.age) { - cached->purge = true; + shm_unref(&cached->public); cached = &it->item; - } else - it->item.purge = true; + } else { + if (buffer_unref_no_remove_from_cache(&it->item)) + tll_remove(buffers, it); + } } } } @@ -559,14 +549,12 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, if (it->item.cookie != cookie) continue; - if (it->item.busy) - continue; - if (it->item.public.width == width && it->item.public.height == height) continue; LOG_DBG("cookie=%lx: marking buffer %p for purging", cookie, (void *)&it->item); - it->item.purge = true; + if (buffer_unref_no_remove_from_cache(&it->item)) + tll_remove(buffers, it); } struct buffer *ret; @@ -879,13 +867,31 @@ shm_purge(struct wl_shm *shm, unsigned long cookie) if (it->item.cookie != cookie) continue; - if (it->item.busy) { - LOG_DBG("deferring purge of 'busy' buffer (width=%d, height=%d)", - it->item.public.width, it->item.public.height); - it->item.purge = true; - } else { - buffer_destroy(&it->item); + if (buffer_unref_no_remove_from_cache(&it->item)) tll_remove(buffers, it); - } + } +} + +void +shm_addref(struct buffer *_buf) +{ + struct buffer_private *buf = (struct buffer_private *)_buf; + buf->ref_count++; +} + +void +shm_unref(struct buffer *_buf) +{ + if (_buf == NULL) + return; + + struct buffer_private *buf = (struct buffer_private *)_buf; + tll_foreach(buffers, it) { + if (&it->item != buf) + continue; + + if (buffer_unref_no_remove_from_cache(buf)) + tll_remove(buffers, it); + break; } } diff --git a/shm.h b/shm.h index 435f9de4..18941588 100644 --- a/shm.h +++ b/shm.h @@ -10,8 +10,6 @@ struct damage; struct buffer { - bool locked; /* Caller owned, shm won’t destroy it */ - int width; int height; int stride; @@ -23,6 +21,7 @@ struct buffer { size_t pix_instances; unsigned age; + struct damage *scroll_damage; size_t scroll_damage_count; pixman_region32_t dirty; @@ -74,6 +73,8 @@ bool shm_scroll(struct wl_shm *shm, struct buffer *buf, int rows, int top_margin, int top_keep_rows, int bottom_margin, int bottom_keep_rows); +void shm_addref(struct buffer *buf); +void shm_unref(struct buffer *buf); void shm_purge(struct wl_shm *shm, unsigned long cookie); struct terminal; diff --git a/terminal.c b/terminal.c index 488ac316..c7776f28 100644 --- a/terminal.c +++ b/terminal.c @@ -35,6 +35,7 @@ #include "selection.h" #include "sixel.h" #include "slave.h" +#include "shm.h" #include "spawn.h" #include "url-mode.h" #include "util.h" @@ -1457,6 +1458,7 @@ term_destroy(struct terminal *term) sem_destroy(&term->render.workers.done); xassert(tll_length(term->render.workers.queue) == 0); tll_free(term->render.workers.queue); + shm_unref(term->render.last_buf); tll_free(term->tab_stops); -- cgit v1.3 From 53851e13ec976001cdec2077d7963c292bcd6d20 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Fri, 16 Jul 2021 16:48:49 +0200 Subject: shm: refactor: move away from a single, global, buffer list MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Up until now, *all* buffers have been tracked in a single, global buffer list. We've used 'cookies' to separate buffers from different contexts (so that shm_get_buffer() doesn't try to re-use e.g. a search-box buffer for the main grid). This patch refactors this, and completely removes the global list. Instead of cookies, we now use 'chains'. A chain tracks both the properties to apply to newly created buffers (scrollable, number of pixman instances to instantiate etc), as well as the instantiated buffers themselves. This means there's strictly speaking not much use for shm_fini() anymore, since its up to the chain owner to call shm_chain_free(), which will also purge all buffers. However, since purging a buffer may be deferred, if the buffer is owned by the compositor at the time of the call to shm_purge() or shm_chain_free(), we still keep a global 'deferred' list, on to which deferred buffers are pushed. shm_fini() iterates this list and destroys the buffers _even_ if they are still owned by the compositor. This only happens at program termination, and not when destroying a terminal instance. I.e. closing a window in a “foot --server” does *not* trigger this. Each terminal instatiates a number of chains, and these chains are destroyed when the terminal instance is destroyed. Note that some buffers may be put on the deferred list, as mentioned above. --- render.c | 49 +++++++------- shm.c | 215 ++++++++++++++++++++++++++++++++----------------------------- shm.h | 39 ++++------- terminal.c | 25 +++++++ terminal.h | 10 +++ wayland.c | 16 ++--- 6 files changed, 190 insertions(+), 164 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index c6835664..7bcad519 100644 --- a/render.c +++ b/render.c @@ -943,7 +943,7 @@ grid_render_scroll(struct terminal *term, struct buffer *buf, if (try_shm_scroll) { did_shm_scroll = shm_scroll( - term->wl->shm, buf, dmg->lines * term->cell_height, + buf, dmg->lines * term->cell_height, term->margins.top, dmg->region.start * term->cell_height, term->margins.bottom, (term->rows - dmg->region.end) * term->cell_height); } @@ -1008,7 +1008,7 @@ grid_render_scroll_reverse(struct terminal *term, struct buffer *buf, if (try_shm_scroll) { did_shm_scroll = shm_scroll( - term->wl->shm, buf, -dmg->lines * term->cell_height, + buf, -dmg->lines * term->cell_height, term->margins.top, dmg->region.start * term->cell_height, term->margins.bottom, (term->rows - dmg->region.end) * term->cell_height); } @@ -1587,9 +1587,8 @@ render_csd_title(struct terminal *term) xassert(info.width % term->scale == 0); xassert(info.height % term->scale == 0); - unsigned long cookie = shm_cookie_csd(term, CSD_SURF_TITLE); - struct buffer *buf = shm_get_buffer( - term->wl->shm, info.width, info.height, cookie, false, 1); + struct buffer_chain *chain = term->render.chains.csd[CSD_SURF_TITLE]; + struct buffer *buf = shm_get_buffer(chain, info.width, info.height); uint32_t _color = term->conf->colors.fg; uint16_t alpha = 0xffff; @@ -1622,9 +1621,8 @@ render_csd_border(struct terminal *term, enum csd_surface surf_idx) xassert(info.width % term->scale == 0); xassert(info.height % term->scale == 0); - unsigned long cookie = shm_cookie_csd(term, surf_idx); - struct buffer *buf = shm_get_buffer( - term->wl->shm, info.width, info.height, cookie, false, 1); + struct buffer_chain *chain = term->render.chains.csd[surf_idx]; + struct buffer *buf = shm_get_buffer(chain, info.width, info.height); pixman_color_t color = color_hex_to_pixman_with_alpha(0, 0); render_csd_part(term, surf, buf, info.width, info.height, &color); @@ -1808,9 +1806,8 @@ render_csd_button(struct terminal *term, enum csd_surface surf_idx) xassert(info.width % term->scale == 0); xassert(info.height % term->scale == 0); - unsigned long cookie = shm_cookie_csd(term, surf_idx); - struct buffer *buf = shm_get_buffer( - term->wl->shm, info.width, info.height, cookie, false, 1); + struct buffer_chain *chain = term->render.chains.csd[surf_idx]; + struct buffer *buf = shm_get_buffer(chain, info.width, info.height); uint32_t _color; uint16_t alpha = 0xffff; @@ -2084,9 +2081,8 @@ render_scrollback_position(struct terminal *term) return; } - unsigned long cookie = shm_cookie_scrollback_indicator(term); - struct buffer *buf = shm_get_buffer( - term->wl->shm, width, height, cookie, false, 1); + struct buffer_chain *chain = term->render.chains.scrollback_indicator; + struct buffer *buf = shm_get_buffer(chain, width, height); wl_subsurface_set_position( win->scrollback_indicator.sub, x / scale, y / scale); @@ -2117,9 +2113,8 @@ render_render_timer(struct terminal *term, struct timeval render_time) const int height = (2 * margin + term->cell_height + scale - 1) / scale * scale; - unsigned long cookie = shm_cookie_render_timer(term); - struct buffer *buf = shm_get_buffer( - term->wl->shm, width, height, cookie, false, 1); + struct buffer_chain *chain = term->render.chains.render_timer; + struct buffer *buf = shm_get_buffer(chain, width, height); wl_subsurface_set_position( win->render_timer.sub, @@ -2292,9 +2287,8 @@ grid_render(struct terminal *term) xassert(term->width > 0); xassert(term->height > 0); - unsigned long cookie = shm_cookie_grid(term); - struct buffer *buf = shm_get_buffer( - term->wl->shm, term->width, term->height, cookie, true, 1 + term->render.workers.count); + struct buffer_chain *chain = term->render.chains.grid; + struct buffer *buf = shm_get_buffer(chain, term->width, term->height); /* Dirty old and current cursor cell, to ensure they’re repainted */ dirty_old_cursor(term); @@ -2626,8 +2620,8 @@ render_search_box(struct terminal *term) const size_t visible_cells = (visible_width - 2 * margin) / term->cell_width; size_t glyph_offset = term->render.search_glyph_offset; - unsigned long cookie = shm_cookie_search(term); - struct buffer *buf = shm_get_buffer(term->wl->shm, width, height, cookie, false, 1); + struct buffer_chain *chain = term->render.chains.search; + struct buffer *buf = shm_get_buffer(chain, width, height); pixman_region32_t clip; pixman_region32_init_rect(&clip, 0, 0, width, height); @@ -2936,7 +2930,8 @@ render_urls(struct terminal *term) } info[tll_length(win->urls)]; /* For shm_get_many() */ - struct buffer_description shm_desc[tll_length(win->urls)]; + int widths[tll_length(win->urls)]; + int heights[tll_length(win->urls)]; size_t render_count = 0; @@ -3066,15 +3061,15 @@ render_urls(struct terminal *term) info[render_count].x = x; info[render_count].y = y; - shm_desc[render_count].width = width; - shm_desc[render_count].height = height; - shm_desc[render_count].cookie = shm_cookie_url(url); + widths[render_count] = width; + heights[render_count] = height; render_count++; } + struct buffer_chain *chain = term->render.chains.url; struct buffer *bufs[render_count]; - shm_get_many(term->wl->shm, render_count, shm_desc, bufs, 1); + shm_get_many(chain, render_count, widths, heights, bufs); uint32_t fg = term->conf->colors.use_custom.jump_label ? term->conf->colors.jump_label.fg diff --git a/shm.c b/shm.c index d5c94c8b..acc14a68 100644 --- a/shm.c +++ b/shm.c @@ -68,21 +68,28 @@ struct buffer_pool { size_t ref_count; }; +struct buffer_chain; struct buffer_private { struct buffer public; + struct buffer_chain *chain; size_t ref_count; - size_t size; bool busy; /* Owned by compositor */ - unsigned long cookie; struct buffer_pool *pool; off_t offset; /* Offset into memfd where data begins */ + size_t size; + + bool scrollable; +}; +struct buffer_chain { + tll(struct buffer_private *) bufs; + struct wl_shm *shm; + size_t pix_instances; bool scrollable; }; -static tll(struct buffer_private *) buffers; static tll(struct buffer_private *) deferred; #undef MEASURE_SHM_ALLOCS @@ -151,7 +158,7 @@ buffer_destroy(struct buffer_private *buf) } static bool -buffer_unref_no_remove_from_cache(struct buffer_private *buf) +buffer_unref_no_remove_from_chain(struct buffer_private *buf) { xassert(buf->ref_count > 0); buf->ref_count--; @@ -169,34 +176,13 @@ buffer_unref_no_remove_from_cache(struct buffer_private *buf) void shm_fini(void) { - size_t busy_count UNUSED = 0; - size_t non_busy_count UNUSED = 0; - - tll_foreach(buffers, it) { - if (it->item->busy) - busy_count++; - else - non_busy_count++; - - buffer_destroy(it->item); - tll_remove(buffers, it); - } - - xassert(busy_count == 0); - busy_count = tll_length(deferred); + LOG_DBG("deferred buffers: %zu", tll_length(deferred)); tll_foreach(deferred, it) { buffer_destroy(it->item); tll_remove(deferred, it); } - LOG_DBG("buffers left: busy=%zu, non-busy=%zu", busy_count, non_busy_count); - - if (non_busy_count > 0) { - BUG("%zu non-busy buffers remaining (%zu buffers in total)", - non_busy_count, busy_count + non_busy_count); - } - #if defined(MEASURE_SHM_ALLOCS) && MEASURE_SHM_ALLOCS LOG_INFO("max total allocations was: %zu MB", max_alloced / 1024 / 1024); #endif @@ -207,27 +193,25 @@ buffer_release(void *data, struct wl_buffer *wl_buffer) { struct buffer_private *buffer = data; - LOG_DBG("release: cookie=%lx (buf=%p, total buffer count: %zu)", - buffer->cookie, (void *)buffer, tll_length(buffers)); - xassert(buffer->public.wl_buf == wl_buffer); xassert(buffer->busy); buffer->busy = false; if (buffer->ref_count == 0) { - LOG_WARN("deferred delete"); - bool found = false; tll_foreach(deferred, it) { if (it->item == buffer) { found = true; - buffer_destroy(buffer); tll_remove(deferred, it); break; } } + buffer_destroy(buffer); + xassert(found); + if (!found) + LOG_WARN("deferred delete: buffer not on the 'deferred' list"); } } @@ -255,7 +239,7 @@ page_size(void) #endif static bool -instantiate_offset(struct wl_shm *shm, struct buffer_private *buf, off_t new_offset) +instantiate_offset(struct buffer_private *buf, off_t new_offset) { xassert(buf->public.data == NULL); xassert(buf->public.pix == NULL); @@ -314,12 +298,11 @@ err: } static void NOINLINE -get_new_buffers(struct wl_shm *shm, size_t count, - struct buffer_description info[static count], - struct buffer *bufs[static count], - size_t pix_instances, bool scrollable, bool immediate_purge) +get_new_buffers(struct buffer_chain *chain, size_t count, + int widths[static count], int heights[static count], + struct buffer *bufs[static count], bool immediate_purge) { - xassert(count == 1 || !scrollable); + xassert(count == 1 || !chain->scrollable); /* * No existing buffer available. Create a new one by: * @@ -335,8 +318,8 @@ get_new_buffers(struct wl_shm *shm, size_t count, size_t total_size = 0; for (size_t i = 0; i < count; i++) { - stride[i] = stride_for_format_and_width(PIXMAN_a8r8g8b8, info[i].width); - sizes[i] = stride[i] * info[i].height; + stride[i] = stride_for_format_and_width(PIXMAN_a8r8g8b8, widths[i]); + sizes[i] = stride[i] * heights[i]; total_size += sizes[i]; } @@ -363,14 +346,18 @@ get_new_buffers(struct wl_shm *shm, size_t count, } #if __SIZEOF_POINTER__ == 8 - off_t offset = scrollable && max_pool_size > 0 ? (max_pool_size / 4) & ~(page_size() - 1) : 0; - off_t memfd_size = scrollable && max_pool_size > 0 ? max_pool_size : total_size; + off_t offset = chain->scrollable && max_pool_size > 0 + ? (max_pool_size / 4) & ~(page_size() - 1) + : 0; + off_t memfd_size = chain->scrollable && max_pool_size > 0 + ? max_pool_size + : total_size; #else off_t offset = 0; off_t memfd_size = total_size; #endif - xassert(scrollable || (offset == 0 && memfd_size == total_size)); + xassert(chain->scrollable || (offset == 0 && memfd_size == total_size)); LOG_DBG("memfd-size: %lu, initial offset: %lu", memfd_size, offset); @@ -397,10 +384,10 @@ get_new_buffers(struct wl_shm *shm, size_t count, #endif } - if (scrollable && !can_punch_hole) { + if (chain->scrollable && !can_punch_hole) { offset = 0; memfd_size = total_size; - scrollable = false; + chain->scrollable = false; if (ftruncate(pool_fd, memfd_size) < 0) { LOG_ERRNO("failed to set size of SHM backing memory file"); @@ -428,13 +415,13 @@ get_new_buffers(struct wl_shm *shm, size_t count, } #endif - wl_pool = wl_shm_create_pool(shm, pool_fd, memfd_size); + wl_pool = wl_shm_create_pool(chain->shm, pool_fd, memfd_size); if (wl_pool == NULL) { LOG_ERR("failed to create SHM pool"); goto err; } - pool = malloc(sizeof(*pool)); + pool = xmalloc(sizeof(*pool)); if (pool == NULL) { LOG_ERRNO("failed to allocate buffer pool"); goto err; @@ -454,22 +441,22 @@ get_new_buffers(struct wl_shm *shm, size_t count, struct buffer_private *buf = xmalloc(sizeof(*buf)); *buf = (struct buffer_private){ .public = { - .width = info[i].width, - .height = info[i].height, + .width = widths[i], + .height = heights[i], .stride = stride[i], - .pix_instances = pix_instances, + .pix_instances = chain->pix_instances, .age = 1234, /* Force a full repaint */ }, - .cookie = info[i].cookie, + .chain = chain, .ref_count = immediate_purge ? 0 : 1, - .size = sizes[i], .busy = true, .pool = pool, - .scrollable = scrollable, .offset = 0, + .size = sizes[i], + .scrollable = chain->scrollable, }; - if (!instantiate_offset(shm, buf, offset)) { + if (!instantiate_offset(buf, offset)) { free(buf); goto err; } @@ -477,7 +464,7 @@ get_new_buffers(struct wl_shm *shm, size_t count, if (immediate_purge) tll_push_front(deferred, buf); else - tll_push_front(buffers, buf); + tll_push_front(chain->bufs, buf); pixman_region32_init(&buf->public.dirty); pool->ref_count++; @@ -518,28 +505,24 @@ err: } void -shm_get_many(struct wl_shm *shm, size_t count, - struct buffer_description info[static count], - struct buffer *bufs[static count], - size_t pix_instances) +shm_get_many(struct buffer_chain *chain, size_t count, + int widths[static count], int heights[static count], + struct buffer *bufs[static count]) { - get_new_buffers(shm, count, info, bufs, pix_instances, false, true); + get_new_buffers(chain, count, widths, heights, bufs, true); } struct buffer * -shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, - bool scrollable, size_t pix_instances) +shm_get_buffer(struct buffer_chain *chain, int width, int height) { struct buffer_private *cached = NULL; - tll_foreach(buffers, it) { + tll_foreach(chain->bufs, it) { struct buffer_private *buf = it->item; if (buf->public.width != width) continue; if (buf->public.height != height) continue; - if (buf->cookie != cookie) - continue; if (buf->busy) buf->public.age++; @@ -551,13 +534,12 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, #endif { if (cached == NULL) { - LOG_DBG("cookie=%lx: re-using buffer from cache (buf=%p)", - cookie, (void *)buf); + LOG_DBG("re-using buffer %p from cache", (void *)buf); buf->busy = true; pixman_region32_clear(&buf->public.dirty); free(buf->public.scroll_damage); buf->public.scroll_damage = NULL; - xassert(buf->public.pix_instances == pix_instances); + xassert(buf->public.pix_instances == chain->pix_instances); cached = it->item; } else { /* We have multiple buffers eligible for @@ -567,8 +549,8 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, shm_unref(&cached->public); cached = buf; } else { - if (buffer_unref_no_remove_from_cache(buf)) - tll_remove(buffers, it); + if (buffer_unref_no_remove_from_chain(buf)) + tll_remove(chain->bufs, it); } } } @@ -578,23 +560,19 @@ shm_get_buffer(struct wl_shm *shm, int width, int height, unsigned long cookie, return &cached->public; /* Mark old buffers associated with this cookie for purging */ - tll_foreach(buffers, it) { + tll_foreach(chain->bufs, it) { struct buffer_private *buf = it->item; - if (buf->cookie != cookie) - continue; - if (buf->public.width == width && buf->public.height == height) continue; - LOG_DBG("cookie=%lx: marking buffer %p for purging", cookie, (void *)buf); - if (buffer_unref_no_remove_from_cache(buf)) - tll_remove(buffers, it); + LOG_DBG("marking buffer %p for purging", (void *)buf); + if (buffer_unref_no_remove_from_chain(buf)) + tll_remove(chain->bufs, it); } struct buffer *ret; - get_new_buffers(shm, 1, &(struct buffer_description){width, height, cookie}, - &ret, pix_instances, scrollable, false); + get_new_buffers(chain, 1, &width, &height, &ret, false); return ret; } @@ -612,7 +590,7 @@ shm_can_scroll(const struct buffer *_buf) #if __SIZEOF_POINTER__ == 8 && defined(FALLOC_FL_PUNCH_HOLE) static bool -wrap_buffer(struct wl_shm *shm, struct buffer_private *buf, off_t new_offset) +wrap_buffer(struct buffer_private *buf, off_t new_offset) { struct buffer_pool *pool = buf->pool; xassert(pool->ref_count == 1); @@ -649,11 +627,11 @@ wrap_buffer(struct wl_shm *shm, struct buffer_private *buf, off_t new_offset) /* Re-instantiate pixman+wl_buffer+raw pointersw */ buffer_destroy_dont_close(&buf->public); - return instantiate_offset(shm, buf, new_offset); + return instantiate_offset(buf, new_offset); } static bool -shm_scroll_forward(struct wl_shm *shm, struct buffer_private *buf, int rows, +shm_scroll_forward(struct buffer_private *buf, int rows, int top_margin, int top_keep_rows, int bottom_margin, int bottom_keep_rows) { @@ -675,7 +653,7 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer_private *buf, int rows, if (buf->offset + diff + buf->size > max_pool_size) { LOG_DBG("memfd offset wrap around"); - if (!wrap_buffer(shm, buf, 0)) + if (!wrap_buffer(buf, 0)) goto err; } @@ -684,6 +662,7 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer_private *buf, int rows, xassert(new_offset + buf->size <= max_pool_size); #if TIME_SCROLL + struct timeval tot; struct timeval time1; gettimeofday(&time1, NULL); @@ -731,7 +710,7 @@ shm_scroll_forward(struct wl_shm *shm, struct buffer_private *buf, int rows, #endif /* Re-instantiate pixman+wl_buffer+raw pointersw */ - bool ret = instantiate_offset(shm, buf, new_offset); + bool ret = instantiate_offset(buf, new_offset); #if TIME_SCROLL struct timeval time4; @@ -768,7 +747,7 @@ err: } static bool -shm_scroll_reverse(struct wl_shm *shm, struct buffer_private *buf, int rows, +shm_scroll_reverse(struct buffer_private *buf, int rows, int top_margin, int top_keep_rows, int bottom_margin, int bottom_keep_rows) { @@ -780,7 +759,7 @@ shm_scroll_reverse(struct wl_shm *shm, struct buffer_private *buf, int rows, const off_t diff = rows * buf->public.stride; if (diff > buf->offset) { LOG_DBG("memfd offset reverse wrap-around"); - if (!wrap_buffer(shm, buf, (max_pool_size - buf->size) & ~(page_size() - 1))) + if (!wrap_buffer(buf, (max_pool_size - buf->size) & ~(page_size() - 1))) goto err; } @@ -837,7 +816,7 @@ shm_scroll_reverse(struct wl_shm *shm, struct buffer_private *buf, int rows, #endif /* Re-instantiate pixman+wl_buffer+raw pointers */ - bool ret = instantiate_offset(shm, buf, new_offset); + bool ret = instantiate_offset(buf, new_offset); #if TIME_SCROLL struct timeval time3; @@ -873,7 +852,7 @@ err: #endif /* FALLOC_FL_PUNCH_HOLE */ bool -shm_scroll(struct wl_shm *shm, struct buffer *_buf, int rows, +shm_scroll(struct buffer *_buf, int rows, int top_margin, int top_keep_rows, int bottom_margin, int bottom_keep_rows) { @@ -885,27 +864,22 @@ shm_scroll(struct wl_shm *shm, struct buffer *_buf, int rows, xassert(rows != 0); return rows > 0 - ? shm_scroll_forward(shm, buf, rows, top_margin, top_keep_rows, bottom_margin, bottom_keep_rows) - : shm_scroll_reverse(shm, buf, -rows, top_margin, top_keep_rows, bottom_margin, bottom_keep_rows); + ? shm_scroll_forward(buf, rows, top_margin, top_keep_rows, bottom_margin, bottom_keep_rows) + : shm_scroll_reverse(buf, -rows, top_margin, top_keep_rows, bottom_margin, bottom_keep_rows); #else return false; #endif } void -shm_purge(struct wl_shm *shm, unsigned long cookie) +shm_purge(struct buffer_chain *chain) { - LOG_DBG("cookie=%lx: purging all buffers", cookie); + LOG_DBG("chain: %p: purging all buffers", (void *)chain); /* Purge old buffers associated with this cookie */ - tll_foreach(buffers, it) { - struct buffer_private *buf = it->item; - - if (buf->cookie != cookie) - continue; - - if (buffer_unref_no_remove_from_cache(buf)) - tll_remove(buffers, it); + tll_foreach(chain->bufs, it) { + if (buffer_unref_no_remove_from_chain(it->item)) + tll_remove(chain->bufs, it); } } @@ -923,12 +897,47 @@ shm_unref(struct buffer *_buf) return; struct buffer_private *buf = (struct buffer_private *)_buf; - tll_foreach(buffers, it) { + struct buffer_chain *chain = buf->chain; + + tll_foreach(chain->bufs, it) { if (it->item != buf) continue; - if (buffer_unref_no_remove_from_cache(buf)) - tll_remove(buffers, it); + if (buffer_unref_no_remove_from_chain(buf)) + tll_remove(chain->bufs, it); break; } } + +void +shm_chain_purge(struct buffer_chain *chain) +{ + tll_foreach(chain->bufs, it) { + struct buffer_private *buf = it->item; + if (buffer_unref_no_remove_from_chain(buf)) + tll_remove(chain->bufs, it); + } +} + +struct buffer_chain * +shm_chain_new(struct wl_shm *shm, bool scrollable, size_t pix_instances) +{ + struct buffer_chain *chain = xmalloc(sizeof(*chain)); + *chain = (struct buffer_chain){ + .bufs = tll_init(), + .shm = shm, + .pix_instances = pix_instances, + .scrollable = scrollable, + }; + return chain; +} + +void +shm_chain_free(struct buffer_chain *chain) +{ + if (chain == NULL) + return; + + shm_chain_purge(chain); + free(chain); +} diff --git a/shm.h b/shm.h index 18941588..180c8525 100644 --- a/shm.h +++ b/shm.h @@ -7,6 +7,8 @@ #include #include +#include + struct damage; struct buffer { @@ -27,28 +29,24 @@ struct buffer { pixman_region32_t dirty; }; -struct buffer_description { - int width; - int height; - unsigned long cookie; -}; - void shm_fini(void); void shm_set_max_pool_size(off_t max_pool_size); +struct buffer_chain; +struct buffer_chain *shm_chain_new( + struct wl_shm *shm, bool scrollable, size_t pix_instances); +void shm_chain_free(struct buffer_chain *chain); + /* * Returns a single buffer. * * May returned a cached buffer. If so, the buffer’s age indicates how * many shm_get_buffer() calls have been made for the same - * width/height/cookie while the buffer was still busy. + * width/height while the buffer was still busy. * * A newly allocated buffer has an age of 1234. */ -struct buffer *shm_get_buffer( - struct wl_shm *shm, int width, int height, unsigned long cookie, - bool scrollable, size_t pix_instances); - +struct buffer *shm_get_buffer(struct buffer_chain *chain, int width, int height); /* * Returns many buffers, described by ‘info’, all sharing the same SHM * buffer pool. @@ -64,25 +62,16 @@ struct buffer *shm_get_buffer( * soon as the compositor releases them. */ void shm_get_many( - struct wl_shm *shm, size_t count, - struct buffer_description info[static count], - struct buffer *bufs[static count], size_t pix_instances); + struct buffer_chain *chain, size_t count, + int widths[static count], int heights[static count], + struct buffer *bufs[static count]); bool shm_can_scroll(const struct buffer *buf); -bool shm_scroll(struct wl_shm *shm, struct buffer *buf, int rows, +bool shm_scroll(struct buffer *buf, int rows, int top_margin, int top_keep_rows, int bottom_margin, int bottom_keep_rows); void shm_addref(struct buffer *buf); void shm_unref(struct buffer *buf); -void shm_purge(struct wl_shm *shm, unsigned long cookie); - -struct terminal; -static inline unsigned long shm_cookie_grid(const struct terminal *term) { return (unsigned long)((uintptr_t)term + 0); } -static inline unsigned long shm_cookie_search(const struct terminal *term) { return (unsigned long)((uintptr_t)term + 1); } -static inline unsigned long shm_cookie_scrollback_indicator(const struct terminal *term) { return (unsigned long)(uintptr_t)term + 2; } -static inline unsigned long shm_cookie_render_timer(const struct terminal *term) { return (unsigned long)(uintptr_t)term + 3; } -static inline unsigned long shm_cookie_csd(const struct terminal *term, int n) { return (unsigned long)((uintptr_t)term + 4 + (n)); } -struct url; -static inline unsigned long shm_cookie_url(const struct url *url) { return (unsigned long)(uintptr_t)url; } +void shm_purge(struct buffer_chain *chain); diff --git a/terminal.c b/terminal.c index c7776f28..72ab1f2b 100644 --- a/terminal.c +++ b/terminal.c @@ -1144,6 +1144,23 @@ term_init(const struct config *conf, struct fdm *fdm, struct reaper *reaper, .tab_stops = tll_init(), .wl = wayl, .render = { + .chains = { + .grid = shm_chain_new(wayl->shm, true, 1 + conf->render_worker_count), + .search = shm_chain_new(wayl->shm, false, 1), + .scrollback_indicator = shm_chain_new(wayl->shm, false, 1), + .render_timer = shm_chain_new(wayl->shm, false, 1), + .url = shm_chain_new(wayl->shm, false, 1), + .csd = { + [CSD_SURF_TITLE] = shm_chain_new(wayl->shm, false, 1), + [CSD_SURF_LEFT] = shm_chain_new(wayl->shm, false, 1), + [CSD_SURF_RIGHT] = shm_chain_new(wayl->shm, false, 1), + [CSD_SURF_TOP] = shm_chain_new(wayl->shm, false, 1), + [CSD_SURF_BOTTOM] = shm_chain_new(wayl->shm, false, 1), + [CSD_SURF_MINIMIZE] = shm_chain_new(wayl->shm, false, 1), + [CSD_SURF_MAXIMIZE] = shm_chain_new(wayl->shm, false, 1), + [CSD_SURF_CLOSE] = shm_chain_new(wayl->shm, false, 1), + }, + }, .scrollback_lines = conf->scrollback.lines, .app_sync_updates.timer_fd = app_sync_updates_fd, .title = { @@ -1458,7 +1475,15 @@ term_destroy(struct terminal *term) sem_destroy(&term->render.workers.done); xassert(tll_length(term->render.workers.queue) == 0); tll_free(term->render.workers.queue); + shm_unref(term->render.last_buf); + shm_chain_free(term->render.chains.grid); + shm_chain_free(term->render.chains.search); + shm_chain_free(term->render.chains.scrollback_indicator); + shm_chain_free(term->render.chains.render_timer); + shm_chain_free(term->render.chains.url); + for (size_t i = 0; i < CSD_SURF_COUNT; i++) + shm_chain_free(term->render.chains.csd[i]); tll_free(term->tab_stops); diff --git a/terminal.h b/terminal.h index 5ffa6154..b02036a2 100644 --- a/terminal.h +++ b/terminal.h @@ -21,6 +21,7 @@ #include "fdm.h" #include "macros.h" #include "reaper.h" +#include "shm.h" #include "wayland.h" /* @@ -475,6 +476,15 @@ struct terminal { enum term_surface active_surface; struct { + struct { + struct buffer_chain *grid; + struct buffer_chain *search; + struct buffer_chain *scrollback_indicator; + struct buffer_chain *render_timer; + struct buffer_chain *url; + struct buffer_chain *csd[CSD_SURF_COUNT]; + } chains; + /* Scheduled for rendering, as soon-as-possible */ struct { bool grid; diff --git a/wayland.c b/wayland.c index 880a4cf3..38c80999 100644 --- a/wayland.c +++ b/wayland.c @@ -52,11 +52,10 @@ static void csd_destroy(struct wl_window *win) { struct terminal *term = win->term; - struct wl_shm *shm = term->wl->shm; for (size_t i = 0; i < ALEN(win->csd.surface); i++) { wayl_win_subsurface_destroy(&win->csd.surface[i]); - shm_purge(shm, shm_cookie_csd(term, i)); + shm_purge(term->render.chains.csd[i]); } } @@ -1417,7 +1416,6 @@ wayl_win_destroy(struct wl_window *win) return; struct terminal *term = win->term; - struct wl_shm *shm = term->wl->shm; if (win->csd.move_timeout_fd != -1) close(win->csd.move_timeout_fd); @@ -1472,7 +1470,7 @@ wayl_win_destroy(struct wl_window *win) tll_foreach(win->urls, it) { wayl_win_subsurface_destroy(&it->item.surf); - shm_purge(shm, shm_cookie_url(it->item.url)); + shm_purge(term->render.chains.url); tll_remove(win->urls, it); } @@ -1481,13 +1479,13 @@ wayl_win_destroy(struct wl_window *win) wayl_win_subsurface_destroy(&win->scrollback_indicator); wayl_win_subsurface_destroy(&win->render_timer); - shm_purge(shm, shm_cookie_search(term)); - shm_purge(shm, shm_cookie_scrollback_indicator(term)); - shm_purge(shm, shm_cookie_render_timer(term)); - shm_purge(shm, shm_cookie_grid(term)); + shm_purge(term->render.chains.search); + shm_purge(term->render.chains.scrollback_indicator); + shm_purge(term->render.chains.render_timer); + shm_purge(term->render.chains.grid); for (size_t i = 0; i < ALEN(win->csd.surface); i++) - shm_purge(shm, shm_cookie_csd(term, i)); + shm_purge(term->render.chains.csd[i]); #if defined(HAVE_XDG_ACTIVATION) if (win->xdg_activation_token != NULL) -- cgit v1.3 From 20fc80e57e365f2e002eead7de110cb23ffa7adc Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sun, 18 Jul 2021 16:46:43 +0200 Subject: render: use a single backing SHM pool for CSD surface buffers --- render.c | 73 +++++++++++++++++++++++++++++++------------------------------- terminal.c | 14 ++---------- terminal.h | 2 +- wayland.c | 11 ++++------ 4 files changed, 44 insertions(+), 56 deletions(-) (limited to 'render.c') diff --git a/render.c b/render.c index 7bcad519..7750dd19 100644 --- a/render.c +++ b/render.c @@ -1575,20 +1575,16 @@ render_csd_part(struct terminal *term, } static void -render_csd_title(struct terminal *term) +render_csd_title(struct terminal *term, const struct csd_data *info, + struct buffer *buf) { xassert(term->window->csd_mode == CSD_YES); - struct csd_data info = get_csd_data(term, CSD_SURF_TITLE); struct wl_surface *surf = term->window->csd.surface[CSD_SURF_TITLE].surf; + xassert(info->width > 0 && info->height > 0); - xassert(info.width > 0 && info.height > 0); - - xassert(info.width % term->scale == 0); - xassert(info.height % term->scale == 0); - - struct buffer_chain *chain = term->render.chains.csd[CSD_SURF_TITLE]; - struct buffer *buf = shm_get_buffer(chain, info.width, info.height); + xassert(info->width % term->scale == 0); + xassert(info->height % term->scale == 0); uint32_t _color = term->conf->colors.fg; uint16_t alpha = 0xffff; @@ -1602,30 +1598,27 @@ render_csd_title(struct terminal *term) _color = color_dim(_color); pixman_color_t color = color_hex_to_pixman_with_alpha(_color, alpha); - render_csd_part(term, surf, buf, info.width, info.height, &color); + render_csd_part(term, surf, buf, info->width, info->height, &color); csd_commit(term, surf, buf); } static void -render_csd_border(struct terminal *term, enum csd_surface surf_idx) +render_csd_border(struct terminal *term, enum csd_surface surf_idx, + const struct csd_data *info, struct buffer *buf) { xassert(term->window->csd_mode == CSD_YES); xassert(surf_idx >= CSD_SURF_LEFT && surf_idx <= CSD_SURF_BOTTOM); - struct csd_data info = get_csd_data(term, surf_idx); struct wl_surface *surf = term->window->csd.surface[surf_idx].surf; - if (info.width == 0 || info.height == 0) + if (info->width == 0 || info->height == 0) return; - xassert(info.width % term->scale == 0); - xassert(info.height % term->scale == 0); - - struct buffer_chain *chain = term->render.chains.csd[surf_idx]; - struct buffer *buf = shm_get_buffer(chain, info.width, info.height); + xassert(info->width % term->scale == 0); + xassert(info->height % term->scale == 0); pixman_color_t color = color_hex_to_pixman_with_alpha(0, 0); - render_csd_part(term, surf, buf, info.width, info.height, &color); + render_csd_part(term, surf, buf, info->width, info->height, &color); csd_commit(term, surf, buf); } @@ -1792,22 +1785,19 @@ render_csd_button_close(struct terminal *term, struct buffer *buf) } static void -render_csd_button(struct terminal *term, enum csd_surface surf_idx) +render_csd_button(struct terminal *term, enum csd_surface surf_idx, + const struct csd_data *info, struct buffer *buf) { xassert(term->window->csd_mode == CSD_YES); xassert(surf_idx >= CSD_SURF_MINIMIZE && surf_idx <= CSD_SURF_CLOSE); - struct csd_data info = get_csd_data(term, surf_idx); struct wl_surface *surf = term->window->csd.surface[surf_idx].surf; - if (info.width == 0 || info.height == 0) + if (info->width == 0 || info->height == 0) return; - xassert(info.width % term->scale == 0); - xassert(info.height % term->scale == 0); - - struct buffer_chain *chain = term->render.chains.csd[surf_idx]; - struct buffer *buf = shm_get_buffer(chain, info.width, info.height); + xassert(info->width % term->scale == 0); + xassert(info->height % term->scale == 0); uint32_t _color; uint16_t alpha = 0xffff; @@ -1856,7 +1846,7 @@ render_csd_button(struct terminal *term, enum csd_surface surf_idx) _color = color_dim(_color); pixman_color_t color = color_hex_to_pixman_with_alpha(_color, alpha); - render_csd_part(term, surf, buf, info.width, info.height, &color); + render_csd_part(term, surf, buf, info->width, info->height, &color); switch (surf_idx) { case CSD_SURF_MINIMIZE: render_csd_button_minimize(term, buf); break; @@ -1880,12 +1870,16 @@ render_csd(struct terminal *term) if (term->window->is_fullscreen) return; + struct csd_data infos[CSD_SURF_COUNT]; + int widths[CSD_SURF_COUNT]; + int heights[CSD_SURF_COUNT]; + for (size_t i = 0; i < CSD_SURF_COUNT; i++) { - struct csd_data info = get_csd_data(term, i); - const int x = info.x; - const int y = info.y; - const int width = info.width; - const int height = info.height; + infos[i] = get_csd_data(term, i); + const int x = infos[i].x; + const int y = infos[i].y; + const int width = infos[i].width; + const int height = infos[i].height; struct wl_surface *surf = term->window->csd.surface[i].surf; struct wl_subsurface *sub = term->window->csd.surface[i].sub; @@ -1894,20 +1888,27 @@ render_csd(struct terminal *term) xassert(sub != NULL); if (width == 0 || height == 0) { + widths[i] = heights[i] = 0; wl_subsurface_set_position(sub, 0, 0); wl_surface_attach(surf, NULL, 0, 0); wl_surface_commit(surf); continue; } + widths[i] = width; + heights[i] = height; + wl_subsurface_set_position(sub, x / term->scale, y / term->scale); } + struct buffer *bufs[CSD_SURF_COUNT]; + shm_get_many(term->render.chains.csd, CSD_SURF_COUNT, widths, heights, bufs); + for (size_t i = CSD_SURF_LEFT; i <= CSD_SURF_BOTTOM; i++) - render_csd_border(term, i); + render_csd_border(term, i, &infos[i], bufs[i]); for (size_t i = CSD_SURF_MINIMIZE; i <= CSD_SURF_CLOSE; i++) - render_csd_button(term, i); - render_csd_title(term); + render_csd_button(term, i, &infos[i], bufs[i]); + render_csd_title(term, &infos[CSD_SURF_TITLE], bufs[CSD_SURF_TITLE]); } static void diff --git a/terminal.c b/terminal.c index af5172bb..46e7fc01 100644 --- a/terminal.c +++ b/terminal.c @@ -1150,16 +1150,7 @@ term_init(const struct config *conf, struct fdm *fdm, struct reaper *reaper, .scrollback_indicator = shm_chain_new(wayl->shm, false, 1), .render_timer = shm_chain_new(wayl->shm, false, 1), .url = shm_chain_new(wayl->shm, false, 1), - .csd = { - [CSD_SURF_TITLE] = shm_chain_new(wayl->shm, false, 1), - [CSD_SURF_LEFT] = shm_chain_new(wayl->shm, false, 1), - [CSD_SURF_RIGHT] = shm_chain_new(wayl->shm, false, 1), - [CSD_SURF_TOP] = shm_chain_new(wayl->shm, false, 1), - [CSD_SURF_BOTTOM] = shm_chain_new(wayl->shm, false, 1), - [CSD_SURF_MINIMIZE] = shm_chain_new(wayl->shm, false, 1), - [CSD_SURF_MAXIMIZE] = shm_chain_new(wayl->shm, false, 1), - [CSD_SURF_CLOSE] = shm_chain_new(wayl->shm, false, 1), - }, + .csd = shm_chain_new(wayl->shm, false, 1), }, .scrollback_lines = conf->scrollback.lines, .app_sync_updates.timer_fd = app_sync_updates_fd, @@ -1482,8 +1473,7 @@ term_destroy(struct terminal *term) shm_chain_free(term->render.chains.scrollback_indicator); shm_chain_free(term->render.chains.render_timer); shm_chain_free(term->render.chains.url); - for (size_t i = 0; i < CSD_SURF_COUNT; i++) - shm_chain_free(term->render.chains.csd[i]); + shm_chain_free(term->render.chains.csd); tll_free(term->tab_stops); diff --git a/terminal.h b/terminal.h index d699d644..688e42cc 100644 --- a/terminal.h +++ b/terminal.h @@ -482,7 +482,7 @@ struct terminal { struct buffer_chain *scrollback_indicator; struct buffer_chain *render_timer; struct buffer_chain *url; - struct buffer_chain *csd[CSD_SURF_COUNT]; + struct buffer_chain *csd; } chains; /* Scheduled for rendering, as soon-as-possible */ diff --git a/wayland.c b/wayland.c index 38c80999..0679dee3 100644 --- a/wayland.c +++ b/wayland.c @@ -53,10 +53,9 @@ csd_destroy(struct wl_window *win) { struct terminal *term = win->term; - for (size_t i = 0; i < ALEN(win->csd.surface); i++) { + for (size_t i = 0; i < ALEN(win->csd.surface); i++) wayl_win_subsurface_destroy(&win->csd.surface[i]); - shm_purge(term->render.chains.csd[i]); - } + shm_purge(term->render.chains.csd); } static void @@ -1470,7 +1469,6 @@ wayl_win_destroy(struct wl_window *win) tll_foreach(win->urls, it) { wayl_win_subsurface_destroy(&it->item.surf); - shm_purge(term->render.chains.url); tll_remove(win->urls, it); } @@ -1483,9 +1481,8 @@ wayl_win_destroy(struct wl_window *win) shm_purge(term->render.chains.scrollback_indicator); shm_purge(term->render.chains.render_timer); shm_purge(term->render.chains.grid); - - for (size_t i = 0; i < ALEN(win->csd.surface); i++) - shm_purge(term->render.chains.csd[i]); + shm_purge(term->render.chains.url); + shm_purge(term->render.chains.csd); #if defined(HAVE_XDG_ACTIVATION) if (win->xdg_activation_token != NULL) -- cgit v1.3