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()