From c893878aca7fe30d85c3a2a5cde78322c1fdd25a Mon Sep 17 00:00:00 2001 From: tokyo4j Date: Tue, 19 Nov 2024 05:03:26 +0900 Subject: [PATCH] scaled-scene-buffer: implement buffer sharing mechanism Implementers can define impl->equal() which compares two scaled-scene-buffers so that buffers are not allocated for visually duplicated scaled-scene-buffers. Currently this mechanism isn't applied for scaled-font-buffers since we haven't defined impl->equal() for it. --- include/common/scaled-scene-buffer.h | 17 ++++- src/common/scaled-font-buffer.c | 4 +- src/common/scaled-scene-buffer.c | 96 +++++++++++++++++++++++----- 3 files changed, 97 insertions(+), 20 deletions(-) diff --git a/include/common/scaled-scene-buffer.h b/include/common/scaled-scene-buffer.h index db59cca1..5c365595 100644 --- a/include/common/scaled-scene-buffer.h +++ b/include/common/scaled-scene-buffer.h @@ -17,6 +17,9 @@ struct scaled_scene_buffer_impl { (struct scaled_scene_buffer *scaled_buffer, double scale); /* Might be NULL or used for cleaning up */ void (*destroy)(struct scaled_scene_buffer *scaled_buffer); + /* Returns true if the two buffers are visually the same */ + bool (*equal)(struct scaled_scene_buffer *scaled_buffer_a, + struct scaled_scene_buffer *scaled_buffer_b); }; struct scaled_scene_buffer { @@ -28,11 +31,18 @@ struct scaled_scene_buffer { /* Private */ bool drop_buffer; double active_scale; + /* cached wlr_buffers for each scale */ struct wl_list cache; /* struct scaled_buffer_cache_entry.link */ struct wl_listener destroy; struct wl_listener output_enter; struct wl_listener output_leave; const struct scaled_scene_buffer_impl *impl; + /* + * Pointer to the per-implementation list of scaled-scene-buffers. + * This is used to share the backing wlr_buffers. + */ + struct wl_list *cached_buffers; + struct wl_list link; /* struct scaled_scene_buffer.cached_buffers */ }; /** @@ -53,6 +63,11 @@ struct scaled_scene_buffer { * it will also get called so a consumer of this API may clean up its own * allocations. * + * Besides caching buffers for each scale per scaled_scene_buffer, we also + * store all the scaled_scene_buffers in a per-implementer list passed as + * @cached_buffers in order to reuse backing buffers for visually duplicated + * scaled_scene_buffers found via impl->equal(). + * * All requested lab_data_buffers via impl->create_buffer() will be locked * during the lifetime of the buffer in the internal cache and unlocked * when being evacuated from the cache (due to LAB_SCALED_BUFFER_MAX_CACHE @@ -79,7 +94,7 @@ struct scaled_scene_buffer { struct scaled_scene_buffer *scaled_scene_buffer_create( struct wlr_scene_tree *parent, const struct scaled_scene_buffer_impl *implementation, - bool drop_buffer); + struct wl_list *cached_buffers, bool drop_buffer); /* Clear the cache of existing buffers, useful in case the content changes */ void scaled_scene_buffer_invalidate_cache(struct scaled_scene_buffer *self); diff --git a/src/common/scaled-font-buffer.c b/src/common/scaled-font-buffer.c index 844aeaef..5b7fd2cf 100644 --- a/src/common/scaled-font-buffer.c +++ b/src/common/scaled-font-buffer.c @@ -53,8 +53,8 @@ scaled_font_buffer_create(struct wlr_scene_tree *parent) { assert(parent); struct scaled_font_buffer *self = znew(*self); - struct scaled_scene_buffer *scaled_buffer = - scaled_scene_buffer_create(parent, &impl, /* drop_buffer */ true); + struct scaled_scene_buffer *scaled_buffer = scaled_scene_buffer_create( + parent, &impl, NULL, /* drop_buffer */ true); if (!scaled_buffer) { free(self); return NULL; diff --git a/src/common/scaled-scene-buffer.c b/src/common/scaled-scene-buffer.c index e177fd19..cb6bf14a 100644 --- a/src/common/scaled-scene-buffer.c +++ b/src/common/scaled-scene-buffer.c @@ -49,31 +49,84 @@ _cache_entry_destroy(struct scaled_scene_buffer_cache_entry *cache_entry, bool d free(cache_entry); } +static struct scaled_scene_buffer_cache_entry * +find_cache_for_scale(struct scaled_scene_buffer *scene_buffer, double scale) +{ + struct scaled_scene_buffer_cache_entry *cache_entry; + wl_list_for_each(cache_entry, &scene_buffer->cache, link) { + if (cache_entry->scale == scale) { + return cache_entry; + } + } + return NULL; +} + static void _update_buffer(struct scaled_scene_buffer *self, double scale) { self->active_scale = scale; /* Search for cached buffer of specified scale */ - struct scaled_scene_buffer_cache_entry *cache_entry, *cache_entry_tmp; - wl_list_for_each_safe(cache_entry, cache_entry_tmp, &self->cache, link) { - if (cache_entry->scale == scale) { - /* LRU cache, recently used in front */ - wl_list_remove(&cache_entry->link); - wl_list_insert(&self->cache, &cache_entry->link); - wlr_scene_buffer_set_buffer(self->scene_buffer, cache_entry->buffer); - return; + struct scaled_scene_buffer_cache_entry *cache_entry = + find_cache_for_scale(self, scale); + if (cache_entry) { + /* LRU cache, recently used in front */ + wl_list_remove(&cache_entry->link); + wl_list_insert(&self->cache, &cache_entry->link); + wlr_scene_buffer_set_buffer(self->scene_buffer, cache_entry->buffer); + /* + * If found in our local cache, + * - self->width and self->height are already set + * - wlr_scene_buffer_set_dest_size() has already been called + */ + return; + } + + struct wlr_buffer *wlr_buffer = NULL; + + if (self->impl->equal && self->cached_buffers) { + /* Search from other cached scaled-scene-buffers */ + struct scaled_scene_buffer *scene_buffer; + wl_list_for_each(scene_buffer, self->cached_buffers, link) { + if (scene_buffer == self) { + continue; + } + if (!self->impl->equal(self, scene_buffer)) { + continue; + } + cache_entry = find_cache_for_scale(scene_buffer, scale); + if (!cache_entry) { + continue; + } + + /* Ensure self->width and self->height are set correctly */ + self->width = scene_buffer->width; + self->height = scene_buffer->height; + wlr_buffer = cache_entry->buffer; + break; } } - /* Create new buffer, will get destroyed along the backing wlr_buffer */ - struct lab_data_buffer *buffer = self->impl->create_buffer(self, scale); - if (buffer) { - /* Ensure the buffer doesn't get deleted behind our back */ - wlr_buffer_lock(&buffer->base); + if (!wlr_buffer) { + /* + * Create new buffer, will get destroyed along the backing + * wlr_buffer + */ + struct lab_data_buffer *buffer = + self->impl->create_buffer(self, scale); + if (buffer) { + self->width = buffer->logical_width; + self->height = buffer->logical_height; + wlr_buffer = &buffer->base; + } else { + self->width = 0; + self->height = 0; + } + } + if (wlr_buffer) { + /* Ensure the buffer doesn't get deleted behind our back */ + wlr_buffer_lock(wlr_buffer); } - self->width = buffer ? buffer->logical_width : 0; - self->height = buffer ? buffer->logical_height : 0; /* Create or reuse cache entry */ if (wl_list_length(&self->cache) < LAB_SCALED_BUFFER_MAX_CACHE) { @@ -92,7 +145,7 @@ _update_buffer(struct scaled_scene_buffer *self, double scale) /* Update the cache entry */ cache_entry->scale = scale; - cache_entry->buffer = buffer ? &buffer->base : NULL; + cache_entry->buffer = wlr_buffer; wl_list_insert(&self->cache, &cache_entry->link); /* And finally update the wlr_scene_buffer itself */ @@ -119,6 +172,7 @@ _handle_node_destroy(struct wl_listener *listener, void *data) if (self->impl->destroy) { self->impl->destroy(self); } + wl_list_remove(&self->link); free(self); } @@ -159,7 +213,7 @@ _handle_output_leave(struct wl_listener *listener, void *data) struct scaled_scene_buffer * scaled_scene_buffer_create(struct wlr_scene_tree *parent, const struct scaled_scene_buffer_impl *impl, - bool drop_buffer) + struct wl_list *cached_buffers, bool drop_buffer) { assert(parent); assert(impl); @@ -178,6 +232,14 @@ scaled_scene_buffer_create(struct wlr_scene_tree *parent, self->drop_buffer = drop_buffer; wl_list_init(&self->cache); + self->cached_buffers = cached_buffers; + if (self->cached_buffers) { + wl_list_insert(self->cached_buffers, &self->link); + } else { + /* Ensure self->link can be removed safely in the destroy handler */ + wl_list_init(&self->link); + } + /* Listen to output enter/leave so we get notified about scale changes */ self->output_enter.notify = _handle_output_enter; wl_signal_add(&self->scene_buffer->events.output_enter, &self->output_enter);