diff --git a/app/src/main/cpp/waylandcomp/src/compositor.c b/app/src/main/cpp/waylandcomp/src/compositor.c index c2c26d63fe..f78f0d3f86 100644 --- a/app/src/main/cpp/waylandcomp/src/compositor.c +++ b/app/src/main/cpp/waylandcomp/src/compositor.c @@ -256,6 +256,7 @@ struct surface { struct wl_list child_link; int sub_x, sub_y, sub_pending_x, sub_pending_y, sub_pending; int below_parent; + int sub_desync; int fullscreen; int toplevel_committed; @@ -332,6 +333,7 @@ struct pending_release { struct wl_resource *buffer; struct wl_listener destroy; struct surface *surface; + struct surface *held_by; int64_t at_ns; int64_t since_ns; struct wl_list link; @@ -434,10 +436,54 @@ static void pending_release_free(struct pending_release *pr) { free(pr); } +static void release_due_buffers(void); +static void arm_release_timer(void); + static void pending_releases_forget_surface(struct surface *s) { struct pending_release *pr; - wl_list_for_each(pr, &g_pending_releases, link) + int unheld = 0; + wl_list_for_each(pr, &g_pending_releases, link) { if (pr->surface == s) pr->surface = NULL; + if (pr->held_by == s) { pr->held_by = NULL; unheld = 1; } + } + if (unheld) { release_due_buffers(); arm_release_timer(); } +} + +static void pending_releases_cancel(struct wl_resource *buffer) { + struct pending_release *pr, *tmp; + wl_list_for_each_safe(pr, tmp, &g_pending_releases, link) + if (pr->buffer == buffer) pending_release_free(pr); +} + +static void pending_releases_apply(struct surface *holder) { + struct pending_release *pr; + int unheld = 0; + wl_list_for_each(pr, &g_pending_releases, link) + if (pr->held_by == holder) { pr->held_by = NULL; unheld = 1; } + if (unheld) { release_due_buffers(); arm_release_timer(); } +} + +static struct surface *sync_holder(struct surface *s) { + struct surface *holder = NULL; + for (int depth = 0; s && s->role == ROLE_SUBSURFACE && s->parent && depth < 8; depth++) { + if (!s->sub_desync) holder = s->parent; + s = s->parent; + } + return holder; +} + +static void pending_releases_rehold(struct surface *changed) { + struct pending_release *pr; + int unheld = 0; + wl_list_for_each(pr, &g_pending_releases, link) { + if (!pr->held_by || !pr->surface) continue; + struct surface *s = pr->surface; + for (int depth = 0; s && s != changed && depth < 8; depth++) s = s->parent; + if (s != changed) continue; + pr->held_by = sync_holder(pr->surface); + if (!pr->held_by) unheld = 1; + } + if (unheld) { release_due_buffers(); arm_release_timer(); } } static void on_pending_release_buffer_destroyed(struct wl_listener *l, void *data) { @@ -450,20 +496,18 @@ static void arm_release_timer(void) { int64_t earliest = 0; if (g_release_timer_fd < 0) return; wl_list_for_each(pr, &g_pending_releases, link) - if (!buffer_release_blocked(pr->buffer) && (!earliest || pr->at_ns < earliest)) + if (!pr->held_by && !buffer_release_blocked(pr->buffer) && (!earliest || pr->at_ns < earliest)) earliest = pr->at_ns; struct itimerspec its = {0}; if (earliest) { its.it_value.tv_sec = earliest / 1000000000LL; its.it_value.tv_nsec = earliest % 1000000000LL; } timerfd_settime(g_release_timer_fd, TFD_TIMER_ABSTIME, &its, NULL); } -static int on_release_timer(int fd, uint32_t mask, void *data) { +static void release_due_buffers(void) { struct pending_release *pr, *tmp; - uint64_t expirations; int64_t now = now_ns() + 300000; - if (read(fd, &expirations, sizeof(expirations)) < 0 && errno != EAGAIN) return 0; wl_list_for_each_safe(pr, tmp, &g_pending_releases, link) { - if (pr->at_ns <= now && !buffer_release_blocked(pr->buffer)) { + if (!pr->held_by && pr->at_ns <= now && !buffer_release_blocked(pr->buffer)) { /* Attached again since (to its surface or another): that surface releases it later. */ if (buffer_shown_elsewhere(pr->buffer, NULL)) { pending_release_free(pr); @@ -474,28 +518,39 @@ static int on_release_timer(int fd, uint32_t mask, void *data) { pending_release_free(pr); } } +} + +static int on_release_timer(int fd, uint32_t mask, void *data) { + uint64_t expirations; + if (read(fd, &expirations, sizeof(expirations)) < 0 && errno != EAGAIN) return 0; + release_due_buffers(); wl_display_flush_clients(g_display); arm_release_timer(); return 0; } -static void release_buffer(struct surface *s, struct wl_resource *buffer, int64_t since_ns) { +static void release_buffer(struct surface *s, struct wl_resource *buffer, int64_t since_ns, struct surface *holder) { /* No allocation or immediate-release fallback is allowed for a quarantined * DMA-BUF. Existing queued releases stay held; their timer is disarmed. */ if (buffer_release_blocked(buffer)) return; const int limit = g_fps_limit; const int64_t interval = limit > 0 ? 1000000000LL / limit : g_refresh_ns; - if (g_release_unpaced || interval <= 0 || g_release_timer_fd < 0) { send_buffer_release(buffer); perf_note_release(since_ns); return; } + const int paced = !g_release_unpaced && interval > 0 && g_release_timer_fd >= 0; + if (!paced && !holder) { send_buffer_release(buffer); perf_note_release(since_ns); return; } int64_t now = now_ns(); - int64_t at = s->next_release_ns + interval; - int64_t latest = now + interval * (int64_t)(s->releases_pending + 1); - if (at < now) at = now; - if (at > latest) at = latest; - s->next_release_ns = at; + int64_t at = now; + if (paced) { + int64_t latest = now + interval * (int64_t)(s->releases_pending + 1); + at = s->next_release_ns + interval; + if (at < now) at = now; + if (at > latest) at = latest; + s->next_release_ns = at; + } struct pending_release *pr = calloc(1, sizeof(*pr)); if (!pr) { send_buffer_release(buffer); perf_note_release(since_ns); return; } pr->buffer = buffer; pr->surface = s; + pr->held_by = holder; pr->at_ns = at; pr->since_ns = since_ns; pr->destroy.notify = on_pending_release_buffer_destroyed; @@ -721,7 +776,7 @@ static void drop_dmabuf(struct surface *s, int paced) { wl_list_remove(&s->dmabuf_destroy.link); if (buffer_shown_elsewhere(s->dmabuf, s)) { } else if (!ahb_swapchain_defer_release(s->dmabuf_buf, s->dmabuf, s, paced)) { - if (paced) release_buffer(s, s->dmabuf, now_ns()); + if (paced) release_buffer(s, s->dmabuf, now_ns(), sync_holder(s)); else send_buffer_release(s->dmabuf); } s->dmabuf = NULL; @@ -887,6 +942,7 @@ static void take_dmabuf(struct surface *s, struct dmabuf_buffer *b, struct wl_re s->last_dmabuf = buffer; pace_note_buffer(buffer); drop_dmabuf(s, 1); + pending_releases_cancel(buffer); s->dmabuf = buffer; s->dmabuf_buf = b; b->refs++; @@ -977,7 +1033,7 @@ void droiddeck_dmabuf_ref(struct dmabuf_buffer *b) { b->refs++; } void droiddeck_dmabuf_unref(struct dmabuf_buffer *b) { dmabuf_buffer_unref(b); } void droiddeck_release_buffer(struct surface *s, struct wl_resource *buffer, int paced, int64_t since_ns) { if (buffer_release_blocked(buffer)) return; - if (paced && s) release_buffer(s, buffer, since_ns); + if (paced && s) release_buffer(s, buffer, since_ns, NULL); else { send_buffer_release(buffer); perf_note_release(since_ns); } } void droiddeck_surface_describe(const struct surface *s, char *out, size_t size) { describe(s, out, size); } @@ -1265,6 +1321,7 @@ static void surface_commit(struct wl_client *c, struct wl_resource *r) { s->pending_attach = 0; surface_drop_idle(s); + buf_trace_attach(buffer); if (s->role == ROLE_CURSOR) { if (!buffer) { cursor_publish_hidden(); @@ -1275,7 +1332,6 @@ static void surface_commit(struct wl_client *c, struct wl_resource *r) { } else if (s->role == ROLE_NONE) { if (buffer) surface_hold_idle(s, buffer); } else if (db) { - buf_trace_attach(buffer); take_dmabuf(s, db, buffer); } else if (shm) { drop_dmabuf(s, 1); @@ -1289,6 +1345,7 @@ static void surface_commit(struct wl_client *c, struct wl_resource *r) { if (buffer) send_buffer_release(buffer); } } + pending_releases_apply(s); wl_list_for_each(child, &s->children, child_link) { if (child->sub_pending) { @@ -1486,8 +1543,14 @@ static void subsurface_place_below(struct wl_client *c, struct wl_resource *r, struct wl_resource *sibling) { restack_child(wl_resource_get_user_data(r), wl_resource_get_user_data(sibling), 0); } -static void subsurface_set_sync(struct wl_client *c, struct wl_resource *r) {} -static void subsurface_set_desync(struct wl_client *c, struct wl_resource *r) {} +static void subsurface_set_sync(struct wl_client *c, struct wl_resource *r) { + struct surface *s = wl_resource_get_user_data(r); + if (s) s->sub_desync = 0; +} +static void subsurface_set_desync(struct wl_client *c, struct wl_resource *r) { + struct surface *s = wl_resource_get_user_data(r); + if (s) { s->sub_desync = 1; pending_releases_rehold(s); } +} static const struct wl_subsurface_interface subsurface_impl = { .destroy = subsurface_destroy, .set_position = subsurface_set_position, @@ -1521,6 +1584,7 @@ static void subcompositor_get_subsurface(struct wl_client *c, struct wl_resource s->subsurface = sub; s->parent = p; s->below_parent = 0; + s->sub_desync = 0; s->sub_x = s->sub_y = 0; wl_list_insert(p->children.prev, &s->child_link); } diff --git a/tools/tests/subsurface_release_harness.c b/tools/tests/subsurface_release_harness.c new file mode 100644 index 0000000000..0921666d45 --- /dev/null +++ b/tools/tests/subsurface_release_harness.c @@ -0,0 +1,318 @@ +#define _POSIX_C_SOURCE 200809L +#include +#include +#include +#include +#include +#include +#include "wayland-util.h" + +void wl_list_init(struct wl_list *list) { list->prev = list->next = list; } +void wl_list_insert(struct wl_list *list, struct wl_list *elm) { + elm->prev = list; + elm->next = list->next; + list->next = elm; + elm->next->prev = elm; +} +void wl_list_remove(struct wl_list *elm) { + elm->prev->next = elm->next; + elm->next->prev = elm->prev; + elm->next = elm->prev = NULL; +} +int wl_list_empty(const struct wl_list *list) { return list->next == list; } + +struct wl_listener { struct wl_list link; void (*notify)(struct wl_listener *, void *); }; +struct wl_resource { struct wl_list listeners; int acquired, releases, errors; }; +struct dmabuf_buffer { int unused; }; +enum surface_role { ROLE_NONE, ROLE_TOPLEVEL, ROLE_SUBSURFACE }; +struct surface { + struct wl_list link; + struct wl_resource *dmabuf; + struct dmabuf_buffer *dmabuf_buf; + struct wl_listener dmabuf_destroy; + int64_t next_release_ns; + int releases_pending; + enum surface_role role; + struct surface *parent; + int sub_desync; +}; + +#define TFD_TIMER_ABSTIME 1 +static struct wl_list g_surfaces; +static struct wl_list g_pending_releases; +static int g_release_timer_fd = 3; +static int g_fps_limit; +static int64_t g_refresh_ns = 8333333; +static int g_release_unpaced; +static int64_t g_now = 1000000000LL; +static int64_t g_armed; +static struct dmabuf_buffer g_buf; + +static int64_t now_ns(void) { return g_now; } +static void perf_note_release(int64_t since) { (void)since; } +static int buffer_release_blocked(struct wl_resource *b) { (void)b; return 0; } +static int ahb_swapchain_defer_release(struct dmabuf_buffer *b, struct wl_resource *r, struct surface *s, int paced) { + (void)b; (void)r; (void)s; (void)paced; + return 0; +} +static void dmabuf_buffer_unref(struct dmabuf_buffer *b) { (void)b; } +static void wl_resource_add_destroy_listener(struct wl_resource *r, struct wl_listener *l) { + wl_list_insert(r->listeners.prev, &l->link); +} +static int timerfd_settime(int fd, int flags, const struct itimerspec *its, struct itimerspec *old) { + (void)fd; (void)flags; (void)old; + g_armed = (int64_t)its->it_value.tv_sec * 1000000000LL + its->it_value.tv_nsec; + return 0; +} +static void send_buffer_release(struct wl_resource *b) { + b->releases++; + if (b->acquired) b->acquired = 0; + else b->errors++; +} + +#include "release.inc" + +static void present(struct wl_resource *b) { b->acquired = 1; } + +static void commit(struct surface *s, struct wl_resource *b) { + if (s->dmabuf != b) { + drop_dmabuf(s, 1); + if (b) { + pending_releases_cancel(b); + s->dmabuf = b; + s->dmabuf_buf = &g_buf; + wl_resource_add_destroy_listener(b, &s->dmabuf_destroy); + } + } + pending_releases_apply(s); +} + +static void timer_fires(int64_t at) { + if (g_now < at) g_now = at; + release_due_buffers(); + arm_release_timer(); +} + +static void surface_init(struct surface *s, enum surface_role role, struct surface *parent) { + memset(s, 0, sizeof(*s)); + s->role = role; + s->parent = parent; + wl_list_insert(g_surfaces.prev, &s->link); +} + +static void buffer_init(struct wl_resource *b) { + memset(b, 0, sizeof(*b)); + wl_list_init(&b->listeners); +} + +static void check(const struct wl_resource *b, int releases) { + if (b->releases != releases || b->errors) { + fprintf(stderr, "releases %d (want %d), released while not acquired %d\n", b->releases, releases, b->errors); + exit(1); + } +} + +static void moved_between_planes(void) { + struct surface root, low, high; + struct wl_resource a, b, c; + surface_init(&root, ROLE_TOPLEVEL, NULL); + surface_init(&low, ROLE_SUBSURFACE, &root); + surface_init(&high, ROLE_SUBSURFACE, &root); + buffer_init(&a); buffer_init(&b); buffer_init(&c); + + present(&a); present(&b); + commit(&high, &a); + commit(&low, &b); + commit(&root, NULL); + + present(&a); present(&b); + commit(&high, NULL); + timer_fires(g_now); + check(&a, 0); + commit(&low, &a); + timer_fires(g_now); + commit(&root, &b); + timer_fires(g_now + 100000000LL); + check(&a, 0); + check(&b, 0); + + present(&c); + commit(&high, NULL); + commit(&low, NULL); + commit(&root, &c); + timer_fires(g_now + 100000000LL); + check(&a, 1); + check(&b, 1); + check(&c, 0); +} + +static void reattached_before_release(void) { + struct surface s; + struct wl_resource a, b, c; + surface_init(&s, ROLE_TOPLEVEL, NULL); + buffer_init(&a); buffer_init(&b); buffer_init(&c); + g_fps_limit = 60; + present(&a); commit(&s, &a); + present(&b); commit(&s, &b); + present(&a); commit(&s, &a); + present(&c); commit(&s, &c); + timer_fires(g_now + 1000000000LL); + check(&a, 1); + check(&b, 1); + check(&c, 0); +} + +static void desync_child_not_held(void) { + struct surface root, child; + struct wl_resource a, b; + surface_init(&root, ROLE_TOPLEVEL, NULL); + surface_init(&child, ROLE_SUBSURFACE, &root); + child.sub_desync = 1; + buffer_init(&a); buffer_init(&b); + present(&a); commit(&child, &a); + present(&b); commit(&child, &b); + timer_fires(g_now + 100000000LL); + check(&a, 1); + check(&b, 0); +} + +static void toplevel_pacing_kept(void) { + struct surface s; + struct wl_resource a, b, c; + surface_init(&s, ROLE_TOPLEVEL, NULL); + buffer_init(&a); buffer_init(&b); buffer_init(&c); + g_fps_limit = 60; + const int64_t interval = 1000000000LL / 60; + present(&a); commit(&s, &a); + present(&b); commit(&s, &b); + present(&c); commit(&s, &c); + const int64_t start = g_now; + timer_fires(g_now); + check(&a, 1); + check(&b, 0); + assert(g_armed == start + interval); + timer_fires(start + interval / 2); + check(&b, 0); + timer_fires(g_armed); + check(&b, 1); + check(&c, 0); +} + +static void unpaced_sync_child(void) { + struct surface root, low, high; + struct wl_resource a, b; + surface_init(&root, ROLE_TOPLEVEL, NULL); + surface_init(&low, ROLE_SUBSURFACE, &root); + surface_init(&high, ROLE_SUBSURFACE, &root); + buffer_init(&a); buffer_init(&b); + g_release_unpaced = 1; + present(&a); commit(&high, &a); commit(&root, NULL); + present(&a); + commit(&high, NULL); + check(&a, 0); + commit(&low, &a); + commit(&root, NULL); + check(&a, 0); + commit(&low, NULL); + check(&a, 0); + commit(&root, NULL); + check(&a, 1); + present(&b); commit(&root, &b); + commit(&root, NULL); + check(&b, 1); +} + +static void holder_destroyed(void) { + struct surface root, child; + struct wl_resource a, b; + surface_init(&root, ROLE_TOPLEVEL, NULL); + surface_init(&child, ROLE_SUBSURFACE, &root); + buffer_init(&a); buffer_init(&b); + present(&a); commit(&child, &a); commit(&root, NULL); + present(&b); commit(&child, &b); + timer_fires(g_now + 100000000LL); + check(&a, 0); + child.parent = NULL; + wl_list_remove(&root.link); + pending_releases_forget_surface(&root); + check(&a, 1); +} + +static void cycled_faster_than_releases(void) { + struct surface s; + struct wl_resource a, b, c; + struct wl_resource *order[3] = {&a, &b, &c}; + surface_init(&s, ROLE_TOPLEVEL, NULL); + buffer_init(&a); buffer_init(&b); buffer_init(&c); + g_fps_limit = 60; + const int64_t interval = 1000000000LL / 60; + for (int i = 0; i < 30; i++) { + present(order[i % 3]); + commit(&s, order[i % 3]); + assert(s.releases_pending <= 2); + assert(g_armed <= g_now + 3 * interval); + } + timer_fires(g_now + 1000000000LL); + check(&a, 1); + check(&b, 1); + check(&c, 0); +} + +static void desync_parent_holds_sync_grandchild(void) { + struct surface root, middle, child; + struct wl_resource a, b; + surface_init(&root, ROLE_TOPLEVEL, NULL); + surface_init(&middle, ROLE_SUBSURFACE, &root); + surface_init(&child, ROLE_SUBSURFACE, &middle); + middle.sub_desync = 1; + buffer_init(&a); buffer_init(&b); + present(&a); commit(&child, &a); commit(&middle, NULL); + present(&b); commit(&child, &b); + timer_fires(g_now + 100000000LL); + check(&a, 0); + commit(&middle, NULL); + timer_fires(g_now + 100000000LL); + check(&a, 1); + check(&b, 0); +} + +static void set_desync_frees_held_release(void) { + struct surface root, outer, inner; + struct wl_resource a, b, c, d; + surface_init(&root, ROLE_TOPLEVEL, NULL); + surface_init(&outer, ROLE_SUBSURFACE, &root); + surface_init(&inner, ROLE_SUBSURFACE, &outer); + buffer_init(&a); buffer_init(&b); buffer_init(&c); buffer_init(&d); + present(&a); commit(&inner, &a); commit(&root, NULL); + present(&b); commit(&inner, &b); + present(&c); commit(&outer, &c); commit(&root, NULL); + present(&d); commit(&outer, &d); + inner.sub_desync = 1; + pending_releases_rehold(&inner); + timer_fires(g_now + 100000000LL); + check(&a, 1); + check(&c, 0); + outer.sub_desync = 1; + pending_releases_rehold(&outer); + timer_fires(g_now + 100000000LL); + check(&c, 1); + check(&b, 0); + check(&d, 0); +} + +int main(int argc, char **argv) { + assert(argc == 2); + wl_list_init(&g_surfaces); + wl_list_init(&g_pending_releases); + if (!strcmp(argv[1], "moved")) moved_between_planes(); + else if (!strcmp(argv[1], "reattached")) reattached_before_release(); + else if (!strcmp(argv[1], "cycled")) cycled_faster_than_releases(); + else if (!strcmp(argv[1], "desync")) desync_child_not_held(); + else if (!strcmp(argv[1], "toplevel")) toplevel_pacing_kept(); + else if (!strcmp(argv[1], "unpaced")) unpaced_sync_child(); + else if (!strcmp(argv[1], "destroyed")) holder_destroyed(); + else if (!strcmp(argv[1], "nested")) desync_parent_holds_sync_grandchild(); + else if (!strcmp(argv[1], "set-desync")) set_desync_frees_held_release(); + else return 2; + return 0; +} diff --git a/tools/tests/test_subsurface_release.py b/tools/tests/test_subsurface_release.py new file mode 100644 index 0000000000..2254eb1a71 --- /dev/null +++ b/tools/tests/test_subsurface_release.py @@ -0,0 +1,96 @@ +import os +from pathlib import Path +import re +import shutil +import subprocess +import tempfile +import unittest + +REPO = Path(__file__).resolve().parents[2] +SOURCE = REPO / 'app/src/main/cpp/waylandcomp/src/compositor.c' +FUNCTIONS = ( + 'pending_release_free', 'pending_releases_forget_surface', 'pending_releases_cancel', + 'pending_releases_apply', 'sync_holder', 'pending_releases_rehold', 'on_pending_release_buffer_destroyed', + 'arm_release_timer', 'release_due_buffers', 'release_buffer', 'buffer_shown_elsewhere', + 'drop_dmabuf', +) + + +def extract_function(source, name): + match = re.search(r'^static [^\n;]*?\b' + re.escape(name) + r'\([^;{]*\) \{$', source, re.MULTILINE) + if match is None: + raise AssertionError(f'Missing compositor function: {name}') + cursor, depth = match.end(), 1 + while depth: + depth += (source[cursor] == '{') - (source[cursor] == '}') + cursor += 1 + return match.group(0)[:-2] + ';', source[match.start():cursor] + + +def function_body(source, name): + return extract_function(source, name)[1] + + +class SubsurfaceReleaseTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + compiler = shutil.which(os.environ.get('CC', 'cc')) + if compiler is None: + raise unittest.SkipTest('A host C compiler is required') + cls.source = SOURCE.read_text() + start = cls.source.index('struct pending_release {') + end = cls.source.index('\n};\n', start) + 4 + parts = [extract_function(cls.source, name) for name in FUNCTIONS] + code = cls.source[start:end] + '\n'.join(p[0] for p in parts) + '\n' + '\n'.join(p[1] for p in parts) + '\n' + cls.temp = tempfile.TemporaryDirectory(prefix='droiddeck-subsurface-release-') + cls.addClassCleanup(cls.temp.cleanup) + folder = Path(cls.temp.name) + (folder / 'release.inc').write_text(code) + cls.binary = folder / 'release-test' + subprocess.run([compiler, '-std=c11', '-Wall', '-Werror', '-Wno-unused-function', + '-I', str(folder), '-I', str(REPO / 'app/src/main/cpp/waylandcomp/prebuilt/include'), + str(REPO / 'tools/tests/subsurface_release_harness.c'), '-o', str(cls.binary)], + check=True, capture_output=True, text=True) + + def check_case(self, case): + result = subprocess.run([str(self.binary), case], capture_output=True, text=True) + self.assertEqual(result.returncode, 0, result.stdout + result.stderr) + + def test_buffer_moved_to_another_plane_is_released_once_after_the_parent_commit(self): + self.check_case('moved') + + def test_buffer_attached_again_before_its_paced_release_is_released_once(self): + self.check_case('reattached') + + def test_buffers_cycled_faster_than_their_paced_releases_are_released_once_each(self): + self.check_case('cycled') + + def test_unpaced_sync_child_waits_for_the_parent_commit(self): + self.check_case('unpaced') + + def test_desynchronized_child_is_released_without_a_parent_commit(self): + self.check_case('desync') + + def test_toplevel_release_pacing_is_unchanged(self): + self.check_case('toplevel') + + def test_held_release_is_sent_when_the_parent_is_destroyed(self): + self.check_case('destroyed') + + def test_desynchronized_parent_releases_its_synchronized_child(self): + self.check_case('nested') + + def test_set_desync_releases_what_the_old_parent_held(self): + self.check_case('set-desync') + + def test_compositor_attach_and_commit_use_the_release_hold(self): + self.assertIn('pending_releases_cancel(buffer);', function_body(self.source, 'take_dmabuf')) + commit = function_body(self.source, 'surface_commit') + self.assertIn('pending_releases_apply(s);', commit) + self.assertLess(commit.index('take_dmabuf(s, db, buffer);'), commit.index('pending_releases_apply(s);')) + self.assertLess(commit.index('buf_trace_attach(buffer);'), commit.index('if (s->role == ROLE_CURSOR)')) + self.assertIn('pending_releases_rehold(s);', function_body(self.source, 'subsurface_set_desync')) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/tests/test_vk_dmabuf_quarantine.py b/tools/tests/test_vk_dmabuf_quarantine.py index aeafada3ef..5bd0f1b016 100644 --- a/tools/tests/test_vk_dmabuf_quarantine.py +++ b/tools/tests/test_vk_dmabuf_quarantine.py @@ -51,6 +51,10 @@ class VkDmabufQuarantineTest(unittest.TestCase): # One surface per buffer in these scenarios: never shown elsewhere. helpers += ['static int buffer_shown_elsewhere(struct wl_resource *b, const struct surface *e) ' '{ (void)b; (void)e; return 0; }'] + if re.search(r'^static void release_due_buffers\(void\) \{', comp, re.M): + helpers += ['static void release_due_buffers(void);', 'static void arm_release_timer(void);', + function(comp, 'sync_holder')] + names.insert(names.index('on_release_timer'), 'release_due_buffers') if re.search(r'\bvolatile int g_release_unpaced;', comp): # Releases stay paced in these scenarios (fps limit -1 sends them at once). helpers.insert(0, 'static int g_release_unpaced;') diff --git a/tools/tests/test_wayland_clock_domain.py b/tools/tests/test_wayland_clock_domain.py index a805ff9c09..265b0b17b2 100644 --- a/tools/tests/test_wayland_clock_domain.py +++ b/tools/tests/test_wayland_clock_domain.py @@ -58,7 +58,7 @@ class WaylandClockDomainTest(unittest.TestCase): #include #include "clock_domain.h" -struct pending_release { void *buffer; int64_t at_ns; struct pending_release *next; }; +struct pending_release { void *buffer; int64_t at_ns; struct pending_release *next; void *held_by; }; static struct pending_release *g_pending_releases; static int g_release_timer_fd; #define wl_list_for_each(pr, list, link) for (pr = *(list); pr; pr = pr->next) @@ -79,8 +79,8 @@ int main(int argc, char **argv) { struct timespec started, ended; clock_gettime(CLOCK_MONOTONIC, &started); int64_t start = now_ns(); - struct pending_release blocked = {(void *)1, start + 1000000LL, NULL}; - struct pending_release release = {NULL, start + 60000000LL, &blocked}; + struct pending_release blocked = {(void *)1, start + 1000000LL, NULL, NULL}; + struct pending_release release = {NULL, start + 60000000LL, &blocked, NULL}; g_pending_releases = &release; arm_release_timer(); int64_t next_offset = offsets[i] + 10000000000LL; diff --git a/tools/tests/vk_dmabuf_quarantine_test.c b/tools/tests/vk_dmabuf_quarantine_test.c index cbcf724b19..f9dcf85bf0 100644 --- a/tools/tests/vk_dmabuf_quarantine_test.c +++ b/tools/tests/vk_dmabuf_quarantine_test.c @@ -25,7 +25,11 @@ struct dmabuf_buffer { struct vkp_image *img; void *ahb_state; }; +enum surface_role { ROLE_NONE, ROLE_TOPLEVEL, ROLE_SUBSURFACE }; struct surface { + enum surface_role role; + struct surface *parent; + int sub_desync; struct wl_resource *dmabuf; struct dmabuf_buffer *dmabuf_buf; struct wl_listener dmabuf_destroy; @@ -113,7 +117,7 @@ static void test_queue(int mixed, int client_gone) { g_release_timer_fd = 123; g_refresh_ns = 100000; drop_dmabuf(&s, 1); assert(s.releases_pending == 1 && !r.releases); assert(last_timer.it_value.tv_sec || last_timer.it_value.tv_nsec); - if (mixed) { init_resource(&shm, NULL); release_buffer(&s, &shm, now_ns()); } + if (mixed) { init_resource(&shm, NULL); droiddeck_release_buffer(&s, &shm, 1, now_ns()); } pending_releases_forget_surface(&s); g_dev_state = -3; fire_timer();