From 1c245df6b6f0389e1eef9a8cdc4a82abd1d13863 Mon Sep 17 00:00:00 2001 From: The412Banner Date: Wed, 28 Oct 2026 02:21:27 +0000 Subject: [PATCH] fix(compositor): keep drawing frames on arrival at one frame per refresh On the device, render-on-commit drew only 4-12 % of frames on arrival while a game ran uncapped: gamescope delivers about one frame per refresh, so once the tick drew a frame, the next one arrived in the same refresh, was held back by the once-per-refresh limit and was drawn by the next tick, which held back the one after it. Waits stayed at ~2 ms. The tick now leaves a frame younger than one refresh for the next arrival to draw, unless the tick itself changed the window, effects or headset pose. A frame no other frame follows is drawn at the tick after. --- app/src/main/cpp/waylandcomp/src/compositor.c | 18 +++-- tools/tests/test_render_on_commit.py | 75 ++++++++++++------- 2 files changed, 61 insertions(+), 32 deletions(-) diff --git a/app/src/main/cpp/waylandcomp/src/compositor.c b/app/src/main/cpp/waylandcomp/src/compositor.c index 12d6b6d643..9437c3afa8 100644 --- a/app/src/main/cpp/waylandcomp/src/compositor.c +++ b/app/src/main/cpp/waylandcomp/src/compositor.c @@ -2302,9 +2302,12 @@ static int on_fallback_timer(void *data) { /* A new frame is drawn when it arrives instead of at the next screen tick, at most once per refresh, while frames go straight back to the game (no compositor limit), without streaming or frame generation. */ +static int commit_renders_on(void) { + return g_render_on_commit && g_release_unpaced && !atomic_load(&g_stream_on) && !vkp_framegen_active(); +} + static int render_on_commit(void) { - return g_render_on_commit && g_release_unpaced && !g_render_idle && g_rendered_tick_ns != g_tick_vsync_ns && - !atomic_load(&g_stream_on) && !vkp_framegen_active(); + return commit_renders_on() && !g_render_idle && g_rendered_tick_ns != g_tick_vsync_ns; } static void schedule_render(void) { @@ -2352,9 +2355,14 @@ static void on_vsync(int64_t frame_time_ns) { } g_last_vsync_ns = now; g_tick_vsync_ns = frame_time_ns; - if (vkp_apply_window_request()) g_dirty = 1; - if (vkp_effects_sync()) g_dirty = 1; - if (vkp_cardboard_pose_changed()) g_dirty = 1; + int tick_change = 0; + if (vkp_apply_window_request()) tick_change = 1; + if (vkp_effects_sync()) tick_change = 1; + 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; 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 4fe9f84a3a..9da61cd989 100644 --- a/tools/tests/test_render_on_commit.py +++ b/tools/tests/test_render_on_commit.py @@ -57,63 +57,84 @@ static void run_idle(void) { static void tick(int64_t t) { clock_ns = t; on_vsync(t); } +static void arrive(int64_t after_ns) { clock_ns += after_ns; schedule_render(); } + int main(void) { - const int64_t refresh = 6944444; + const int64_t refresh = 6944444, ms = 1000000; int64_t t = 1000000000LL; + g_refresh_ns = refresh; tick(t); assert(renders == 0); /* a new frame is drawn when it arrives */ - clock_ns += 2000000; - schedule_render(); + arrive(2 * ms); assert(idles_added == 1 && renders == 0); run_idle(); assert(renders == 1 && g_pace.commit_renders == 1 && g_render_idle == NULL); - /* a second frame in the same refresh waits for the tick */ - clock_ns += 1000000; - schedule_render(); + /* a second frame in the same refresh is left for the next arrival, which is drawn when it arrives */ + arrive(1 * ms); assert(idles_added == 1); tick(t += refresh); - assert(renders == 2 && g_pace.commit_renders == 1); + assert(renders == 1); + arrive(2 * ms); + assert(idles_added == 2); + run_idle(); + assert(renders == 2 && g_pace.commit_renders == 2); - /* when the tick comes first, the queued draw does nothing */ + /* a frame no other frame follows is drawn at the tick after next */ + arrive(1 * ms); tick(t += refresh); assert(renders == 2); - clock_ns += 1000000; - schedule_render(); - assert(idles_added == 2); tick(t += refresh); - assert(renders == 3); + 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 */ + arrive(2 * ms); + assert(idles_added == 2); + for (int i = 0; i < 10; i++) { + tick(t += refresh); + arrive(2 * ms); + run_idle(); + } + assert(renders == 13 && g_pace.commit_renders == 12); + + /* a window, effect or headset change at the tick draws the waiting frame now */ + arrive(1 * ms); + window_requests = 1; + tick(t += refresh); + window_requests = 0; + assert(renders == 14 && g_pace.commit_renders == 12); + + /* a draw queued before the tick still draws the frame once */ + tick(t += refresh); + arrive(1 * ms); + tick(t += refresh); + assert(renders == 14); run_idle(); - assert(renders == 3 && g_pace.commit_renders == 1); + assert(renders == 15 && g_pace.commit_renders == 13); + tick(t += refresh); + assert(renders == 15); /* paced output, frame generation, the switch off and streaming keep drawing on the tick */ + const int idles = idles_added; for (int c = 0; c < 4; c++) { tick(t += refresh); if (c == 0) g_release_unpaced = 0; if (c == 1) framegen = 1; if (c == 2) g_render_on_commit = 0; if (c == 3) atomic_store(&g_stream_on, 1); - clock_ns += 1000000; - schedule_render(); - assert(idles_added == 2); - g_release_unpaced = 1; framegen = 0; g_render_on_commit = 1; atomic_store(&g_stream_on, 0); + arrive(1 * ms); + assert(idles_added == idles); tick(t += refresh); - assert(renders == 4 + c); + g_release_unpaced = 1; framegen = 0; g_render_on_commit = 1; atomic_store(&g_stream_on, 0); + assert(renders == 16 + c); } - tick(t += refresh); - clock_ns += 1000000; - schedule_render(); - assert(idles_added == 3); - run_idle(); - assert(renders == 8 && g_pace.commit_renders == 2); - /* without screen ticks the fallback timer still draws */ clock_ns += 200000000LL; schedule_render(); - assert(idles_added == 3 && g_fallback_armed == 1 && timers_armed == 1); + assert(idles_added == idles && g_fallback_armed == 1 && timers_armed == 1); puts("PASS"); return 0; } @@ -129,7 +150,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) - functions = ('render_on_commit', 'schedule_render', 'scene_waits_for_game', 'on_commit_idle', 'on_vsync') + 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: path = Path(folder)