From bfe5941ce9cf5795d5a9633c1120584dad136e54 Mon Sep 17 00:00:00 2001 From: The412Banner Date: Wed, 28 Oct 2026 04:40:24 +0000 Subject: [PATCH] fix(compositor): keep callback-paced clients at one frame per refresh Review of #1707: a client that draws its next frame only after the frame callback of the last one sends no new frame while the tick holds one back, so it got one frame every two refreshes. Once a held frame is still waiting at the next tick, the tick now draws every frame for a second before holding one again; such a client loses at most one refresh per second, while gamescope, which commits without waiting, keeps drawing on arrival. The queued draw also checks again that drawing on arrival is still on, so a frame queued just before streaming, frame generation or paced output switched on is left for the tick. --- app/src/main/cpp/waylandcomp/src/compositor.c | 18 ++++- tools/tests/test_render_on_commit.py | 76 ++++++++++++++++--- 2 files changed, 80 insertions(+), 14 deletions(-) diff --git a/app/src/main/cpp/waylandcomp/src/compositor.c b/app/src/main/cpp/waylandcomp/src/compositor.c index 9437c3afa..69c2e7187 100644 --- a/app/src/main/cpp/waylandcomp/src/compositor.c +++ b/app/src/main/cpp/waylandcomp/src/compositor.c @@ -265,6 +265,9 @@ static int g_dirty; static int64_t g_dirty_since_ns; volatile int g_render_on_commit = 1; static int64_t g_rendered_tick_ns; +static int g_tick_held; +static int64_t g_hold_missed_ns; +#define HOLD_RETRY_NS 1000000000LL #define PACE_BUFFERS 32 static struct { unsigned ticks, ticks_late_2ms, renders, commit_renders, null_attaches, reattaches, presented, replaced, undrawn, distinct; @@ -2136,6 +2139,7 @@ static void render_scene(void) { } g_dirty = 0; g_rendered_tick_ns = g_tick_vsync_ns; + g_tick_held = 0; g_hud_fresh = 0; g_hdr_unimported = NULL; wl_list_for_each(s, &g_surfaces, link) s->drawn = 0; @@ -2334,7 +2338,7 @@ static int scene_waits_for_game(int64_t now) { static void on_commit_idle(void *data) { g_render_idle = NULL; - if (!g_dirty || g_rendered_tick_ns == g_tick_vsync_ns || scene_waits_for_game(now_ns())) return; + if (!g_dirty || !commit_renders_on() || g_rendered_tick_ns == g_tick_vsync_ns || scene_waits_for_game(now_ns())) return; g_pace.commit_renders++; render_scene(); } @@ -2361,8 +2365,16 @@ static void on_vsync(int64_t frame_time_ns) { if (vkp_cardboard_pose_changed()) tick_change = 1; if (tick_change) g_dirty = 1; /* A frame that arrived after this refresh was already drawn is left for the next arrival to draw; - drawing it here would block that arrival too and keep every frame waiting for the tick. */ - if (!tick_change && commit_renders_on() && g_dirty_since_ns && now - g_dirty_since_ns < g_refresh_ns) return; + drawing it here would block that arrival too and keep every frame waiting for the tick. A client + that draws again only after its frame callback sends no such arrival: once a held frame is still + waiting at the next tick, the tick draws every frame for a second before holding one again. */ + if (g_tick_held && g_dirty) g_hold_missed_ns = now; + g_tick_held = 0; + if (!tick_change && commit_renders_on() && g_dirty_since_ns && now - g_dirty_since_ns < g_refresh_ns && + now - g_hold_missed_ns >= HOLD_RETRY_NS) { + g_tick_held = 1; + return; + } if (g_dirty && !scene_waits_for_game(now)) render_scene(); } diff --git a/tools/tests/test_render_on_commit.py b/tools/tests/test_render_on_commit.py index 9da61cd98..d27c7646e 100644 --- a/tools/tests/test_render_on_commit.py +++ b/tools/tests/test_render_on_commit.py @@ -26,6 +26,9 @@ static struct wl_event_source *g_render_idle, *g_fallback_timer; static int g_fallback_armed, g_dirty, g_hud_fresh, framegen; static void *g_hud_surface; static int64_t g_dirty_since_ns, g_last_vsync_ns, g_tick_vsync_ns, g_hud_last_ns, g_rendered_tick_ns; +static int g_tick_held; +static int64_t g_hold_missed_ns; +#define HOLD_RETRY_NS 1000000000LL static int64_t g_refresh_ns = 16666667; volatile int g_render_on_commit = 1; volatile int g_release_unpaced = 1; @@ -43,7 +46,7 @@ static int vkp_framegen_active(void) { return framegen; } static int vkp_apply_window_request(void) { return window_requests; } static int vkp_effects_sync(void) { return effects_changes; } static int vkp_cardboard_pose_changed(void) { return pose_changes; } -static void render_scene(void) { renders++; g_dirty = 0; g_dirty_since_ns = 0; g_rendered_tick_ns = g_tick_vsync_ns; } +static void render_scene(void) { renders++; g_dirty = 0; g_dirty_since_ns = 0; g_rendered_tick_ns = g_tick_vsync_ns; g_tick_held = 0; } static int on_fallback_timer(void *data) { return 0; } static void on_commit_idle(void *data); ''' @@ -62,6 +65,8 @@ static void arrive(int64_t after_ns) { clock_ns += after_ns; schedule_render(); int main(void) { const int64_t refresh = 6944444, ms = 1000000; int64_t t = 1000000000LL; + int r0; + unsigned c0; g_refresh_ns = refresh; tick(t); assert(renders == 0); @@ -76,11 +81,11 @@ int main(void) { arrive(1 * ms); assert(idles_added == 1); tick(t += refresh); - assert(renders == 1); + assert(renders == 1 && g_tick_held == 1); arrive(2 * ms); assert(idles_added == 2); run_idle(); - assert(renders == 2 && g_pace.commit_renders == 2); + assert(renders == 2 && g_pace.commit_renders == 2 && g_tick_held == 0); /* a frame no other frame follows is drawn at the tick after next */ arrive(1 * ms); @@ -89,35 +94,83 @@ int main(void) { tick(t += refresh); assert(renders == 3 && g_pace.commit_renders == 2); - /* one frame per refresh, starting right after a tick draw, settles on drawing every frame when it arrives */ + /* after that, the tick draws every frame for a second, then holds one again */ + arrive(1 * ms); + tick(t += refresh); + assert(renders == 4 && g_tick_held == 0); + t += HOLD_RETRY_NS; + tick(t); + arrive(1 * ms); + run_idle(); + arrive(1 * ms); + tick(t += refresh); + assert(renders == 5 && g_tick_held == 1); arrive(2 * ms); - assert(idles_added == 2); + run_idle(); + assert(renders == 6 && g_pace.commit_renders == 4); + + /* one frame per refresh, starting right after a tick draw, settles on drawing every frame when it arrives */ + window_requests = 1; + tick(t += refresh); + window_requests = 0; + arrive(2 * ms); + r0 = renders; c0 = g_pace.commit_renders; for (int i = 0; i < 10; i++) { tick(t += refresh); arrive(2 * ms); run_idle(); } - assert(renders == 13 && g_pace.commit_renders == 12); + assert(renders - r0 == 10 && g_pace.commit_renders - c0 == 10); + + /* a client that draws again only after its frame callback (sent when the scene is drawn) keeps one frame + per refresh: two held frames in 200 refreshes, about 1.4 s */ + r0 = renders; c0 = g_pace.commit_renders; + { + int seen = renders - 1; + for (int i = 0; i < 200; i++) { + if (renders != seen) { seen = renders; arrive(1 * ms); run_idle(); } + tick(t += refresh); + } + } + assert(renders - r0 == 198 && g_pace.commit_renders == c0); /* a window, effect or headset change at the tick draws the waiting frame now */ + t += HOLD_RETRY_NS; + tick(t); + arrive(1 * ms); + run_idle(); + r0 = renders; arrive(1 * ms); window_requests = 1; tick(t += refresh); window_requests = 0; - assert(renders == 14 && g_pace.commit_renders == 12); + assert(renders - r0 == 1 && g_tick_held == 0); /* a draw queued before the tick still draws the frame once */ tick(t += refresh); + r0 = renders; c0 = g_pace.commit_renders; arrive(1 * ms); tick(t += refresh); - assert(renders == 14); + assert(renders == r0); run_idle(); - assert(renders == 15 && g_pace.commit_renders == 13); + assert(renders - r0 == 1 && g_pace.commit_renders - c0 == 1); tick(t += refresh); - assert(renders == 15); + assert(renders - r0 == 1); + + /* streaming switched on after the draw was queued leaves the frame for the tick */ + tick(t += refresh); + r0 = renders; c0 = g_pace.commit_renders; + arrive(1 * ms); + atomic_store(&g_stream_on, 1); + run_idle(); + assert(renders == r0); + tick(t += refresh); + atomic_store(&g_stream_on, 0); + assert(renders - r0 == 1 && g_pace.commit_renders == c0); /* paced output, frame generation, the switch off and streaming keep drawing on the tick */ const int idles = idles_added; + r0 = renders; for (int c = 0; c < 4; c++) { tick(t += refresh); if (c == 0) g_release_unpaced = 0; @@ -128,7 +181,7 @@ int main(void) { assert(idles_added == idles); tick(t += refresh); g_release_unpaced = 1; framegen = 0; g_render_on_commit = 1; atomic_store(&g_stream_on, 0); - assert(renders == 16 + c); + assert(renders - r0 == c + 1); } /* without screen ticks the fallback timer still draws */ @@ -150,6 +203,7 @@ class RenderOnCommitTest(unittest.TestCase): source = SOURCE.read_text() render = extract_function(source, 'render_scene') self.assertIn('g_rendered_tick_ns = g_tick_vsync_ns;', render) + self.assertIn('g_tick_held = 0;', render) functions = ('commit_renders_on', 'render_on_commit', 'schedule_render', 'scene_waits_for_game', 'on_commit_idle', 'on_vsync') harness = PREAMBLE + '\n'.join(extract_function(source, name) for name in functions) + CHECKS with tempfile.TemporaryDirectory(prefix='droiddeck-render-on-commit-') as folder: