Files
DroidDeck/tools/tests/test_wayland_clock_domain.py
T
The412Bannerandmaxjivi05 a139d9eff4 fix(compositor): hold releases from synchronized subsurfaces until the parent commits (#2721)
* fix(compositor): hold releases from synchronized subsurfaces until the parent commits

gamescope's Wayland backend moves layers between synchronized subsurface
planes and commits the parent last. Each child commit was applied at once,
so a buffer leaving one plane could be released before the next plane took
it, and gamescope then logged "Compositor released us but we were not
acquired". A buffer attached again also dropped its queued release, and the
buffer trace records every attach.

* fix(compositor): hold a synchronized release at its sync boundary and recheck holds on set_desync

---------

Co-authored-by: maxjivi05 <maxjividen@gmail.com>
2026-11-18 11:10:57 -05:00

268 lines
13 KiB
Python

import ctypes
import mmap
import shutil
from pathlib import Path
import struct
import subprocess
import tempfile
import unittest
from tools.tests.test_clock_pause_preload import clock_reset_command
from tools.tests.test_output_refresh import extract_function as extract_void_function
from tools.tests.test_scene_limit_hold import extract_function
SOURCE = Path(__file__).resolve().parents[2] / "app/src/main/cpp/waylandcomp/src/clock_domain.c"
HEADER = SOURCE.with_suffix(".h")
@unittest.skipUnless(shutil.which("cc"), "needs a C compiler")
class WaylandClockDomainTest(unittest.TestCase):
def test_host_timestamp_uses_the_guest_domain(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
control = root / "clock"
control.write_bytes(struct.pack("<q", 10_000_000_000))
program = root / "program.c"
program.write_text(
'#include <stdio.h>\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 <assert.h>
#include <fcntl.h>
#include <poll.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/timerfd.h>
#include <time.h>
#include <unistd.h>
#include "clock_domain.h"
struct pending_release { void *buffer; int64_t at_ns; struct pending_release *next; void *held_by; };
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, NULL};
struct pending_release release = {NULL, start + 60000000LL, &blocked, NULL};
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("<q", 0))
program = root / "program.c"
program.write_text(harness.replace("@FUNCTIONS@", functions))
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(control)], check=True, timeout=5)
def test_zero_and_missing_offsets_are_unchanged(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
control = root / "clock"
control.write_bytes(struct.pack("<q", 0))
program = root / "program.c"
program.write_text(
'#include <stdio.h>\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("<q", 10_000_000_000))
replacement.write_bytes(struct.pack("<q", 20_000_000_000))
program = root / "program.c"
program.write_text(
'#include <stdio.h>\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 <assert.h>
#include <fcntl.h>
#include <stdint.h>
#include <unistd.h>
#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("<q", 10_000_000_000))
library = root / "clock.so"
subprocess.run(["cc", "-shared", "-fPIC", "-pthread", "-Wall", "-Wextra", "-Werror",
"-o", str(library), str(SOURCE)], check=True)
host = ctypes.CDLL(str(library))
host.droiddeck_clock_domain_set_control.argtypes = [ctypes.c_char_p]
host.droiddeck_clock_domain_adjust_ns.argtypes = [ctypes.c_int64]
host.droiddeck_clock_domain_adjust_ns.restype = ctypes.c_int64
host.droiddeck_clock_domain_set_control(str(control).encode())
with control.open("r+b") as file, mmap.mmap(file.fileno(), 8) as guest:
inode = control.stat().st_ino
subprocess.run(["bash", "-c", clock_reset_command(control)],
check=True, timeout=5)
self.assertEqual(control.stat().st_ino, inode)
self.assertEqual(struct.unpack("<q", guest[:])[0], 0)
self.assertEqual(host.droiddeck_clock_domain_adjust_ns(30_000_000_000), 30_000_000_000)
file.seek(0)
file.write(struct.pack("<q", 20_000_000_000))
file.flush()
self.assertEqual(struct.unpack("<q", guest[:])[0], 20_000_000_000)
self.assertEqual(host.droiddeck_clock_domain_adjust_ns(30_000_000_000), 10_000_000_000)
host.droiddeck_clock_domain_set_control(None)
def test_initially_missing_control_is_mapped_after_creation(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
control = root / "clock"
replacement = root / "replacement"
replacement.write_bytes(struct.pack("<q", 20_000_000_000))
program = root / "program.c"
program.write_text(
'#include <stdio.h>\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()