From 8549ac9ce8128a036075e9402419de6eec103dfd Mon Sep 17 00:00:00 2001 From: The412Banner <205237651+The412Banner@users.noreply.github.com> Date: Wed, 28 Oct 2026 05:21:07 -0400 Subject: [PATCH] perf(compositor): draw a new frame when it arrives (#1707) A new game frame waited for the next screen tick before the compositor drew it: 1.9-3.5 ms on average at 144 Hz, measured with the pacing counters. With frames going straight back to the game (no compositor limit), the compositor now draws as soon as the clients' requests are handled, at most once per refresh, and presentation times stay on the tick. gamescope delivers about one frame per refresh, so the tick 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. Once a held frame is still waiting at the next tick (a client paced by frame callbacks), the tick draws every frame for a second before holding one again. The queued draw checks again that drawing on arrival is still on. Paced output (glasses), streaming and frame generation keep drawing on the tick. The hidden pref renderOnCommit (default on) turns it off. The pacing log line counts the scenes drawn on arrival. On the device new frames wait 0.12 ms instead of ~2 ms. --- app/src/main/cpp/waylandcomp/src/compositor.c | 56 ++++- .../cpp/waylandcomp/src/waylandcomp_jni.c | 7 + .../launcher/session/SessionPrefs.kt | 1 + .../launcher/wayland/CompositorHost.kt | 1 + .../launcher/wayland/WaylandCompositor.java | 2 + tools/tests/test_render_on_commit.py | 223 ++++++++++++++++++ 6 files changed, 283 insertions(+), 7 deletions(-) create mode 100644 tools/tests/test_render_on_commit.py diff --git a/app/src/main/cpp/waylandcomp/src/compositor.c b/app/src/main/cpp/waylandcomp/src/compositor.c index ff1a33ed2d..69c2e71871 100644 --- a/app/src/main/cpp/waylandcomp/src/compositor.c +++ b/app/src/main/cpp/waylandcomp/src/compositor.c @@ -263,9 +263,14 @@ static struct wl_event_source *g_render_idle, *g_frame_timer; 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, null_attaches, reattaches, presented, replaced, undrawn, distinct; + unsigned ticks, ticks_late_2ms, renders, commit_renders, null_attaches, reattaches, presented, replaced, undrawn, distinct; int64_t tick_late_ns, tick_late_max_ns, wait_ns, wait_max_ns; const void *buffers[PACE_BUFFERS]; uint64_t game_frames_seen; @@ -327,6 +332,7 @@ static struct { } g_perf; static void schedule_render(void); +static void on_commit_idle(void *data); static int64_t now_ns(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); @@ -2132,6 +2138,8 @@ static void render_scene(void) { g_dirty_since_ns = 0; } 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; @@ -2296,11 +2304,25 @@ static int on_fallback_timer(void *data) { return 0; } +/* 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 commit_renders_on() && !g_render_idle && g_rendered_tick_ns != g_tick_vsync_ns; +} + static void schedule_render(void) { if (!g_dirty && !g_dirty_since_ns) g_dirty_since_ns = now_ns(); g_dirty = 1; if (!g_display) return; - if (g_last_vsync_ns && now_ns() - g_last_vsync_ns < 100000000LL) return; + if (g_last_vsync_ns && now_ns() - g_last_vsync_ns < 100000000LL) { + if (render_on_commit()) + g_render_idle = wl_event_loop_add_idle(wl_display_get_event_loop(g_display), on_commit_idle, NULL); + return; + } if (g_fallback_armed) return; if (!g_fallback_timer) g_fallback_timer = wl_event_loop_add_timer(wl_display_get_event_loop(g_display), @@ -2314,6 +2336,13 @@ static int scene_waits_for_game(int64_t now) { return g_hud_surface && !g_hud_fresh && now - g_hud_last_ns < 100000000LL && vkp_framegen_active(); } +static void on_commit_idle(void *data) { + g_render_idle = NULL; + 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(); +} + static void on_vsync(int64_t frame_time_ns) { int64_t now = now_ns(); g_perf.ticks++; @@ -2330,9 +2359,22 @@ 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. 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(); } @@ -3440,13 +3482,13 @@ static int on_stats_timer(void *data) { if (g_pace.ticks || g_pace.renders || game || g_pace.reattaches || g_pace.null_attaches || g_pace.distinct || g_pace.presented || g_pace.replaced || g_pace.undrawn) { droiddeck_log("pacing", "last 10 s: tick reaches compositor %.2f/%.2f ms late (%u ticks, %u over 2 ms) | " - "new frame waits %.2f/%.2f ms to be drawn (%u scenes) | %llu game frames, %u re-attached after an " + "new frame waits %.2f/%.2f ms to be drawn (%u scenes, %u on arrival) | %llu game frames, %u re-attached after an " "empty attach, %u empty attaches, %u distinct buffers | feedback %u shown, %u replaced before drawing, " "%u not drawn", g_pace.ticks ? (double)g_pace.tick_late_ns / 1e6 / g_pace.ticks : 0.0, (double)g_pace.tick_late_max_ns / 1e6, g_pace.ticks, g_pace.ticks_late_2ms, g_pace.renders ? (double)g_pace.wait_ns / 1e6 / g_pace.renders : 0.0, (double)g_pace.wait_max_ns / 1e6, - g_pace.renders, (unsigned long long)game, g_pace.reattaches, g_pace.null_attaches, g_pace.distinct, + g_pace.renders, g_pace.commit_renders, (unsigned long long)game, g_pace.reattaches, g_pace.null_attaches, g_pace.distinct, g_pace.presented, g_pace.replaced, g_pace.undrawn); } { diff --git a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c index 675d4ac2ce..fad36f2823 100644 --- a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c +++ b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c @@ -36,6 +36,7 @@ extern void droiddeck_wayland_output_resized(void); extern void droiddeck_wayland_set_output_refresh_rate(int mhz); extern volatile int g_fps_limit; extern volatile int g_release_unpaced; +extern volatile int g_render_on_commit; extern volatile int g_hide_shell; extern volatile int g_zero_copy; extern volatile unsigned g_zero_copy_last; @@ -587,6 +588,12 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetLookName(JNIEnv * free(s); } +JNIEXPORT void JNICALL +Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetRenderOnCommit(JNIEnv *env, jclass clazz, jboolean on) { + g_render_on_commit = on ? 1 : 0; + __android_log_print(ANDROID_LOG_INFO, TAG, "render on commit %s", on ? "on" : "off"); +} + JNIEXPORT void JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetFpsLimit(JNIEnv *env, jclass clazz, jint fps) { g_fps_limit = fps > 0 ? fps : 0; diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index 52a9b4a78b..a98dabcead 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -603,6 +603,7 @@ object SessionPrefs { fun mangoapp(context: Context): Boolean = prefs(context).getBoolean("mangoapp", true) fun vsyncThread(context: Context): Boolean = prefs(context).getBoolean("vsyncThread", true) + fun renderOnCommit(context: Context): Boolean = prefs(context).getBoolean("renderOnCommit", true) fun setMangoapp(context: Context, on: Boolean) { prefs(context).edit().putBoolean("mangoapp", on).apply() } fun zinkLazy(context: Context): Boolean = prefs(context).getBoolean("zinkLazy", true) diff --git a/app/src/main/java/com/droiddeck/launcher/wayland/CompositorHost.kt b/app/src/main/java/com/droiddeck/launcher/wayland/CompositorHost.kt index fcf57b9515..ea06879faf 100644 --- a/app/src/main/java/com/droiddeck/launcher/wayland/CompositorHost.kt +++ b/app/src/main/java/com/droiddeck/launcher/wayland/CompositorHost.kt @@ -53,6 +53,7 @@ object CompositorHost { fpsLimit: Int, ): Boolean { ownVsyncThread = SessionPrefs.vsyncThread(context) + WaylandCompositor.nativeSetRenderOnCommit(SessionPrefs.renderOnCommit(context)) pace(refreshHz, fpsLimit) if (!SessionState.running) WaylandCompositor.nativeSetOutputSize(outputWidth, outputHeight) if (started) { diff --git a/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java b/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java index 206b182805..7aefad5738 100644 --- a/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java +++ b/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java @@ -284,6 +284,8 @@ public final class WaylandCompositor { public static native void nativeSetFpsLimit(int fps); + public static native void nativeSetRenderOnCommit(boolean on); + public static native void nativeSetGpuTurbo(boolean on); public static native int nativeRaisePriority(int tid, int nice); diff --git a/tools/tests/test_render_on_commit.py b/tools/tests/test_render_on_commit.py new file mode 100644 index 0000000000..d27c7646e1 --- /dev/null +++ b/tools/tests/test_render_on_commit.py @@ -0,0 +1,223 @@ +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +from test_output_refresh import SOURCE, extract_function + + +PREAMBLE = r''' +#include +#include +#include +#include + +struct wl_event_source { int armed; }; +static struct wl_event_source idle_source, timer_source; +static void (*idle_func)(void *); +static int idles_added, timers_armed, renders, window_requests, effects_changes, pose_changes; +static int64_t clock_ns; +static int g_display_storage; +static void *g_display = &g_display_storage; +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; +static atomic_int g_stream_on; +static struct { unsigned ticks, ticks_late_2ms, commit_renders; int64_t tick_late_ns, tick_late_max_ns; } g_pace; +static struct { unsigned ticks; } g_perf; +static int64_t now_ns(void) { return clock_ns; } +static void *wl_display_get_event_loop(void *display) { return display; } +static struct wl_event_source *wl_event_loop_add_idle(void *loop, void (*func)(void *), void *data) { + idles_added++; idle_func = func; return &idle_source; +} +static struct wl_event_source *wl_event_loop_add_timer(void *loop, int (*func)(void *), void *data) { return &timer_source; } +static int wl_event_source_timer_update(struct wl_event_source *source, int ms) { timers_armed++; return 0; } +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; g_tick_held = 0; } +static int on_fallback_timer(void *data) { return 0; } +static void on_commit_idle(void *data); +''' + +CHECKS = r''' +static void run_idle(void) { + void (*func)(void *) = idle_func; + idle_func = NULL; + if (func) func(NULL); +} + +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, ms = 1000000; + int64_t t = 1000000000LL; + int r0; + unsigned c0; + g_refresh_ns = refresh; + tick(t); + assert(renders == 0); + + /* a new frame is drawn when it arrives */ + 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 is left for the next arrival, which is drawn when it arrives */ + arrive(1 * ms); + assert(idles_added == 1); + tick(t += refresh); + assert(renders == 1 && g_tick_held == 1); + arrive(2 * ms); + assert(idles_added == 2); + run_idle(); + 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); + tick(t += refresh); + assert(renders == 2); + tick(t += refresh); + assert(renders == 3 && g_pace.commit_renders == 2); + + /* 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); + 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 - 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 - 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 == r0); + run_idle(); + assert(renders - r0 == 1 && g_pace.commit_renders - c0 == 1); + tick(t += refresh); + 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; + if (c == 1) framegen = 1; + if (c == 2) g_render_on_commit = 0; + if (c == 3) atomic_store(&g_stream_on, 1); + arrive(1 * ms); + 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 - r0 == c + 1); + } + + /* without screen ticks the fallback timer still draws */ + clock_ns += 200000000LL; + schedule_render(); + assert(idles_added == idles && g_fallback_armed == 1 && timers_armed == 1); + puts("PASS"); + return 0; +} +''' + + +@unittest.skipUnless(sys.platform.startswith('linux'), 'needs a Linux host compiler') +class RenderOnCommitTest(unittest.TestCase): + def test_a_new_frame_is_drawn_on_arrival_at_most_once_per_refresh(self): + compiler = shutil.which(os.environ.get('CC', 'cc')) + if compiler is None: + self.skipTest('A host C compiler is required') + 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: + path = Path(folder) + (path / 'commit.c').write_text(harness) + binary = path / 'commit-test' + build = subprocess.run([compiler, '-std=c11', '-Wall', '-Wextra', '-Werror', + '-Wno-unused-parameter', '-Wno-unused-function', '-O2', + str(path / 'commit.c'), '-o', str(binary)], capture_output=True, text=True) + self.assertEqual(0, build.returncode, build.stderr) + result = subprocess.run([str(binary)], capture_output=True, text=True, timeout=10) + self.assertEqual(0, result.returncode, result.stderr) + self.assertEqual('PASS', result.stdout.strip()) + + +if __name__ == '__main__': + unittest.main()