diff --git a/app/src/main/cpp/waylandcomp/CMakeLists.txt b/app/src/main/cpp/waylandcomp/CMakeLists.txt index 61baf0d379..c7aa1b0eb4 100644 --- a/app/src/main/cpp/waylandcomp/CMakeLists.txt +++ b/app/src/main/cpp/waylandcomp/CMakeLists.txt @@ -1,5 +1,6 @@ add_library(droiddeckwayland SHARED src/compositor.c + src/clock_domain.c src/vk_present.c src/effects_chain.c src/cardboard.c diff --git a/app/src/main/cpp/waylandcomp/src/clock_domain.c b/app/src/main/cpp/waylandcomp/src/clock_domain.c new file mode 100644 index 0000000000..30fd73a4eb --- /dev/null +++ b/app/src/main/cpp/waylandcomp/src/clock_domain.c @@ -0,0 +1,72 @@ +#define _GNU_SOURCE +#include "clock_domain.h" + +#include +#include +#include +#include +#include +#include +#include + +static const int64_t *g_shift; +static pthread_mutex_t g_control_lock = PTHREAD_MUTEX_INITIALIZER; +static dev_t g_device; +static ino_t g_inode; + +void droiddeck_clock_domain_set_control(const char *path) { + int fd; + struct stat st; + pthread_mutex_lock(&g_control_lock); + if (!path || !*path) { + const int64_t *previous = g_shift; + g_shift = NULL; + if (previous) munmap((void *)previous, sizeof(*previous)); + pthread_mutex_unlock(&g_control_lock); + return; + } + fd = open(path, O_RDONLY | O_CLOEXEC); + if (fd < 0 || fstat(fd, &st) != 0 || st.st_size < (off_t)sizeof(int64_t)) { + if (fd >= 0) close(fd); + pthread_mutex_unlock(&g_control_lock); + return; + } + if (g_shift && st.st_dev == g_device && st.st_ino == g_inode) { + close(fd); + pthread_mutex_unlock(&g_control_lock); + return; + } + const int64_t *shift = mmap(NULL, sizeof(*shift), PROT_READ, MAP_SHARED, fd, 0); + close(fd); + if (shift != MAP_FAILED) { + g_device = st.st_dev; + g_inode = st.st_ino; + const int64_t *previous = g_shift; + g_shift = shift; + if (previous) munmap((void *)previous, sizeof(*previous)); + } + pthread_mutex_unlock(&g_control_lock); +} + +static int64_t shift_ns(void) { + pthread_mutex_lock(&g_control_lock); + const int64_t *mapping = g_shift; + int64_t shift = mapping ? __atomic_load_n(mapping, __ATOMIC_RELAXED) : 0; + pthread_mutex_unlock(&g_control_lock); + return shift > 0 ? shift : 0; +} + +int64_t droiddeck_clock_domain_adjust_ns(int64_t value) { + int64_t shift = shift_ns(); + return value > shift ? value - shift : 0; +} + +int64_t droiddeck_clock_domain_now_ns(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return droiddeck_clock_domain_adjust_ns((int64_t)ts.tv_sec * 1000000000LL + ts.tv_nsec); +} + +uint32_t droiddeck_clock_domain_now_ms(void) { + return (uint32_t)(droiddeck_clock_domain_now_ns() / 1000000LL); +} diff --git a/app/src/main/cpp/waylandcomp/src/clock_domain.h b/app/src/main/cpp/waylandcomp/src/clock_domain.h new file mode 100644 index 0000000000..acb7e0e174 --- /dev/null +++ b/app/src/main/cpp/waylandcomp/src/clock_domain.h @@ -0,0 +1,11 @@ +#ifndef DROIDDECK_CLOCK_DOMAIN_H +#define DROIDDECK_CLOCK_DOMAIN_H + +#include + +void droiddeck_clock_domain_set_control(const char *path); +int64_t droiddeck_clock_domain_now_ns(void); +uint32_t droiddeck_clock_domain_now_ms(void); +int64_t droiddeck_clock_domain_adjust_ns(int64_t value); + +#endif diff --git a/app/src/main/cpp/waylandcomp/src/compositor.c b/app/src/main/cpp/waylandcomp/src/compositor.c index 21ef1d23f9..3510ea29a3 100644 --- a/app/src/main/cpp/waylandcomp/src/compositor.c +++ b/app/src/main/cpp/waylandcomp/src/compositor.c @@ -36,6 +36,7 @@ #include "droiddeck_ext.h" #include "droiddeck_color.h" #include "compositor_internal.h" +#include "clock_domain.h" #define WLOGI(...) __android_log_print(ANDROID_LOG_INFO, "DroidDeckWayland", __VA_ARGS__) #define WLOGE(...) __android_log_print(ANDROID_LOG_ERROR, "DroidDeckWayland", __VA_ARGS__) @@ -727,9 +728,7 @@ static void on_pending_buffer_destroyed(struct wl_listener *l, void *data) { static void fire_frames(struct wl_list *frames) { struct wl_resource *cb, *tmp; uint32_t t; - struct timespec ts; - clock_gettime(CLOCK_MONOTONIC, &ts); - t = (uint32_t)(ts.tv_sec * 1000 + ts.tv_nsec / 1000000); + t = droiddeck_clock_domain_now_ms(); wl_resource_for_each_safe(cb, tmp, frames) { wl_callback_send_done(cb, t); wl_resource_destroy(cb); @@ -1061,6 +1060,7 @@ static int64_t presented_ns(int64_t render_ns) { static void feedback_present_all(struct wl_list *list, int64_t t) { struct wl_resource *fb, *tmp; + t = droiddeck_clock_domain_adjust_ns(t); uint64_t sec = (uint64_t)(t / 1000000000LL); uint32_t nsec = (uint32_t)(t % 1000000000LL); wl_resource_for_each_safe(fb, tmp, list) { @@ -2493,8 +2493,7 @@ static void on_vsync(int64_t frame_time_ns) { static uint32_t now_ms(void) { - struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); - return (uint32_t)(ts.tv_sec * 1000 + ts.tv_nsec / 1000000); + return droiddeck_clock_domain_now_ms(); } static void pointer_set_cursor(struct wl_client *c, struct wl_resource *r, uint32_t serial, @@ -3114,12 +3113,10 @@ static void relative_pointers_pointer_gone(struct wl_resource *pointer) { static int send_relative_motion(struct wl_client *client, double dx, double dy) { struct relative_pointer *rp; - struct timespec ts; uint64_t ut; int sent = 0; if (dx == 0 && dy == 0) return 0; - clock_gettime(CLOCK_MONOTONIC, &ts); - ut = (uint64_t)ts.tv_sec * 1000000ULL + (uint64_t)ts.tv_nsec / 1000; + ut = (uint64_t)(droiddeck_clock_domain_now_ns() / 1000); wl_list_for_each(rp, &g_relative_pointers, link) { if (!rp->pointer || wl_resource_get_client(rp->pointer) != client) continue; zwp_relative_pointer_v1_send_relative_motion(rp->resource, (uint32_t)(ut >> 32), (uint32_t)ut, diff --git a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c index ffbfdfd935..25b97ae0f8 100644 --- a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c +++ b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c @@ -18,6 +18,7 @@ #include "cardboard.h" #include "droiddeck_color.h" #include "gpu_clock_pin.h" +#include "clock_domain.h" extern int droiddeck_wayland_run(void); extern void droiddeck_wayland_set_scale_mode(int mode, int alignment); @@ -354,6 +355,13 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeVsync(JNIEnv *env, j droiddeck_wayland_vsync((int64_t)frameTimeNanos); } +JNIEXPORT void JNICALL +Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetClockControl(JNIEnv *env, jclass clazz, jstring path) { + const char *value = path ? (*env)->GetStringUTFChars(env, path, NULL) : NULL; + droiddeck_clock_domain_set_control(value); + if (value) (*env)->ReleaseStringUTFChars(env, path, value); +} + JNIEXPORT void JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetHideShell(JNIEnv *env, jclass clazz, jboolean hide) { g_hide_shell = hide ? 1 : 0; diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt index 2af6510093..232eaf0c6d 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -822,6 +822,7 @@ class SessionService : Service() { }, zramControl = File(filesDir, "${LinuxRuntime.DIR}/tmp/.bl-zram"), clockControl = File(filesDir, "${LinuxRuntime.DIR}/tmp/.bl-clock"), + mapClockControl = { WaylandCompositor.nativeSetClockControl(it.path) }, pagedOut = { processes, unacknowledged, residentKb, swapKb, swapBeforeKb, millis -> Log.i(TAG, "paged out $processes processes ($unacknowledged unacknowledged) in $millis ms: " + "resident ${residentKb / 1024} MB, zram ${swapBeforeKb / 1024} -> ${swapKb / 1024} MB") diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionSuspendController.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionSuspendController.kt index b0a6852144..ad7360d8ee 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionSuspendController.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionSuspendController.kt @@ -23,6 +23,7 @@ internal class SessionSuspendController( private val executor: ExecutorService = Executors.newSingleThreadExecutor(), private val zramControl: File? = null, private val clockControl: File? = null, + private val mapClockControl: (File) -> Unit = {}, private val nowNanos: () -> Long = System::nanoTime, private val pagedOut: (processes: Int, unacknowledged: Int, residentKb: Long, swapKb: Long, swapBeforeKb: Long, millis: Long) -> Unit = { _, _, _, _, _, _ -> }, @@ -154,6 +155,7 @@ internal class SessionSuspendController( frozenSince = null val control = clockControl?.takeIf { it.isFile && it.length() >= Long.SIZE_BYTES } ?: return try { + mapClockControl(control) RandomAccessFile(control, "rw").use { file -> val bytes = ByteArray(Long.SIZE_BYTES) file.readFully(bytes) 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 7166440029..7fcdc09620 100644 --- a/app/src/main/java/com/droiddeck/launcher/wayland/CompositorHost.kt +++ b/app/src/main/java/com/droiddeck/launcher/wayland/CompositorHost.kt @@ -50,6 +50,7 @@ object CompositorHost { refreshHz: Float, fpsLimit: Int, ): Boolean { + WaylandCompositor.nativeSetClockControl(java.io.File(context.filesDir, "${com.droiddeck.launcher.runtime.LinuxRuntime.DIR}/tmp/.bl-clock").path) ownVsyncThread = SessionPrefs.vsyncThread(context) WaylandCompositor.nativeSetRenderOnCommit(SessionPrefs.renderOnCommit(context)) pace(refreshHz, fpsLimit) @@ -135,7 +136,9 @@ object CompositorHost { vsyncRunning = false } + @Synchronized fun newSession() { + WaylandCompositor.nativeSetClockControl(null) if (started) WaylandCompositor.nativeResetFirstFrame() } 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 a2ac2171df..995f512471 100644 --- a/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java +++ b/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java @@ -178,6 +178,8 @@ public final class WaylandCompositor { public static native void nativeVsync(long frameTimeNanos); + public static native void nativeSetClockControl(String path); + public static native int nativeCompositorTid(); private static native String nativeCompositorFault(); diff --git a/app/src/test/java/com/droiddeck/launcher/session/SessionSuspendControllerTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SessionSuspendControllerTest.kt index 230eb1f12e..44aa6c73cd 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SessionSuspendControllerTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SessionSuspendControllerTest.kt @@ -273,9 +273,12 @@ class SessionSuspendControllerTest { val fixture = fixture(17) fixture.clock.writeBytes(shift(5_000_000L)) fixture.controller.freeze { assertTrue(it) } + fixture.clock.delete() + fixture.clock.writeBytes(shift(5_000_000L)) fixture.now += 90_000L fixture.controller.resume { assertTrue(it) } val expected = 5_000_000L + 90_000L * 1_000_000L + assertEquals(5_000_000L, fixture.clockAtMapping) assertEquals(expected, fixture.clockAtContinue) assertEquals(expected, shift(fixture.clock)) fixture.controller.resume { assertTrue(it) } @@ -478,6 +481,7 @@ class SessionSuspendControllerTest { val control = File(tmp, ".bl-zram") val clock = File(tmp, ".bl-clock") var clockAtContinue: Long? = null + var clockAtMapping: Long? = null val pagedOut = mutableListOf>() val pagedIn = mutableListOf>() var availableKb = 8_000_000L @@ -496,6 +500,7 @@ class SessionSuspendControllerTest { proc, ::signal, ::threadSignal, ::sleep, { now }, executor, zramControl = control, clockControl = clock, + mapClockControl = { clockAtMapping = ByteBuffer.wrap(it.readBytes()).order(ByteOrder.LITTLE_ENDIAN).long }, nowNanos = { now * 1_000_000L }, pagedOut = { processes, unacknowledged, resident, swap, _, _ -> pagedOut += Triple(processes, resident, swap) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index 37fb2c00ad..df27767405 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -132,8 +132,7 @@ clear_stale_tmp() { [ -z "${BL_INSIDE:-}" ] && clear_stale_tmp if [ -z "${BL_INSIDE:-}" ]; then if [ "${BL_ZRAM:-0}" = 1 ]; then printf 0 > /tmp/.bl-zram; else rm -f /tmp/.bl-zram; fi - rm -f /tmp/.bl-clock - head -c 8 /dev/zero > /tmp/.bl-clock + dd if=/dev/zero of=/tmp/.bl-clock bs=8 count=1 conv=notrunc status=none fi steam_devtools() { diff --git a/tools/linuxfs/preload/clockpause.c b/tools/linuxfs/preload/clockpause.c index 19a1d728ab..eed7a401d7 100644 --- a/tools/linuxfs/preload/clockpause.c +++ b/tools/linuxfs/preload/clockpause.c @@ -81,7 +81,6 @@ static void cp_init(void) { struct stat st; void *map; int fd; - if (strcmp(program_invocation_short_name, "plasmashell") != 0) return; if (!cp_find_cond_bit()) return; fd = open(CP_CTL, O_RDONLY | O_CLOEXEC); if (fd < 0) return; diff --git a/tools/tests/test_clock_pause_preload.py b/tools/tests/test_clock_pause_preload.py index 6523811125..06ddd65a49 100644 --- a/tools/tests/test_clock_pause_preload.py +++ b/tools/tests/test_clock_pause_preload.py @@ -1,19 +1,34 @@ import os from pathlib import Path +import queue +import re +import shlex import shutil import struct import subprocess import tempfile +import threading import unittest PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload" + +def clock_reset_command(control): + script = (PRELOAD.parent / "overlay/usr/local/bin/droiddeck-session").read_text() + start = script.index('if [ -z "${BL_INSIDE:-}" ]; then\n if [ "${BL_ZRAM:-0}"') + end = script.index("\nfi", start) + len("\nfi") + paths = {"/tmp/.bl-clock": shlex.quote(str(control)), + "/tmp/.bl-zram": shlex.quote(str(control.parent / "zram"))} + pattern = "|".join(re.escape(token) for token in paths) + return 'BL_INSIDE=; BL_ZRAM=0; ' + re.sub(pattern, lambda match: paths[match.group(0)], script[start:end]) + PROGRAM = r""" #define _GNU_SOURCE #include #include #include #include +#include #include #include #include @@ -36,12 +51,26 @@ static int64_t start; static void begin(void) { start = ns(CLOCK_BOOTTIME); } static void end(const char *name) { printf("%s %lld\n", name, (long long)((ns(CLOCK_BOOTTIME) - start) / 1000000LL)); } +static unsigned long long memory_probe(void) { + static volatile unsigned char memory[4 * 1024 * 1024]; + unsigned long long checksum = 0; + for (size_t i = 0; i < sizeof(memory); i += 4096) memory[i] = (unsigned char)(i / 4096 + 1); + for (size_t i = 0; i < sizeof(memory); i += 4096) checksum += memory[i]; + return checksum; +} + int main(void) { const int64_t wait = 60000000LL; printf("gap %lld\n", (long long)((ns(CLOCK_BOOTTIME) - ns(CLOCK_MONOTONIC)) / 1000000LL)); struct timespec raw; syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &raw); printf("rawgap %lld\n", (long long)((ns(CLOCK_BOOTTIME) - ((int64_t)raw.tv_sec * 1000000000LL + raw.tv_nsec)) / 1000000LL)); + printf("memory %llu\n", memory_probe()); + if (getenv("CLOCK_PAUSE_WAIT")) { puts("ready"); fflush(stdout); getchar(); } + if (getenv("CLOCK_PAUSE_WAIT")) { + printf("livegap %lld\n", (long long)((ns(CLOCK_BOOTTIME) - ns(CLOCK_MONOTONIC)) / 1000000LL)); + printf("livememory %llu\n", memory_probe()); + } pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_condattr_t attr; @@ -124,14 +153,124 @@ class ClockPausePreloadTest(unittest.TestCase): self.assertGreaterEqual(paused[name], 50, name) self.assertLess(paused[name], 1000, name) - def test_other_programs_keep_the_real_clock(self): + def test_program_without_preload_keeps_the_real_clock(self): plain = self.run_program(self.other, 0, preload=False) - paused = self.run_program(self.other, SHIFT_MS) + paused = self.run_program(self.other, SHIFT_MS, preload=False) self.assertAlmostEqual(paused["gap"], plain["gap"], delta=50) for name in ("cond_mono", "clockwait", "sem", "nanosleep", "timerfd", "futex"): self.assertGreaterEqual(paused[name], 50, name) self.assertLess(paused[name], 1000, name) + def test_every_session_program_stops_monotonic_clock_and_keeps_memory_access(self): + plain = self.run_program(self.other, 0) + paused = self.run_program(self.other, SHIFT_MS) + self.assertAlmostEqual(paused["gap"] - plain["gap"], SHIFT_MS, delta=50) + self.assertAlmostEqual(paused["rawgap"] - plain["rawgap"], SHIFT_MS, delta=50) + self.assertEqual(plain["memory"], 130560) + self.assertEqual(paused["memory"], 130560) + + def test_running_session_program_observes_pause_offset_update(self): + self.check_running_offset_update(False) + + def test_session_reset_preserves_live_guest_mapping(self): + self.check_running_offset_update(True) + + def check_running_offset_update(self, reset): + self.control.write_bytes(struct.pack("\n' + '#include "clock_domain.h"\n' + 'int main(int argc, char **argv) { (void)argc;\n' + ' droiddeck_clock_domain_set_control(argv[1]);\n' + ' printf("%lld %u %lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL), ' + ' droiddeck_clock_domain_now_ms(), (long long)droiddeck_clock_domain_adjust_ns(5LL * 1000000000LL));\n' + ' return 0;\n' + '}\n' + ) + binary = root / "program" + subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), "-o", str(binary), str(program), str(SOURCE)], + check=True) + result = subprocess.run([str(binary), str(control)], capture_output=True, text=True, check=True) + adjusted, now_ms, clamped = map(int, result.stdout.split()) + self.assertEqual(adjusted, 20_000_000_000) + self.assertGreaterEqual(now_ms, 0) + self.assertLessEqual(now_ms, 0xFFFFFFFF) + self.assertEqual(clamped, 0) + + def test_paced_release_uses_kernel_time_across_pause_offsets(self): + compositor = SOURCE.with_name("compositor.c").read_text() + functions = extract_function(compositor, "now_ns") + "\n" + extract_void_function(compositor, "arm_release_timer") + harness = r''' +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include "clock_domain.h" + +struct pending_release { void *buffer; int64_t at_ns; struct pending_release *next; }; +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) +static int buffer_release_blocked(void *buffer) { return buffer != NULL; } + +@FUNCTIONS@ + +int main(int argc, char **argv) { + (void)argc; + droiddeck_clock_domain_set_control(argv[1]); + int control = open(argv[1], O_WRONLY); + assert(control >= 0); + g_release_timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC); + assert(g_release_timer_fd >= 0); + const int64_t offsets[] = {0, 10000000000LL, 300000000000LL}; + for (unsigned i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) { + assert(pwrite(control, &offsets[i], sizeof(offsets[i]), 0) == sizeof(offsets[i])); + 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}; + g_pending_releases = &release; + arm_release_timer(); + int64_t next_offset = offsets[i] + 10000000000LL; + assert(pwrite(control, &next_offset, sizeof(next_offset), 0) == sizeof(next_offset)); + struct pollfd pollfd = {g_release_timer_fd, POLLIN, 0}; + assert(poll(&pollfd, 1, 1000) == 1); + clock_gettime(CLOCK_MONOTONIC, &ended); + int64_t elapsed = (ended.tv_sec - started.tv_sec) * 1000000000LL + ended.tv_nsec - started.tv_nsec; + assert(elapsed >= 50000000LL && elapsed < 1000000000LL); + uint64_t expirations; + assert(read(g_release_timer_fd, &expirations, sizeof(expirations)) == sizeof(expirations)); + assert(expirations == 1); + g_pending_releases = &blocked; + arm_release_timer(); + struct itimerspec remaining; + assert(timerfd_gettime(g_release_timer_fd, &remaining) == 0); + assert(remaining.it_value.tv_sec == 0 && remaining.it_value.tv_nsec == 0); + } + close(g_release_timer_fd); + close(control); + return 0; +} +''' + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + control = root / "clock" + control.write_bytes(struct.pack("\n' + '#include "clock_domain.h"\n' + 'int main(int argc, char **argv) { (void)argc;\n' + ' droiddeck_clock_domain_set_control(argv[1]);\n' + ' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n' + ' droiddeck_clock_domain_set_control(argv[2]);\n' + ' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n' + ' return 0;\n' + '}\n' + ) + binary = root / "program" + subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), "-o", str(binary), str(program), str(SOURCE)], + check=True) + result = subprocess.run([str(binary), str(control), str(root / "missing")], capture_output=True, text=True, check=True) + self.assertEqual(result.stdout.split(), ["30000000000", "30000000000"]) + + def test_replaced_control_file_updates_offset_without_invalidating_readers(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + control = root / "clock" + replacement = root / "replacement" + control.write_bytes(struct.pack("\n' + '#include "clock_domain.h"\n' + 'int main(int argc, char **argv) { (void)argc;\n' + ' droiddeck_clock_domain_set_control(argv[1]);\n' + ' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n' + ' if (rename(argv[2], argv[1]) != 0) return 1;\n' + ' droiddeck_clock_domain_set_control(argv[1]);\n' + ' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n' + ' return 0;\n' + '}\n' + ) + binary = root / "program" + subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), "-o", str(binary), str(program), str(SOURCE)], + check=True) + result = subprocess.run([str(binary), str(control), str(replacement)], capture_output=True, text=True, check=True) + self.assertEqual(result.stdout.split(), ["20000000000", "10000000000"]) + + def test_session_transition_clears_stale_offset_but_live_failures_preserve_it(self): + harness = r''' +#include +#include +#include +#include +#include "clock_domain.h" + +int main(int argc, char **argv) { + (void)argc; + int64_t shift = 10000000000LL; + int fd = open(argv[1], O_CREAT | O_RDWR, 0600); + assert(fd >= 0); + assert(write(fd, &shift, sizeof(shift)) == sizeof(shift)); + droiddeck_clock_domain_set_control(argv[1]); + assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 20000000000LL); + assert(unlink(argv[1]) == 0); + droiddeck_clock_domain_set_control(argv[1]); + assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 20000000000LL); + int replacement = open(argv[1], O_CREAT | O_RDWR, 0600); + assert(replacement >= 0); + droiddeck_clock_domain_set_control(argv[1]); + assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 20000000000LL); + droiddeck_clock_domain_set_control(NULL); + droiddeck_clock_domain_set_control(argv[1]); + assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 30000000000LL); + shift = 20000000000LL; + assert(write(replacement, &shift, sizeof(shift)) == sizeof(shift)); + droiddeck_clock_domain_set_control(argv[1]); + assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 10000000000LL); + close(replacement); + close(fd); + return 0; +} +''' + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + program = root / "program.c" + program.write_text(harness) + binary = root / "program" + subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), + "-o", str(binary), str(program), str(SOURCE)], check=True) + subprocess.run([str(binary), str(root / "clock")], check=True, timeout=5) + host = SOURCE.parents[3] / "java/com/droiddeck/launcher/wayland/CompositorHost.kt" + self.assertIn("nativeSetClockControl(null)", host.read_text().split("fun newSession() {", 1)[1].split("}", 1)[0]) + + def test_startup_reset_keeps_host_and_guest_on_the_same_inode(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + control = root / "clock" + control.write_bytes(struct.pack("\n' + '#include "clock_domain.h"\n' + 'int main(int argc, char **argv) { (void)argc;\n' + ' droiddeck_clock_domain_set_control(argv[1]);\n' + ' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n' + ' if (rename(argv[2], argv[1]) != 0) return 1;\n' + ' droiddeck_clock_domain_set_control(argv[1]);\n' + ' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n' + ' return 0;\n' + '}\n' + ) + binary = root / "program" + subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), + "-o", str(binary), str(program), str(SOURCE)], check=True) + result = subprocess.run([str(binary), str(control), str(replacement)], capture_output=True, text=True, check=True) + self.assertEqual(result.stdout.split(), ["30000000000", "10000000000"]) + + +if __name__ == "__main__": + unittest.main()