Compare commits

..
Author SHA1 Message Date
BZLZHH 8302dd30bf [Docs] (Anland): the lock screen behind the black desktop, and where the Magma text gap is not 2026-10-03 16:34:25 +08:00
BZLZHH a6d788191f [Docs] (Anland): record the Magma verification and its missing glyphs 2026-10-03 16:07:53 +08:00
BZLZHH 0d89db36dd [Docs] (Anland): the D1100 + Mali changes and why each one was needed 2026-10-03 15:57:11 +08:00
BZLZHH b7a6e6c538 [Docs] (Anland): the D1100 + Mali, kernel 4.14 bring-up and its three fixes 2026-10-03 15:55:53 +08:00
BZLZHH f44888ca01 [Fix] (Espryt): present through eglSwapBuffers when the driver refuses the damage entry point
A vendor EGL can export eglSwapBuffersWithDamageEXT and then answer EGL_FALSE on
a window surface without setting an error (measured on an Android 4.14 vendor
kernel with a Mali driver; the surface is current, the context is current, the
ANativeWindow reports its full extent, and the plain entry point presents the
same surface happily). Trusting that pointer kept the frame: the window's buffer
queue never saw a buffer, the compositor's own window stayed a solid colour on
screen, and every client of the session fell back to wl_shm because the
compositor could not sample what it could not present.

A refused damage swap now falls back to eglSwapBuffers and says so once. A
driver without the extension presents through the plain call as before.
2026-10-03 15:54:55 +08:00
BZLZHH 8245221755 [Fix] (Remote): name a shared image by extent and format when the kernel gives descriptors one identity
(st_dev, st_ino) is how an incoming dma-buf descriptor names the image it was
exported from, and it is the only identity the registry had. Some kernels do not
keep those apart: on a 4.14 vendor kernel every descriptor of every image reports
dev 12 ino 10658 with st_size 0, and /proc/self/fdinfo carries nothing else, so
the registry correctly detected the ambiguity and then refused every import -
which is every zero-copy window a compositor ever tries to sample, leaving the
whole stack on the wl_shm fallback.

The identity stays the kernel's to give. When it is ambiguous, the import's own
extent and format select among the live images exported under that identity, in
allocation order and each claimed once, which is the order a producer allocates
and hands them over in. Identify() takes the extent and the fourcc the import
record already carries; nothing else changes.
2026-10-03 15:54:55 +08:00
146 changed files with 680 additions and 12665 deletions
+24 -31
View File
@@ -18,15 +18,15 @@ nobody else is mid-test. Use your own `ct.sh` channel names (others use c, c2,
## Architecture (10 lines)
1. Phone: Lenovo TB321FU (Y700, Adreno 750, Android 15, kernel 6.1), rooted with **KernelSU** (`/data/adb/ksu`, `ksud`; `su -c` works). USB serial `HA27Q3LQ`, or wireless adb `ip:port`.
2. anland APK `com.anland.consumer.mobilegl` (debuggable build of anland branch `legacy-mobilegl-unified`): UI process + private service process `:mobilegl` (`MobileGLWorker`), which loads the **server** `libMobileGL.so` (NDK, from MobileGL `feat/disaggregated`) and listens on abstract socket `@anland-mobilegl` from the first attached window on. One process serves every client (KWin, plasmashell, ksplash, Chrome...), one backend per process. `MobileGLWorker` is a **foreground service** (notification "Linux desktop is running" / action "Stop desktop"), so the server and the session outlive a hidden, locked or swiped-away window.
3. Backend = the app setting "Renderer backend" (Settings > Connection > MobileGL desktop; file `/data/data/<pkg>/files/mobilegl-backend`, default DirectGLES; also `am start ... --es mobilegl_backend X`). Espryt = DirectGLES, Magma = DirectVulkan. The server reads it when its process starts; the app publishes it as `/data/local/tmp/anland-mobilegl/backend` and the session copies that into the container's `/etc/mobilegl/backend` (what every client reports; mismatch = "Hello.backendType disagrees with pinned backend"). `debug.mobilegl.backend`, if someone sets it, still overrides the setting until the next reboot.
4. Experiment display daemon `/data/adb/modules/anland-daemon/display_daemon /data/local/tmp/anland-mobilegl/display.sock` (display/input broker), started by the app (below). The module only starts the original one on `/data/local/tmp/display_daemon.sock` at boot; leave that alone.
2. anland APK `com.anland.consumer.mobilegl` (debuggable build of anland branch `legacy-mobilegl-unified`): UI process + private service process `:mobilegl` (`MobileGLWorker`), which loads the **server** `libMobileGL.so` (NDK, from MobileGL `feat/disaggregated`) and listens on abstract socket `@anland-mobilegl`. One process serves every client (KWin, plasmashell, ksplash, Chrome...), one backend per process.
3. Backend = `setprop debug.mobilegl.backend DirectGLES|DirectVulkan` (Espryt = DirectGLES, Magma = DirectVulkan; prop lost on reboot) and must equal the container's `/etc/mobilegl/backend` (what every client reports; mismatch = "Hello.backendType disagrees with pinned backend").
4. Experiment display daemon `/data/adb/modules/anland-daemon/display_daemon /data/local/tmp/anland-mobilegl/display.sock` (display/input broker; NOT started at boot - the module only starts the original one on `/data/local/tmp/display_daemon.sock`, leave that alone).
5. Container `arch-kde-mgl` (Droidspaces 6.4.5, Arch Linux ARM aarch64 glibc, host net, `rootfs.img` mounted at `/mnt/Droidspaces/arch-kde-mgl` on the Android side). Bind mounts: `/data/local/tmp/anland-mobilegl` -> `/run/anland-mobilegl`, `/data/local/tmp/display_daemon.sock` -> `/run/display.sock`.
6. `desktop-session.service` (User=swung0x48, **enabled**: the container boots straight into it, as the original image does) has drop-in `/etc/systemd/system/desktop-session.service.d/mobilegl.conf` (anland `producers/kde/Arch_v5/desktop-session-mobilegl.conf`, installed + enabled by `sync-build-kwin.sh`): `ExecStartPre=mobilegl-startup.sh wait` (until `@anland-mobilegl` listens in `/proc/net/unix` and the daemon socket exists), `ExecStartPre=+... sync-backend`, `Restart=always`, then `ExecStart=/opt/mobilegl/bin/mobilegl-startup.sh plasma`, which deletes the sticky software-renderer key, sets `MOBILEGL_IPC_PROBE_TIMEOUT_MS=0` session-wide (MobileGL never declines, so glvnd never falls through to another GL stack), writes a user drop-in for `plasma-kwin_wayland.service` (kwin_wayland_wrapper -> `/opt/mobilegl/kwin/bin/kwin_wayland` + `/opt/mobilegl/kwin/lib/libkwin.so.6.7.4`, `ANLAND_MOBILEGL=1`, `MOBILEGL_IPC_SURFACE=server`) and runs `startplasma-wayland`.
7. KWin 6.7.4 with anland's `anland` backend renders straight into the anland Android Surface through the server. While the window is not on screen (consumer disconnected) the backend powers its output down (DPMS Off + RenderLoop inhibited: no compositing, no frame callbacks) and back up when the window returns. Every other GL process is `MOBILEGL_IPC_SURFACE=offscreen` and presents through KWin.
6. `desktop-session.service` (User=swung0x48) has drop-in `ExecStart=/opt/mobilegl/bin/mobilegl-startup.sh plasma`, which writes a user drop-in for `plasma-kwin_wayland.service` (kwin_wayland_wrapper -> `/opt/mobilegl/kwin/bin/kwin_wayland` + `/opt/mobilegl/kwin/lib/libkwin.so.6.7.4`, `ANLAND_MOBILEGL=1`, `MOBILEGL_IPC_SURFACE=server`) and runs `startplasma-wayland`.
7. KWin 6.7.4 with anland's `anland` backend renders straight into the anland Android Surface through the server. Every other GL process is `MOBILEGL_IPC_SURFACE=offscreen` and presents through KWin.
8. Client = `/opt/mobilegl/lib/libMobileGL.so` (glibc aarch64), the container's **system-wide** GL vendor (section below): glvnd EGL vendor `/usr/share/glvnd/egl_vendor.d/10_mobilegl.json` (sorts before the distribution's `50_*.json`, which serves whenever MobileGL declines), GLX vendor `/usr/lib/libGLX_mobilegl.so.0`, settings from `/etc/mobilegl/client.conf` (`MOBILEGL_TRANSPORT=spawn MOBILEGL_IPC_DATA=shm MOBILEGL_IPC_CONTROL=unix:@anland-mobilegl`) + `/etc/mobilegl/backend`. No per-process environment is needed.
9. Zero-copy windows: client `wl_egl_window` frames are server-allocated AHardwareBuffer "shared images" exported as dma-buf fds over `zwp_linux_dmabuf_v1`; KWin imports them with EGL and the server recognises its own buffer by inode. KWin gets a DRM device via `GBM_BACKEND=mobilegl` -> `/usr/lib/gbm/mobilegl_gbm.so` (node is only an identity, never ioctl'd). Without linux-dmabuf the client falls back to wl_shm readback.
10. X11 (`docs/Disaggregated/notes/anland/plan-x11-gpu.md`): Xwayland draws with **glamor on MobileGL** (an offscreen session; `GBM_BACKEND=mobilegl` on KWin's render node; window pixmaps are shared images handed to KWin as linux-dmabuf buffers; its `glFlush` publishes them through the server, `/tmp/mgl-xwayland.client.log`); `ANLAND_XWAYLAND_GLAMOR=0` in KWin's drop-in brings back the software `-shm` Xwayland. GLX windows present their frames as shared images through **DRI3 + Present** (log `presented through DRI3+Present shared images`), falling back to readback + MIT-SHM / `xcb_put_image` when the X server has no DRI3 (`MOBILEGL_GLX_PRESENT=readback` forces it per app). Chrome runs ANGLE-GLES over MobileGL EGL with the GPU in its own process (`mobilegl-startup.sh chrome`; `MOBILEGL_CHROME_GPU=in-process` opts out), presenting GBM dma-bufs over linux-dmabuf; after a device loss Chrome restarts that process and repaints.
10. X11 apps (Xwayland) use the MobileGL GLX vendor with per-frame readback + `xcb_put_image`. Chrome runs ANGLE-GLES over MobileGL EGL with the GPU in-process (`mobilegl-startup.sh chrome`).
## First-time prerequisites (Windows host)
@@ -35,28 +35,28 @@ nobody else is mid-test. Use your own `ct.sh` channel names (others use c, c2,
- WSL distro **archlinux** with clang, lld, llvm, cmake, ninja. **lld's major version must equal clang/llvm-libs'** (lld 23 on llvm 22 broke `ld.lld`; working set: all 22.1.6). Then export the sysroot once: `bash scripts/xsysroot/refresh-sysroot.sh` (-> `~/sysroots/arch-kde-mgl` + `~/sysroots/aarch64-arch.cmake`; re-run after container package upgrades, then `xbuild.sh --reconfigure`).
- MobileGL worktree (never build in the shared main checkout): `GIT_LFS_SKIP_SMUDGE=1 git worktree add ...`, `git submodule update --init --recursive`, and copy `3rdparty/glslang/External/spirv-tools` from the main checkout (the submodule leaves it empty).
- anland worktree on `legacy-mobilegl-unified` (KWin patch/backend, startup script, `mobilegl-tools/`).
- Phone side that already exists and is NOT recreated by this skill: the APK (build: anland `consumers/anland_v5/android_consumer/MOBILEGL.md`, gradle `:app:assemblePlainDebug` with `MOBILEGL_DIST`, `-PmobileglApplicationId=com.anland.consumer.mobilegl -PanlandDefaultSocket=/data/local/tmp/anland-mobilegl/display.sock`, from Git Bash with `MSYS_NO_PATHCONV=1`; signed with this machine's `~/.android/debug.keystore`, so `adb install -r` works; reinstalling with another key changes the UID and needs the KernelSU grant again - `mobilegl-tools/ksu_grant.c`), the anland KernelSU modules (`anland-daemon`, `anland-awl`), the container with KWin's configured build tree `/root/mobilegl-build/kwin-6.7.4/build` and pristine `/root/gbm-dev/kwin-a/src`.
- Phone side that already exists and is NOT recreated by this skill: the APK (build: anland `consumers/anland_v5/android_consumer/MOBILEGL.md`, gradle `:app:assemblePlainDebug` with `MOBILEGL_DIST`, `-PmobileglApplicationId=com.anland.consumer.mobilegl`; reinstalling with another key changes the UID and needs the KernelSU grant again - `mobilegl-tools/ksu_grant.c`), the anland KernelSU modules (`anland-daemon`, `anland-awl`), the container with KWin's configured build tree `/root/mobilegl-build/kwin-6.7.4/build` and pristine `/root/gbm-dev/kwin-a/src`.
- Install the helpers once (container must be running): `bash scripts/push-tools.sh` (device/*.sh -> `/data/local/tmp/anl`, `mgrun` -> container `/usr/local/bin`, `kwprep.sh` -> container `/root`).
Run host scripts from Git Bash as `bash scripts/<x>.sh`. Raw adb with device paths needs `MSYS_NO_PATHCONV=1` and the whole root command in one quoted string: `adb shell 'su -c "..."'`. A device script can also be run without pushing: `MSYS_NO_PATHCONV=1 adb shell 'su -c sh' < scripts/device/status.sh`.
## Starting, idling, stopping - no manual steps
## Bring-up after a phone reboot
Nothing starts at phone boot (container `run_at_boot=0`). **Opening the app** (launcher icon = `am start -n com.anland.consumer.mobilegl/com.anland.consumer.MainActivity`, no extras; the APK's default socket is the experiment's, `-PanlandDefaultSocket`) calls `MobileGLDesktop.ensureStarted()` - the single trigger - which starts the foreground service and runs the APK's `assets/mobilegl-desktop.sh up` as root (`su`): display daemon if absent (the script leaves the app's cgroup first, so it survives the app) -> backend published -> container started if stopped -> `systemctl start --no-block desktop-session`. The window waits for the daemon socket; the server listens once the Surface is attached; the session's `wait` step then lets Plasma start. A reopen with everything up only reattaches the window. Log: `/data/local/tmp/anland-mobilegl/desktop.log`, logcat `AnlandMobileGL` ("MobileGL desktop up done in N ms").
Hidden window, screen off, lock screen or swiped-away task: server and session stay (foreground service); KWin turns the workspace's DPMS off (logs "viewer gone: output powered down"; windows get xdg_toplevel `suspended`, no frame callbacks) and back on ("viewer back"). Client swaps are paced by frame callbacks (`MG_Impl/EGLImpl/FrameThrottle.h`): interval >= 1 waits like any Wayland EGL; interval 0 (Chrome) drops to ~1 fps once a callback goes unanswered for 200 ms.
Measured 2026-10-03 (Espryt, Chrome on webglsamples aquarium; % of one core, phone = all of Android): open-to-desktop cold 7.5-12.5 s (daemon 0.5, server 1.0, container 1.5, kwin ~5, plasmashell ~6-7), after a phone reboot 8.5 s, reopen of a running desktop 0.2 s; visible phone 249% / kwin 13 / chrome 99 / server 57 / GPU 22%, hidden 54 / 0 / 6 / 2 / 0%, locked 38 / 0 / 8 / 3 / 0%. Stop desktop 1.7 s. Wireless adb does not come back by itself after a reboot (re-enable it on the phone). **Stop desktop** (notification action, or `am startservice -n <pkg>/com.anland.consumer.MobileGLWorker -a com.anland.consumer.mobilegl.STOP`) runs `mobilegl-desktop.sh down` (session + container stopped, daemon stays), closes the windows, ends `:mobilegl`.
Nothing of the session survives a reboot. Either `adb shell 'su -c "sh /data/local/tmp/anl/bringup.sh [DirectGLES|DirectVulkan]"'`, or by hand, in this order:
```sh
adb connect <ip>:<port> # only for wireless debugging
adb connect <ip>:<port> # only for wireless debugging (e.g. USB cannot power it)
export MSYS_NO_PATHCONV=1
adb shell 'su -c "sh /data/local/tmp/anl/bringup.sh"' # after a reboot: wake, dismiss keyguard, open the app, print the timeline
bash scripts/desktop-verify.sh push cold reopen idle # timed cold start, swipe-away + reopen, CPU/GPU visible/hidden/locked
adb shell 'su -c "sh /data/local/tmp/anl/status.sh"'
adb shell 'su -c "svc power stayon true"'
adb shell 'su -c "setprop debug.mobilegl.backend DirectVulkan"' # or DirectGLES; match /etc/mobilegl/backend
adb shell 'su -c "am start -n com.anland.consumer.mobilegl/com.anland.consumer.MainActivity --es socket_path /data/local/tmp/anland-mobilegl/display.sock"'
adb shell 'su -c "/data/local/Droidspaces/bin/droidspaces -C /data/local/Droidspaces/Containers/arch-kde-mgl/container.config start"'
adb shell 'su -c "sh /data/local/tmp/anl/restart-daemon.sh"' # experiment display daemon, chmod 777 dir / 666 socket
adb shell 'su -c "sh /data/local/tmp/anl/run-plasma.sh"' # restarts app + desktop-session, ~90 s
```
`droidspaces` has no `status` command; `droidspaces show` lists running containers. `device/run-plasma.sh` is a developer restart (session + logind user, then the app), needed after a rebuild because KWin does not reconnect to a new server process. `device/desktop-reset.sh` takes everything down to the post-reboot state. The old manual sequence (setprop, start container, `restart-daemon.sh`, `run-plasma.sh`) is gone; `restart-daemon.sh` remains for daemon debugging only.
`droidspaces` has no `status` command; `droidspaces show` lists running containers. Do not use the old
`/data/local/tmp/restart-daemon.sh` (it kills a hard-coded PID). Check with `device/status.sh`.
## Build and deploy loops
@@ -91,7 +91,7 @@ MSYS2_ARG_CONV_EXCL='*' wsl -d archlinux -- bash -lc 'cd ~/mgl-anl-bld && ctest
## Switching backends
In the app: Settings > Connection > MobileGL desktop > Renderer backend, then Stop desktop and open the app. Or `adb shell 'su -c "sh /data/local/tmp/anl/switch.sh DirectGLES"'`, which does the same (saves the setting through the launch extra, STOPs the service, reopens; clears a stale `debug.mobilegl.backend`). No setprop, no file to edit in the container: the session copies the published backend into `/etc/mobilegl/backend` on its next start. `cyc.sh` keeps whatever is set.
`adb shell 'su -c "sh /data/local/tmp/anl/switch.sh DirectGLES"'` (sets the prop, writes `/etc/mobilegl/backend`, restarts the app), then `run-plasma.sh` - the running session's clients are pinned to the old backend. `cyc.sh` keeps whatever is set.
## System-wide vendor and fallback
@@ -102,13 +102,13 @@ Installed by `xdeploy.sh` (and anland's `anland-build-client.sh`), so any proces
| `/usr/share/glvnd/egl_vendor.d/10_mobilegl.json` | EGL vendor, asked before the system's `50_*.json` |
| `/opt/mobilegl/share/glvnd/egl_vendor.d/50_mobilegl.json` | same JSON, for per-process forcing with `__EGL_VENDOR_LIBRARY_FILENAMES` |
| `/etc/mobilegl/client.conf` | `KEY=value` defaults for every client (transport, data, endpoint); rewritten on deploy |
| `/etc/mobilegl/backend` | the backend (the session's `sync-backend` step copies the app's choice in); wins over a `MOBILEGL_BACKEND_TYPE` line in client.conf |
| `/etc/mobilegl/backend` | the backend (`switch.sh` writes it); wins over a `MOBILEGL_BACKEND_TYPE` line in client.conf |
| `/etc/environment.d/10-mobilegl.conf` | `__GLX_VENDOR_LIBRARY_NAME=mobilegl`, `GBM_BACKEND=mobilegl` for the systemd user manager (all Plasma services and what they start, terminals included) |
| `/etc/profile.d/mobilegl.sh` | the same two for login shells (`bash -l`, `su -l`, ssh, `droidspaces run bash -l`) |
Precedence is environment > `/etc/mobilegl/backend` (backend only) > client.conf > built-in; `MOBILEGL_CONFIG_FILE` / `MOBILEGL_BACKEND_FILE` name other files (empty = off); a server process never reads them.
**Fallback.** Before bringing anything up the client probes the configured endpoint (one non-blocking connect, `MOBILEGL_IPC_PROBE_TIMEOUT_MS`, default 250, 0 = off; a refused abstract socket answers in ~0.2 ms). With no server: the EGL vendor returns `EGL_NO_DISPLAY` and no devices (glvnd moves on to the other vendor), the GLX vendor fails `__glx_Main` (libGLX falls back to the vendor Xwayland names), and `mobilegl_gbm` fails `create_device` (libgbm falls back to the device's own backend). Client queries (`eglQueryString(EGL_NO_DISPLAY)`, `eglGetProcAddress`) never bring a session up. MobileGL also steps aside for a GBM device another backend created and for `LIBGL_ALWAYS_SOFTWARE=1` - that is how a software Xwayland (`ANLAND_XWAYLAND_GLAMOR=0`, KWin's patch sets it then) keeps the software stack. MobileGL never opens an X connection to a display its own process serves (`MG_Util/X11/DisplayGuard.h`; `MOBILEGL_X11_DIAL=0` forbids all), which is what made a glamor Xwayland deadlock on itself before. Show it without stopping the real server:
**Fallback.** Before bringing anything up the client probes the configured endpoint (one non-blocking connect, `MOBILEGL_IPC_PROBE_TIMEOUT_MS`, default 250, 0 = off; a refused abstract socket answers in ~0.2 ms). With no server: the EGL vendor returns `EGL_NO_DISPLAY` and no devices (glvnd moves on to the other vendor), the GLX vendor fails `__glx_Main` (libGLX falls back to the vendor Xwayland names), and `mobilegl_gbm` fails `create_device` (libgbm falls back to the device's own backend). Client queries (`eglQueryString(EGL_NO_DISPLAY)`, `eglGetProcAddress`) never bring a session up. MobileGL also steps aside for a GBM device another backend created and for `LIBGL_ALWAYS_SOFTWARE=1` - that is how Xwayland (KWin's patch sets it) keeps the software stack. Show it without stopping the real server:
```sh
sed 's|^MOBILEGL_IPC_CONTROL=.*|MOBILEGL_IPC_CONTROL=unix:@nobody|' /etc/mobilegl/client.conf > /tmp/down.conf
sudo -u swung0x48 env -i HOME=/home/swung0x48 PATH=/usr/bin XDG_RUNTIME_DIR=/run/user/1000 WAYLAND_DISPLAY=wayland-0 \
@@ -117,19 +117,14 @@ sudo -u swung0x48 env -i HOME=/home/swung0x48 PATH=/usr/bin XDG_RUNTIME_DIR=/run
## Test clients and how to verify
X11 on the GPU has its own driver, `scripts/x11-verify.sh` (preflight, measure before/after with glxgears at `vblank_mode=0` on both GLX paths (presentation throughput only: glxgears is fixed-function GL, which MobileGL does not implement, so its window is black by design), deploy-client/-kwin/-server, check, apps, stop); `scripts/device/x11-measure.sh` refuses to load the phone below 40% battery.
Inside the container as root (`printf '...' | bash scripts/ct.sh <chan>`), `mgrun offscreen <cmd>` runs a client as swung0x48 in the live session through a login shell, with nothing but the surface mode and the log path set (log `/tmp/mgl-run.client.log`, override base with `MGLOG=/tmp/x.log`); a plain `env -i ... bash -l -c '<cmd>'` as swung0x48 gets MobileGL the same way:
```sh
mgrun offscreen eglinfo -B ; mgrun offscreen glxinfo -B
timeout 25 mgrun offscreen glmark2-es2-wayland -s 1280x720 --run-forever > /tmp/gm.out 2>&1 &
sleep 8; grep -a "presented through" /tmp/mgl-run.client.log
```
Chrome: `bash scripts/chrome-launch.sh <tag> [flags]` (log `/tmp/mgl-chrome-<tag>.client.log`, screenshot `ch-<tag>.png`; `CHROME_GPU=in-process` puts the GPU back in the browser, which cannot recover from a device loss).
Video: the container has a VA-API driver on the render node the GPU process gets (`/usr/lib/dri/msm_drm_drv_video.so`, V4L2 decode into its own NV12 dma-bufs); MobileGL cannot import those (only its own RGBA shared images; no dma-buf import in the phone's Vulkan, no `GL_OES_EGL_image_external`), and Chrome's GPU process aborts (SIGTRAP, "GPU process exited unexpectedly: exit_code=5") on the first decoded frame - window flicker + stalled video in a loop. `mobilegl-startup.sh chrome` therefore passes `--disable-accelerated-video-decode`. Diagnose a video with a CDP `Media.enable` dump (`kVideoDecoderName`); remote debugging needs a non-default `--user-data-dir`, and a fresh profile also needs `--password-store=basic` (else page loads wait forever on KWallet).
Device loss: `setprop debug.mobilegl.inject_device_lost_pid <pid>` (as root) loses the server session of the client whose pid - as it sees itself in the container - is `<pid>`, once per value, on any backend and whether or not it presents; `debug.mobilegl.inject_device_lost_at N` instead loses whichever session makes the N-th device check (Espryt presents and read-backs only). `bash scripts/chrome-recover.sh <in-process|process> [rounds]` checks that Chrome repaints after such a loss without a restart (battery-guarded, stops below 40%). `bash scripts/kwin-recover.sh [rounds]` loses KWin's own session (default twice) and checks that KWin restarts compositing on a fresh session - same KWin, plasmashell and client processes, the screen still animating (glmark2 on Wayland, glxgears on X11, `CHROME=1` adds Chrome) - which needs the anland backend + kwin.patch reset handling deployed (`kwin-stage.sh build`).
Chrome: `bash scripts/chrome-launch.sh <tag> [flags]` (log `/tmp/mgl-chrome-<tag>.client.log`, screenshot `ch-<tag>.png`).
Probes: `scripts/probes/texfmt.c` (texture formats keep alpha?), `dmahash.c` (hash a process's dma-bufs); build in the container, e.g. `gcc -O1 /root/texfmt.c -o /usr/local/bin/mgl-texfmt -lEGL`, run with `mgrun offscreen`.
GPU hangs: a shader that never ends stops the WHOLE GPU (every process, MobileGL or not) until the kernel resets it - ~2 s, or ~10 s ("Preemption Fault" in dmesg) when a higher-priority context waits; nothing in user space shortens one stall. What the server does is end the guilty session so it cannot hang the GPU again (Magma: event-bracketed submissions + `mgl-gpu-watch`, budget `MOBILEGL_GPU_HANG_BUDGET_MS` / `debug.mobilegl.gpu_hang_budget_ms`, default 2000; Espryt: the driver's GUILTY reset status, which it reports after the ~2 s reset only). Repro: `scripts/probes/hangclient.c` (Wayland + GL 3.3 core; `-H 60 -N 1 -E 60` hangs every 60 frames, `-H -1` is a frame-gap observer; build with wayland-scanner's xdg-shell files, `-lwayland-client -lwayland-egl -lEGL -lOpenGL -lm`), and `gpuprobe.c` (NDK, plain adb shell; `gpuprobe 30 high` is a high-priority GLES context outside MobileGL - it both measures the device-wide stall and forces the 10 s preemption path).
A result counts only if ALL hold:
- client log says `presented through linux-dmabuf shared images` (not `wl_shm`; `could not be presented through a linux-dmabuf shared image` = fell back);
@@ -149,8 +144,6 @@ Reference (glmark2-es2-wayland 1280x720, zero-copy vs wl_shm): Espryt 187 vs 49,
| Native crashes | `adb logcat -b crash -d`; container `coredumpctl list` |
| Session / KWin stderr | container `journalctl -u desktop-session --no-pager`, `journalctl --no-pager --since -2min \| grep kwin_wayland` |
| Display daemon | `/data/local/tmp/anland-mobilegl/display-daemon.log` |
| Desktop start/stop (app's su script) | `/data/local/tmp/anland-mobilegl/desktop.log`, `container-start.log`; logcat `-s AnlandMobileGL` |
| Session wait / backend sync | container `journalctl -u desktop-session --no-pager` ("waiting for the MobileGL server ...") |
`MOBILEGL_LOG_FILE_PATH=/tmp/x.log` produces `/tmp/x.client.log` (and `.server.log` for forwarded lines); files are truncated on open, so one base per process. Client builds log at INFO. Symbolize server frames with `$ANDROID_NDK/toolchains/llvm/prebuilt/windows-x86_64/bin/llvm-addr2line.exe -Cfe build-android/libMobileGL.so <offset>`.
@@ -158,10 +151,10 @@ Reference (glmark2-es2-wayland 1280x720, zero-copy vs wl_shm): Espryt 187 vs 49,
- **pkill -f self-match**: a `ct.sh`/`droidspaces run bash -lc "<script>"` process carries the script in its argv; `pkill -f chrome` kills the runner. Use `pkill -x`.
- **Root-owned /tmp files**: a log created by a root-run client cannot be reopened by swung0x48 later (no log appears). `rm -f` it as root first.
- **Sticky Plasma software renderer**: after any server crash Plasma writes `[QtQuickRendererSettings] SceneGraphBackend=software` into `~swung0x48/.config/kdeglobals`; plasmashell then renders on the CPU and screenshots still look fine (tray icon "正在使用的软件渲染器"). `mobilegl-startup.sh plasma` deletes it at every session start; within a running session that hit a crash, restart the session (`run-plasma.sh`) before any verdict.
- **Sticky Plasma software renderer**: after any server crash Plasma writes `[QtQuickRendererSettings] SceneGraphBackend=software` into `~swung0x48/.config/kdeglobals`; plasmashell then renders on the CPU and screenshots still look fine (tray icon "正在使用的软件渲染器"). Delete before any verdict: `sudo -u swung0x48 kwriteconfig6 --file kdeglobals --group QtQuickRendererSettings --key SceneGraphBackend --delete` (cyc.sh does it), restart the session.
- **Lock screen**: autolock is off (`kscreenlockerrc [Daemon] Autolock=false`); a real lock can only be left by typing the password (logind lock/unlock is not supported for this session type - `device/unlock.sh` is unverified). Test the greeter with `/usr/lib/kscreenlocker_greet --testing` and kill it.
- **CRLF**: `core.autocrlf=true` here; anland's backend sources and `sync-build-kwin.sh` are CRLF in the Windows checkout. Strip CR before anything runs on Linux/Android (`tr -d '\r'`; `ct.sh`, `push-tools.sh`, `kwin-stage.sh` do). This skill has a `.gitattributes` forcing LF.
- **Display daemon**: the app starts it; the session's `wait` step keeps KWin from starting without it (a KWin that cannot reach it logs "failed to connect to display daemon at /run/anland-mobilegl/display.sock" and exits in ~3 s). Anything started from the app's `su` must leave the app's cgroup (`echo $$ > /sys/fs/cgroup/cgroup.procs`) or a force-stop kills it.
- **Display daemon not auto-started** after reboot: KWin logs "failed to connect to display daemon at /run/anland-mobilegl/display.sock" and the session exits in ~3 s.
- **Device power/connection**: low battery or the screen turning off (30 s default) can kill the SurfaceView - `svc power stayon true`; wireless adb `ip:port` changes per pairing - never pin `-s HA27Q3LQ`, use `ANDROID_SERIAL` if several devices are attached.
- **Container vs phone paths**: container `/tmp` is a different place from the phone's `/data/local/tmp`; move files via `/mnt/Droidspaces/arch-kde-mgl/root` (container `/root`) or `/data/local/tmp/anland-mobilegl` (= container `/run/anland-mobilegl`).
- **Never overwrite a mapped .so in place** (container or APK while running): copy to a new inode and `mv -f`; the APK swap force-stops the app first.
@@ -81,8 +81,7 @@ APK, from anland `consumers/anland_v5/android_consumer` (details in its `MOBILEG
```sh
mkdir -p dist/arm64-v8a && cp <worktree>/build-android/libMobileGL.so dist/arm64-v8a/
MOBILEGL_DIST=$PWD/dist ./gradlew :app:assemblePlainDebug \
-PanlandNdkVersion=27.2.12479018 -PmobileglApplicationId=com.anland.consumer.mobilegl \
-PanlandDefaultSocket=/data/local/tmp/anland-mobilegl/display.sock
-PanlandNdkVersion=27.2.12479018 -PmobileglApplicationId=com.anland.consumer.mobilegl
adb install -r app/build/outputs/apk/plain/debug/app-plain-debug.apk
```
- **Grant root:** the app needs root for its helper; approve it in KernelSU.
@@ -135,26 +134,14 @@ The MobileGL session runs a rebuilt KWin from `/opt/mobilegl/kwin`, so the packa
## 7. Bring it up
Nothing has to be started by hand, and the order no longer matters: **open the app** (its launcher
icon, or `am start -n com.anland.consumer.mobilegl/com.anland.consumer.MainActivity` with no extras).
That is the single trigger. The app starts its foreground service and runs its bundled
`mobilegl-desktop.sh up` as root, which:
1. starts the display daemon if it is not running;
2. publishes the backend (the app setting "Renderer backend", default DirectGLES) to
`/data/local/tmp/anland-mobilegl/backend`;
3. starts the container if it is stopped;
4. starts `desktop-session`, which waits for the server and the daemon socket, copies the backend into
`/etc/mobilegl/backend` and runs Plasma.
Until the app-driven auto-start lands, the order matters:
1. **Backend:** `setprop debug.mobilegl.backend DirectVulkan`; it must match `/etc/mobilegl/backend`.
2. **App:** start it with `--es socket_path /data/local/tmp/anland-mobilegl/display.sock`.
3. **Container:** start it.
4. **Display daemon:** start the MobileGL daemon instance.
5. **Plasma:** `run-plasma.sh`.
Cold start to a desktop takes about 8-12 s. `scripts/device/bringup.sh` wakes the phone, dismisses the
keyguard, opens the app and prints the timeline. To change the backend, use the app setting and then
Stop desktop and reopen, or run `scripts/device/switch.sh DirectGLES|DirectVulkan`. Do not use
`setprop debug.mobilegl.backend`: it overrides the setting until the next reboot. **Stop desktop**
(the notification action) stops the session and the container.
**After a phone reboot:** wireless adb does not come back by itself. Re-enable it on the phone
(Developer options > Wireless debugging), then `adb connect <ip>:<port>`; the port changes. After
that, open the app as above. See SKILL.md "Starting, idling, stopping".
`scripts/device/bringup.sh [DirectVulkan|DirectGLES]` does all five. See SKILL.md "Bring-up after a phone reboot".
## 8. Verify
@@ -1,14 +1,10 @@
#!/usr/bin/env bash
# chrome-launch.sh <tag> [extra chrome flags...] - (re)start Chrome inside the running Plasma session
# through mobilegl-startup.sh's `chrome` mode (ANGLE GLES over MobileGL EGL), client log
# /tmp/mgl-chrome-<tag>.client.log, then print its "presented through" line and save a screenshot
# through mobilegl-startup.sh's `chrome` mode (ANGLE GLES over MobileGL EGL, in-process GPU), client
# log /tmp/mgl-chrome-<tag>.client.log, then print its "presented through" line and save a screenshot
# to $ANL_DIR/ch-<tag>.png. Kills the running chrome first (pkill -x, never -f). MobileGL is the
# container's system-wide vendor (10_mobilegl.json + /etc/mobilegl/client.conf), so only the log is set here.
# Env: WAIT (s before checking, default 20), CHANNEL (ct.sh channel, default chrome),
# CHROME_GPU (process, the default: the GPU in its own process, which presents
# through GBM dma-bufs and is restarted by Chrome after a device loss; in-process opts out -
# needs the anland startup script that knows MOBILEGL_CHROME_GPU; in process mode the GPU process and the browser
# write the one client log, the GPU process last); CHROME_GPU_SANDBOX=on keeps its GPU sandbox.
# Env: WAIT (s before checking, default 20), CHANNEL (ct.sh channel, default chrome).
set -euo pipefail
here=$(cd "$(dirname "$0")" && pwd)
. "$here/env.sh"
@@ -16,8 +12,7 @@ TAG=${1:?usage: chrome-launch.sh <tag> [chrome flags...]}; shift
bash "$here/ct.sh" "${CHANNEL:-chrome}" <<IN
pkill -x chrome; sleep 2
U=\$(id -u $MGL_DESKTOP_USER)
rm -f /tmp/mgl-chrome-$TAG.client.log /tmp/chrome-$TAG-out.log
sudo -u $MGL_DESKTOP_USER env XDG_RUNTIME_DIR=/run/user/\$U WAYLAND_DISPLAY=wayland-0 DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/\$U/bus MOBILEGL_LOG_FILE_PATH=/tmp/mgl-chrome-$TAG.log MOBILEGL_CHROME_GPU=${CHROME_GPU:-process} MOBILEGL_CHROME_GPU_SANDBOX=${CHROME_GPU_SANDBOX:-off} bash -c 'nohup /opt/mobilegl/bin/mobilegl-startup.sh chrome --restore-last-session $* > /tmp/chrome-$TAG-out.log 2>&1 &'
sudo -u $MGL_DESKTOP_USER env XDG_RUNTIME_DIR=/run/user/\$U WAYLAND_DISPLAY=wayland-0 DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/\$U/bus MOBILEGL_LOG_FILE_PATH=/tmp/mgl-chrome-$TAG.log bash -c 'nohup /opt/mobilegl/bin/mobilegl-startup.sh chrome --restore-last-session $* > /tmp/chrome-$TAG-out.log 2>&1 &'
sleep ${WAIT:-20}
grep -ah 'presented through' /tmp/mgl-chrome-$TAG.client.log | head -3
IN
@@ -1,146 +0,0 @@
#!/usr/bin/env bash
# chrome-recover.sh <in-process|process> [rounds] - does Chrome repaint after a GPU device loss,
# without a restart? Starts Chrome (chrome-launch.sh, CHROME_GPU=<mode>) on an animated WebGL page,
# then per round: screenshots (the page must animate), loses the session of Chrome's GPU client with
# the server's pid-targeted debug knob (debug.mobilegl.inject_device_lost_pid; the pid as Chrome sees
# itself in the container), waits, and screenshots again. A round PASSES when the server latched
# that pid's session, the browser process is the same one (no restart), a GPU client is drawing on a
# NEW server session, and the screen still animates. Stops early below MIN_BATTERY percent.
#
# in-process the GPU in the browser process (the startup script's default today): the target is
# the browser itself; recovery needs ANGLE to make a new native context.
# process the GPU in its own process (MOBILEGL_CHROME_GPU=process): the target is the GPU
# process; Chrome restarts it after the loss, so the next round's target is a new pid.
#
# Deploy first (same MobileGL commit on both sides; see SKILL.md):
# bash scripts/build-android.sh && bash scripts/cyc.sh pre # server -> APK, restarts the session
# bash scripts/xbuild.sh && bash scripts/xdeploy.sh # client -> container
# STARTUP=<anland worktree>/producers/kde/Arch_v5/mobilegl-startup.sh bash scripts/chrome-recover.sh deploy-startup
# Env: ROUNDS (default 2), SETTLE (s after the loss, default 8), MIN_BATTERY (default 40),
# CHANNEL (ct.sh channel, default crec), TAG (log tag, default crec-<mode>).
set -euo pipefail
here=$(cd "$(dirname "$0")" && pwd)
. "$here/env.sh"
MODE=${1:?usage: chrome-recover.sh <in-process|process|deploy-startup> [rounds]}
ROUNDS=${2:-${ROUNDS:-2}}
SETTLE=${SETTLE:-8}
MIN_BATTERY=${MIN_BATTERY:-40}
CH=${CHANNEL:-crec}
TAG=${TAG:-crec-$MODE}
PAGE=/tmp/mgl-spin.html
ct() { bash "$here/ct.sh" "$CH"; }
battery() { adb_ shell dumpsys battery | tr -d '\r' | awk '/ level:/ {print $2}'; }
check_battery() {
local level; level=$(battery)
echo "battery: $level%"
if [ -n "$level" ] && [ "$level" -lt "$MIN_BATTERY" ]; then
echo "STOP: battery below $MIN_BATTERY%"; cleanup; exit 3
fi
}
cleanup() { adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid 0'" || true; }
if [ "$MODE" = deploy-startup ]; then
# The anland startup script that knows MOBILEGL_CHROME_GPU, installed by rename (a running
# session keeps its open copy).
src=${STARTUP:?STARTUP=<path to the anland mobilegl-startup.sh>}
tr -d '\r' < "$src" > "$ANL_DIR/mobilegl-startup.sh"
adb_ push "$ANL_DIR/mobilegl-startup.sh" "$DEV_SHARE/mobilegl-startup.sh.new" >/dev/null
ct <<'IN'
install -m 755 /run/anland-mobilegl/mobilegl-startup.sh.new /opt/mobilegl/bin/mobilegl-startup.sh.new
mv -f /opt/mobilegl/bin/mobilegl-startup.sh.new /opt/mobilegl/bin/mobilegl-startup.sh
grep -c MOBILEGL_CHROME_GPU /opt/mobilegl/bin/mobilegl-startup.sh
IN
exit 0
fi
case "$MODE" in in-process|process) ;; *) echo "mode must be in-process or process" >&2; exit 2;; esac
trap cleanup EXIT
check_battery
adb_ shell "su -c 'sh $DEV_TOOLS/status.sh'" || true
cleanup
# The page: WebGL clears that change colour every frame plus a moving block, so a frame that
# reaches the screen changes the screenshot.
ct <<IN
cat > $PAGE <<'HTML'
<!doctype html><html><body style="margin:0;background:#000">
<canvas id=c width=640 height=360 style="width:100vw;height:100vh"></canvas>
<script>
const gl = document.getElementById('c').getContext('webgl');
let t = 0, lost = 0;
document.getElementById('c').addEventListener('webglcontextlost', e => { e.preventDefault(); lost++; });
function frame() {
t++;
if (gl && !gl.isContextLost()) {
gl.clearColor((t % 60) / 60, ((t + 20) % 60) / 60, ((t + 40) % 60) / 60, 1);
gl.clear(gl.COLOR_BUFFER_BIT);
gl.enable(gl.SCISSOR_TEST); gl.scissor((t * 7) % 600, 100, 40, 160);
gl.clearColor(1, 1, 1, 1); gl.clear(gl.COLOR_BUFFER_BIT); gl.disable(gl.SCISSOR_TEST);
}
document.title = 'spin ' + t + ' lost ' + lost;
requestAnimationFrame(frame);
}
frame();
</script></body></html>
HTML
chmod 644 $PAGE
IN
WAIT=${WAIT:-20} CHROME_GPU=$MODE CHANNEL=$CH bash "$here/chrome-launch.sh" "$TAG" --new-window "file://$PAGE"
# The target pid inside the container: the browser (in-process) or the GPU process.
target_pid() {
ct <<'IN' | tr -d '\r' | tail -1
for p in $(pgrep -x chrome); do
args=$(tr '\0' ' ' < /proc/$p/cmdline)
case "$args" in
*--type=gpu-process*) echo "gpu $p" ;;
*--type=*) ;;
*) echo "browser $p" ;;
esac
done | sort > /tmp/mgl-crec-pids
cat /tmp/mgl-crec-pids >&2
echo "$(awk '/^browser/ {print $2; exit}' /tmp/mgl-crec-pids) $(awk '/^gpu/ {print $2; exit}' /tmp/mgl-crec-pids)"
IN
}
pass=0
for round in $(seq 1 "$ROUNDS"); do
echo "=== round $round/$ROUNDS ($MODE)"
check_battery
read -r browser gpu < <(target_pid)
if [ "$MODE" = process ]; then target=$gpu; else target=$browser; fi
echo "browser=$browser gpu=${gpu:-none} target=$target"
if [ -z "$target" ]; then echo "FAIL: no target process"; break; fi
bash "$here/shot.sh" "$TAG-r$round-pre" 2 1
adb_ logcat -c
adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid $target'"
sleep "$SETTLE"
adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid 0'"
bash "$here/shot.sh" "$TAG-r$round-post" 3 1 | tee "$ANL_DIR/$TAG-r$round-post.md5"
latched=$(adb_ logcat -d | grep -c "injected:pid=$target" || true)
started=$(adb_ logcat -d | grep -c "session #[0-9]* started" || true)
adb_ logcat -d | grep -E "inject_device_lost_pid|SessionLatch|session #[0-9]+ (started|pid)" | cut -c1-220 | head -12 || true
read -r browser2 gpu2 < <(target_pid)
echo "after: browser=$browser2 gpu=${gpu2:-none}"
ct <<IN || true
echo "--- client log ($TAG):"; grep -aE "DEVICE LOST|RECOVERED|GL_UNKNOWN_CONTEXT_RESET|failed to make|session #" /tmp/mgl-chrome-$TAG.client.log | tail -8
echo "--- chrome stderr:"; grep -aiE "context lost|GPU process|make.*current|lost" /tmp/chrome-$TAG-out.log | tail -8
IN
adb_ logcat -b crash -d | tail -5
hashes=$(awk '{print $1}' "$ANL_DIR/$TAG-r$round-post.md5" | sort -u | wc -l)
verdict=PASS
[ "$latched" -ge 1 ] || { echo " - the server never latched pid $target"; verdict=FAIL; }
[ "$browser2" = "$browser" ] || { echo " - the browser process changed ($browser -> $browser2): Chrome restarted"; verdict=FAIL; }
[ "$started" -ge 1 ] || { echo " - no new server session started after the loss"; verdict=FAIL; }
if [ "$MODE" = process ]; then
[ -n "$gpu2" ] && [ "$gpu2" != "$gpu" ] || { echo " - no new GPU process"; verdict=FAIL; }
fi
[ "$hashes" -ge 2 ] || { echo " - the screen does not change after the loss (frozen)"; verdict=FAIL; }
echo "round $round: $verdict"
[ "$verdict" = PASS ] && pass=$((pass + 1))
[ "$verdict" = PASS ] || break
done
echo "=== $pass/$ROUNDS rounds passed ($MODE); screenshots in $ANL_DIR/$TAG-r*-*.png"
@@ -1,94 +0,0 @@
#!/usr/bin/env bash
# desktop-verify.sh <phase>... - check that the MobileGL desktop starts, idles and stops by itself
# (anland app: foreground service + mobilegl-desktop.sh; container: desktop-session.service).
# Phases run in the order given; screenshots go to $ANL_DIR/dv-<phase>.png.
#
# push install device/*.sh into $DEV_TOOLS (push-tools.sh's device half)
# reset everything down: app force-stopped (its service with it), container stopped,
# experiment display daemon killed - the state after a phone reboot
# cold reset, then open the app like its icon does and time each piece (desktop-timeline.sh)
# open open the app without resetting (after a reboot: the reboot was the reset)
# chrome (re)start Chrome in the session on an animated WebGL page (kills a running Chrome)
# idle CPU/GPU for visible, hidden (HOME), locked (screen off), visible again (measure.sh)
# reopen swipe the app away (remove its task), check KWin survives, open it again, time it
# stop Stop desktop from the notification (the service's STOP action) and check it all ends
# rtest lock/unlock + window resize regression ($ANL_DIR/rtest.sh)
# Env: SECS (idle window, default 20), URL (chrome page).
set -euo pipefail
here=$(cd "$(dirname "$0")" && pwd)
. "$here/env.sh"
SECS=${SECS:-20}
URL=${URL:-https://webglsamples.org/aquarium/aquarium.html}
SOCK=$DEV_SHARE/display.sock
su_() { adb_ shell "su -c '$*'"; }
shot() {
su_ "screencap -p $DEV_SHARE/dv-$1.png"
adb_ pull "$DEV_SHARE/dv-$1.png" "$ANL_DIR/dv-$1.png" > /dev/null && echo "screenshot $ANL_DIR/dv-$1.png"
}
kwin_log() { # the anland backend's lines since <time>
printf '%s\n' "journalctl --no-pager --since '$1' 2>/dev/null | grep -a -E 'viewer (gone|back)|consumer (reconnected|disconnected)|failed to connect' | tail -${2:-8}" |
bash "$here/ct.sh" dv 2>/dev/null | grep -v pushed || true
}
task_id() {
su_ "am stack list" | tr -d '\r' | grep -m1 "$MGL_PKG/" | sed -n 's/.*taskId=\([0-9]*\).*/\1/p'
}
wake() {
su_ "input keyevent KEYCODE_WAKEUP"; sleep 1; su_ "wm dismiss-keyguard"; sleep 2
}
for phase in "$@"; do
echo "=== $phase"
case $phase in
push)
for f in "$here"/device/*.sh; do
tr -d '\r' < "$f" > "$ANL_DIR/push.tmp"
adb_ push "$ANL_DIR/push.tmp" "$DEV_TOOLS/$(basename "$f")" > /dev/null
done
rm -f "$ANL_DIR/push.tmp"; echo "device scripts in $DEV_TOOLS" ;;
reset)
su_ "sh $DEV_TOOLS/desktop-reset.sh" ;;
cold)
bash "$0" reset
wake
su_ "sh $DEV_TOOLS/desktop-timeline.sh 240"
sleep 3; shot cold ;;
open)
wake
su_ "sh $DEV_TOOLS/desktop-timeline.sh 300"
sleep 3; shot open ;;
chrome)
WAIT=15 bash "$here/chrome-launch.sh" dv "$URL" ;;
idle)
su_ "sh $DEV_TOOLS/measure.sh visible $SECS"
t=$(date -u '+%Y-%m-%d %H:%M:%S UTC')
su_ "input keyevent KEYCODE_HOME"; sleep 4
su_ "sh $DEV_TOOLS/measure.sh hidden $SECS"
su_ "am start -n $MGL_PKG/com.anland.consumer.MainActivity >/dev/null"; sleep 5
su_ "input keyevent KEYCODE_SLEEP"; sleep 4
su_ "sh $DEV_TOOLS/measure.sh locked $SECS"
wake
su_ "am start -n $MGL_PKG/com.anland.consumer.MainActivity >/dev/null"; sleep 5
su_ "sh $DEV_TOOLS/measure.sh visible2 $SECS"
shot idle
kwin_log "$t" 12 ;;
reopen)
t=$(date -u '+%Y-%m-%d %H:%M:%S UTC')
id=$(task_id); echo "removing task $id"
[ -n "$id" ] && su_ "am stack remove $id"
sleep 8
su_ "echo server: \$(pidof $MGL_PKG:mobilegl) ui: \$(pidof $MGL_PKG) kwin: \$(pidof kwin_wayland) plasmashell: \$(pidof plasmashell)"
su_ "sh $DEV_TOOLS/measure.sh closed 10"
su_ "sh $DEV_TOOLS/desktop-timeline.sh 120"
sleep 3; shot reopen
kwin_log "$t" ;;
stop)
su_ "am startservice -n $MGL_PKG/com.anland.consumer.MobileGLWorker -a com.anland.consumer.mobilegl.STOP" || true
sleep 25
su_ "echo server: \$(pidof $MGL_PKG:mobilegl) ui: \$(pidof $MGL_PKG); $DS_BIN show"
su_ "tail -3 $DEV_SHARE/desktop.log" ;;
rtest)
bash "$ANL_DIR/rtest.sh" dv ;;
*)
echo "unknown phase $phase" >&2; exit 2 ;;
esac
done
@@ -1,7 +1,29 @@
# bringup.sh - (Android root shell) bring the MobileGL desktop up after a phone reboot. There is
# nothing left to do by hand: opening the anland app (its launcher icon, or this am start) starts
# the display daemon, the MobileGL server, the container and its Plasma session. Prints the timeline.
# Run: su -c "sh /data/local/tmp/anl/bringup.sh" Env: as desktop-timeline.sh.
input keyevent KEYCODE_WAKEUP
wm dismiss-keyguard
sh "$(dirname "$0")/desktop-timeline.sh" 300
# bringup.sh [DirectGLES|DirectVulkan] - (Android root shell) bring the stack up after a phone reboot:
# stay-awake, container, backend property, experiment display daemon, anland app, then the Plasma
# session (run-plasma.sh, ~90 s; skip with NO_PLASMA=1). The backend defaults to the container's
# /etc/mobilegl/backend (persists across reboots; the property does not).
# Assembled from the documented manual steps; not exercised as one unit yet. Re-running restarts the
# daemon, the app and the session. Run: su -c "sh /data/local/tmp/anl/bringup.sh"
# Env: PKG, CONTAINER, DS, SOCK, TOOLS (dir holding run-plasma.sh / restart-daemon.sh; default: this dir).
D=${DS:-/data/local/Droidspaces/bin/droidspaces}
P=${PKG:-com.anland.consumer.mobilegl}
C=${CONTAINER:-arch-kde-mgl}
SOCK=${SOCK:-/data/local/tmp/anland-mobilegl/display.sock}
T=${TOOLS:-$(dirname $0)}
svc power stayon true
if $D show 2>/dev/null | grep -q " $C "; then
echo "container $C already running"
else
$D -C /data/local/Droidspaces/Containers/$C/container.config start
sleep 5
fi
B=${1:-$(cat /mnt/Droidspaces/$C/etc/mobilegl/backend 2>/dev/null)}
B=${B:-DirectGLES}
setprop debug.mobilegl.backend $B
echo "$B" > /mnt/Droidspaces/$C/etc/mobilegl/backend
echo "backend: $(getprop debug.mobilegl.backend)"
sh $T/restart-daemon.sh
am start -n $P/com.anland.consumer.MainActivity --es socket_path $SOCK >/dev/null
sleep 3
if pidof $P:mobilegl >/dev/null; then echo "server process $P:mobilegl up"; else echo "WARNING: $P:mobilegl not running"; fi
[ "${NO_PLASMA:-0}" = 1 ] || sh $T/run-plasma.sh
@@ -1,17 +0,0 @@
# desktop-reset.sh - (Android root shell) take the MobileGL desktop fully down, as after a phone
# reboot: the app force-stopped (its foreground service and server with it), the container
# stopped, the experiment display daemon killed. Leaves the original anland daemon alone.
# Run: su -c "sh /data/local/tmp/anl/desktop-reset.sh" Env: PKG, CONTAINER, SOCK, DS.
P=${PKG:-com.anland.consumer.mobilegl}
C=${CONTAINER:-arch-kde-mgl}
SOCK=${SOCK:-/data/local/tmp/anland-mobilegl/display.sock}
D=${DS:-/data/local/Droidspaces/bin/droidspaces}
am force-stop $P
$D --name=$C stop > /dev/null 2>&1
for p in $(pidof display_daemon); do
tr '\0' ' ' < /proc/$p/cmdline | grep -qF " $SOCK " && kill $p
done
rm -f $SOCK
sleep 2
echo "app: $(pidof $P) server: $(pidof $P:mobilegl) daemon: $(ls $SOCK 2>/dev/null)"
$D show
@@ -1,30 +0,0 @@
# desktop-timeline.sh [timeout-s] - (Android root shell) open the anland app the way its launcher
# icon does (am start, no extras) and print when each piece of the MobileGL desktop comes up,
# in seconds after the open: display daemon socket, the app's MobileGL server listening, the
# container, kwin_wayland, plasmashell, and the splash (ksplashqml) gone = desktop on screen.
# Pieces that already run show 0.0. Read-only apart from the am start.
# Run: su -c "sh /data/local/tmp/anl/desktop-timeline.sh 180" Env: PKG, CONTAINER, SOCK, DS.
T=${1:-180}
P=${PKG:-com.anland.consumer.mobilegl}
C=${CONTAINER:-arch-kde-mgl}
SOCK=${SOCK:-/data/local/tmp/anland-mobilegl/display.sock}
D=${DS:-/data/local/Droidspaces/bin/droidspaces}
now() { awk '{print $1}' /proc/uptime; }
since() { awk -v a="$1" -v b="$(now)" 'BEGIN{printf "%.1f", b - a}'; }
listening() { grep -q '00010000 0001 01 [0-9]* @anland-mobilegl$' /proc/net/unix; }
t0=$(now)
am start -n $P/com.anland.consumer.MainActivity > /dev/null
for k in daemon server container kwin shell splash_seen shown; do eval "t_$k="; done
while :; do
[ -z "$t_daemon" ] && [ -S "$SOCK" ] && t_daemon=$(since $t0) && echo "daemon socket +${t_daemon}s"
[ -z "$t_server" ] && listening && t_server=$(since $t0) && echo "server listening +${t_server}s"
[ -z "$t_container" ] && [ -n "$($D --name=$C pid 2>/dev/null | tr -dc 0-9)" ] && t_container=$(since $t0) && echo "container up +${t_container}s"
[ -z "$t_kwin" ] && pidof kwin_wayland > /dev/null && t_kwin=$(since $t0) && echo "kwin_wayland +${t_kwin}s"
[ -z "$t_shell" ] && pidof plasmashell > /dev/null && t_shell=$(since $t0) && echo "plasmashell +${t_shell}s"
[ -z "$t_splash_seen" ] && pidof ksplashqml > /dev/null && t_splash_seen=1
if [ -n "$t_shell" ] && [ -z "$t_shown" ] && ! pidof ksplashqml > /dev/null; then
t_shown=$(since $t0); echo "splash gone +${t_shown}s (desktop on screen)"; break
fi
[ "$(since $t0 | cut -d. -f1)" -ge "$T" ] && { echo "TIMEOUT after ${T}s"; break; }
sleep 0.3
done
@@ -1,47 +0,0 @@
# measure.sh <label> [seconds] - (Android root shell) CPU and GPU load of the MobileGL desktop over a
# window: % of ONE core (so 800 = all 8 cores) for the whole phone, KWin (+Xwayland), plasmashell,
# Chrome (all its processes), the app's :mobilegl server and its UI process, plus the mean of the
# kgsl gpu_busy_percentage samples (1/s). The container's processes are visible from Android's
# /proc (Droidspaces only gives them their own pid namespace).
# Run: su -c "sh /data/local/tmp/anl/measure.sh visible 20" Env: PKG.
L=${1:-sample}
N=${2:-20}
P=${PKG:-com.anland.consumer.mobilegl}
GPU=/sys/class/kgsl/kgsl-3d0/gpu_busy_percentage
pids_named() { # exact process names (comm or argv0 basename)
for n in "$@"; do pidof "$n"; done
}
pids_matching() { # argv contains the word
for d in /proc/[0-9]*; do
{ tr '\0' ' ' < $d/cmdline; } 2>/dev/null | grep -q "$1" && echo ${d#/proc/}
done
}
ticks() { # utime+stime of the pids, in clock ticks
t=0
for p in "$@"; do
[ -r /proc/$p/stat ] || continue
v=$(sed 's/^.*) //' /proc/$p/stat | awk '{print $12 + $13}')
t=$((t + v))
done
echo $t
}
total() { awk '/^cpu /{print $2+$3+$4+$6+$7+$8}' /proc/stat; }
KW="$(pids_named kwin_wayland Xwayland)"
SH="$(pids_named plasmashell)"
CH="$(pids_matching /opt/google/chrome/)"
SV="$(pidof $P:mobilegl)"
UI="$(pidof $P)"
a0=$(total); k0=$(ticks $KW); s0=$(ticks $SH); c0=$(ticks $CH); v0=$(ticks $SV); u0=$(ticks $UI)
g=0; i=0
while [ $i -lt $N ]; do
sleep 1
b=$(cat $GPU 2>/dev/null | tr -dc '0-9'); g=$((g + ${b:-0})); i=$((i + 1))
done
a1=$(total); k1=$(ticks $KW); s1=$(ticks $SH); c1=$(ticks $CH); v1=$(ticks $SV); u1=$(ticks $UI)
# CLK_TCK is 100: ticks per second == percent of one core.
pct() { echo $(( ($2 - $1) / N )); }
printf '%-10s %3ss phone %4s%% kwin %3s%% plasmashell %3s%% chrome %3s%% server %3s%% app-ui %3s%% gpu %3s%%\n' \
"$L" "$N" "$(pct $a0 $a1)" "$(pct $k0 $k1)" "$(pct $s0 $s1)" "$(pct $c0 $c1)" "$(pct $v0 $v1)" "$(pct $u0 $u1)" "$((g / N))"
@@ -1,25 +1,24 @@
# run-plasma.sh - (Android root shell) DEVELOPER restart of the whole MobileGL desktop, e.g. after a
# server, client or KWin rebuild: ends the Plasma session (and the user's logind session, which takes
# a while to wind down), then restarts the anland app; opening it brings up the server, starts
# desktop-session.service again and the session waits for the server. Normal use needs none of this:
# opening the app is enough. ~60 s. Prints the unit status, plasma user units and recent coredumps.
# Run: su -c "sh /data/local/tmp/anl/run-plasma.sh"
# Env: PKG, CONTAINER, DESKTOP_USER (swung0x48), DS (droidspaces binary).
# run-plasma.sh - (Android root shell) restart the anland app and the container's Plasma session
# (desktop-session.service -> mobilegl-startup.sh plasma). Takes ~90 s (two 40 s waits: logind must
# finish tearing the old user session down before the new one starts). Prints the unit status, the
# plasma user units and recent coredumps. Run: su -c "sh /data/local/tmp/anl/run-plasma.sh"
# Env: PKG, CONTAINER, DESKTOP_USER (swung0x48), SOCK, DS (droidspaces binary).
D=${DS:-/data/local/Droidspaces/bin/droidspaces}
P=${PKG:-com.anland.consumer.mobilegl}
C=${CONTAINER:-arch-kde-mgl}
U=${DESKTOP_USER:-swung0x48}
SOCK=${SOCK:-/data/local/tmp/anland-mobilegl/display.sock}
am force-stop $P
am start -n $P/com.anland.consumer.MainActivity --es socket_path $SOCK >/dev/null
sleep 3
$D --name=$C run bash -lc "
systemctl stop desktop-session.service 2>/dev/null
loginctl terminate-user $U 2>/dev/null; sleep 30
loginctl terminate-user $U 2>/dev/null; sleep 40
systemctl reset-failed desktop-session.service
rm -f /tmp/mobilegl-compositor.log
date +%s > /tmp/plasma-start
"
am force-stop $P
am start -n $P/com.anland.consumer.MainActivity > /dev/null
sleep 30
$D --name=$C run bash -lc "
systemctl start desktop-session.service
sleep 40
systemctl --no-pager status desktop-session.service | head -8
UID_=\$(id -u $U)
sudo -u $U XDG_RUNTIME_DIR=/run/user/\$UID_ systemctl --user --no-pager list-units --all 'plasma*' 2>&1 | head -30
@@ -5,8 +5,7 @@ P=${PKG:-com.anland.consumer.mobilegl}
C=${CONTAINER:-arch-kde-mgl}
SOCK=${SOCK:-/data/local/tmp/anland-mobilegl/display.sock}
echo "battery: $(dumpsys battery | grep ' level:' | tr -d ' ') $(dumpsys power | grep -o 'mStayOn=[a-z]*')"
echo "backend: app setting=$(cat /data/data/$P/files/mobilegl-backend 2>/dev/null || echo 'DirectGLES (default)') published=$(cat ${SOCK%/*}/backend 2>/dev/null) container /etc/mobilegl/backend=$(cat /mnt/Droidspaces/$C/etc/mobilegl/backend 2>/dev/null) prop override=$(getprop debug.mobilegl.backend)"
echo "desktop service log: $(tail -1 ${SOCK%/*}/desktop.log 2>/dev/null)"
echo "prop debug.mobilegl.backend=$(getprop debug.mobilegl.backend) container /etc/mobilegl/backend=$(cat /mnt/Droidspaces/$C/etc/mobilegl/backend 2>/dev/null)"
echo "app pid: $(pidof $P) server (:mobilegl) pid: $(pidof $P:mobilegl)"
ps -A -o PID,ARGS | grep "display_daemon $SOCK" | grep -v grep || echo "experiment display daemon NOT running"
$D show
@@ -1,17 +1,15 @@
# switch.sh <DirectGLES|DirectVulkan> - (Android root shell) change the MobileGL backend the anland
# app's server runs (Espryt = DirectGLES, Magma = DirectVulkan). The choice is the app's setting
# (Settings > Connection > MobileGL desktop, saved in the app's files/mobilegl-backend); this does
# what a user does there: save it, Stop desktop, open the app again. The new server publishes the
# backend and the container's session copies it to /etc/mobilegl/backend before it starts, so
# server and clients agree. ~30-60 s. No setprop: debug.mobilegl.backend, if set, still overrides
# the setting until the next reboot - this clears it.
# Env: PKG, SOCK.
# switch.sh <DirectGLES|DirectVulkan> - (Android root shell) select the server backend: Espryt =
# DirectGLES, Magma = DirectVulkan. Sets the system property the server reads (lost on reboot), writes
# the container's /etc/mobilegl/backend (what every client and the KWin drop-in report; it must match or
# the server refuses the client: "Hello.backendType disagrees with pinned backend"), restarts the app.
# The running Plasma session still speaks the old backend: run run-plasma.sh afterwards.
# Env: PKG, CONTAINER (arch-kde-mgl), SOCK (display daemon socket).
B=${1:?usage: switch.sh DirectGLES|DirectVulkan}
P=${PKG:-com.anland.consumer.mobilegl}
[ -n "$(getprop debug.mobilegl.backend)" ] && setprop debug.mobilegl.backend ""
if pidof $P:mobilegl > /dev/null; then
am startservice -n $P/com.anland.consumer.MobileGLWorker -a com.anland.consumer.mobilegl.STOP > /dev/null
i=0; while pidof $P:mobilegl > /dev/null && [ $i -lt 60 ]; do sleep 1; i=$((i + 1)); done
fi
am start -n $P/com.anland.consumer.MainActivity --es mobilegl_backend $B > /dev/null
echo "backend $B saved; the desktop is starting (watch: sh $(dirname $0)/status.sh)"
C=${CONTAINER:-arch-kde-mgl}
SOCK=${SOCK:-/data/local/tmp/anland-mobilegl/display.sock}
setprop debug.mobilegl.backend $B
echo $B > /mnt/Droidspaces/$C/etc/mobilegl/backend
am force-stop $P
am start -n $P/com.anland.consumer.MainActivity --es socket_path $SOCK >/dev/null
sleep 4
@@ -1,47 +0,0 @@
# x11-measure.sh <label> <app-process-name> [seconds] - (Android root shell) CPU of the X11 path while
# an X11 app runs: % of ONE core (800 = all 8 cores) for the whole phone, the app, Xwayland,
# kwin_wayland, the app's :mobilegl server; mean kgsl gpu_busy_percentage; and the number of dma-buf
# descriptors Xwayland and KWin hold (window pixmaps / client buffers as dma-bufs). Refuses to run
# below 40% battery: the phone drains faster under load than USB charges it.
# Run: su -c "sh /data/local/tmp/anl/x11-measure.sh glamor glxgears 10" Env: PKG, MIN_BATTERY.
L=${1:-sample}
APP=${2:-glxgears}
N=${3:-10}
P=${PKG:-com.anland.consumer.mobilegl}
GPU=/sys/class/kgsl/kgsl-3d0/gpu_busy_percentage
level=$(dumpsys battery | sed -n 's/^ *level: *//p')
if [ "${level:-0}" -lt "${MIN_BATTERY:-40}" ]; then
echo "battery ${level}% < ${MIN_BATTERY:-40}%: not loading the phone; charge first" >&2
exit 3
fi
ticks() {
t=0
for p in "$@"; do
[ -r /proc/$p/stat ] || continue
v=$(sed 's/^.*) //' /proc/$p/stat | awk '{print $12 + $13}')
t=$((t + v))
done
echo $t
}
total() { awk '/^cpu /{print $2+$3+$4+$6+$7+$8}' /proc/stat; }
dmabufs() { # dma-buf descriptors held by the pids (Android kernels link them to /dmabuf:...)
n=0
for p in "$@"; do n=$((n + $(ls -l /proc/$p/fd 2>/dev/null | grep -c dmabuf))); done
echo $n
}
AP="$(pidof $APP)"
XW="$(pidof Xwayland)"
KW="$(pidof kwin_wayland)"
SV="$(pidof $P:mobilegl)"
[ -n "$AP" ] || { echo "no running process named $APP" >&2; exit 2; }
a0=$(total); p0=$(ticks $AP); x0=$(ticks $XW); k0=$(ticks $KW); v0=$(ticks $SV)
g=0; i=0
while [ $i -lt $N ]; do
sleep 1
b=$(cat $GPU 2>/dev/null | tr -dc '0-9'); g=$((g + ${b:-0})); i=$((i + 1))
done
a1=$(total); p1=$(ticks $AP); x1=$(ticks $XW); k1=$(ticks $KW); v1=$(ticks $SV)
pct() { echo $(( ($2 - $1) / N )); }
printf '%-12s %3ss phone %4s%% %s %3s%% Xwayland %3s%% kwin %3s%% server %3s%% gpu %3s%% dmabufs Xwayland %s kwin %s battery %s%%\n' \
"$L" "$N" "$(pct $a0 $a1)" "$APP" "$(pct $p0 $p1)" "$(pct $x0 $x1)" "$(pct $k0 $k1)" "$(pct $v0 $v1)" "$((g / N))" \
"$(dmabufs $XW)" "$(dmabufs $KW)" "$level"
@@ -1,146 +0,0 @@
#!/usr/bin/env bash
# kwin-recover.sh [rounds] - does the desktop keep working when KWin's OWN MobileGL session is lost?
# Starts animated clients (glmark2-es2-wayland: Wayland, zero-copy shared images; glxgears: X11 through
# Xwayland's GLX; with CHROME=1 also Chrome on an animated WebGL page), then per round loses the server
# session of KWin with the pid-targeted debug knob (debug.mobilegl.inject_device_lost_pid, KWin's pid as
# it sees itself in the container), waits, and checks. A round PASSES when:
# - the server latched KWin's session (the server log file: "injected:pid=<kwin>"; logcat is too small);
# - KWin, plasmashell and every test client are the SAME processes (nothing restarted);
# - KWin restarted compositing on a fresh session (its journal: "compositing restarted on a fresh
# MobileGL session"; its client log: one more "RECOVERED");
# - the screen still animates (shot.sh hashes differ) and the clients keep presenting;
# - no native crash (logcat -b crash).
# Between rounds the knob is reset to 0 while the clients run, which re-arms it for the same pid.
# Stops early below MIN_BATTERY percent (the phone drains faster under load than USB charges it).
#
# Deploy first (same MobileGL commit on both sides; see SKILL.md):
# bash scripts/build-android.sh && bash scripts/cyc.sh pre # server -> APK, restarts the session
# bash scripts/xbuild.sh && bash scripts/xdeploy.sh # client -> container
# ANLAND_WORKTREE=<anland worktree> bash scripts/kwin-stage.sh build # kwin.patch + anland backend
# (wait for "== ALL DONE ==" in /root/kwin-build.log), then: adb shell 'su -c "sh /data/local/tmp/anl/run-plasma.sh"'
# Env: ROUNDS (default 2), SETTLE (s after the loss, default 10), REARM (s with the knob at 0 between
# rounds, default 4), MIN_BATTERY (default 40), CHROME (1: add Chrome), CHANNEL (ct.sh channel,
# default krec), TAG (screenshot/log tag, default krec).
set -euo pipefail
here=$(cd "$(dirname "$0")" && pwd)
. "$here/env.sh"
ROUNDS=${1:-${ROUNDS:-2}}
SETTLE=${SETTLE:-10}
REARM=${REARM:-4}
MIN_BATTERY=${MIN_BATTERY:-40}
CH=${CHANNEL:-krec}
TAG=${TAG:-krec}
COMPOSITOR_LOG=/tmp/mobilegl-compositor.client.log
SERVER_LOG=/data/data/$MGL_PKG/files/mobilegl-server.server.log
ct() { bash "$here/ct.sh" "$CH"; }
battery() { adb_ shell dumpsys battery | tr -d '\r' | awk '/ level:/ {print $2}'; }
stop_clients() {
ct <<'IN' || true
pkill -x glmark2-es2-way 2>/dev/null; pkill -x glmark2-es2-wayland 2>/dev/null; pkill -x glxgears 2>/dev/null
true
IN
}
cleanup() {
adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid 0'" || true
stop_clients
}
check_battery() {
local level; level=$(battery)
echo "battery: $level%"
if [ -n "$level" ] && [ "$level" -lt "$MIN_BATTERY" ]; then
echo "STOP: battery below $MIN_BATTERY%"; exit 3
fi
}
trap cleanup EXIT
check_battery
adb_ shell "su -c 'sh $DEV_TOOLS/status.sh'" || true
adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid 0'"
# The clients, each with its own log (mgrun's MGLOG), in the background for the whole run.
ct <<'IN'
rm -f /tmp/mgl-krec-gm.client.log /tmp/mgl-krec-gx.client.log /tmp/krec-gm.out /tmp/krec-gx.out
MGLOG=/tmp/mgl-krec-gm.log nohup timeout 900 mgrun offscreen glmark2-es2-wayland -s 960x540 --run-forever \
> /tmp/krec-gm.out 2>&1 < /dev/null &
MGLOG=/tmp/mgl-krec-gx.log nohup timeout 900 mgrun offscreen glxgears -info > /tmp/krec-gx.out 2>&1 < /dev/null &
sleep 8
echo "glmark2: $(pgrep -x glmark2-es2-way || pgrep -x glmark2-es2-wayland) glxgears: $(pgrep -x glxgears)"
grep -aE "presented through|could not be presented" /tmp/mgl-krec-gm.client.log | head -2
grep -aE "presented through|readback" /tmp/mgl-krec-gx.client.log | head -2
IN
if [ "${CHROME:-0}" = 1 ]; then
ct <<'IN'
cat > /tmp/mgl-krec-spin.html <<'HTML'
<!doctype html><html><body style="margin:0;background:#000">
<canvas id=c width=640 height=360 style="width:100vw;height:100vh"></canvas>
<script>
const gl = document.getElementById('c').getContext('webgl'); let t = 0;
function frame() { t++; if (gl && !gl.isContextLost()) { gl.clearColor((t % 60) / 60, 0.2, 0.6, 1); gl.clear(gl.COLOR_BUFFER_BIT); }
requestAnimationFrame(frame); }
frame();
</script></body></html>
HTML
chmod 644 /tmp/mgl-krec-spin.html
IN
WAIT=${WAIT:-20} CHANNEL=$CH bash "$here/chrome-launch.sh" "$TAG" --new-window "file:///tmp/mgl-krec-spin.html"
fi
# KWin, plasmashell and the clients, as pids inside the container; how often KWin recovered so far.
snapshot() {
ct <<IN | tr -d '\r' | tail -1
k=\$(pgrep -x kwin_wayland | head -1); p=\$(pgrep -x plasmashell | head -1)
g=\$(pgrep -x glmark2-es2-way || pgrep -x glmark2-es2-wayland); x=\$(pgrep -x glxgears | head -1)
c=\$(pgrep -x chrome | head -1)
r=\$(grep -ac "RECOVERED" $COMPOSITOR_LOG 2>/dev/null || true)
f=\$(grep -ac "FPS" /tmp/krec-gm.out 2>/dev/null || true)
echo "\${k:-none} \${p:-none} \${g:-none} \${x:-none} \${c:-none} \${r:-0} \${f:-0}"
IN
}
pass=0
for round in $(seq 1 "$ROUNDS"); do
echo "=== round $round/$ROUNDS"
check_battery
read -r kwin plasma gm gx chrome recovered fps < <(snapshot)
echo "kwin=$kwin plasmashell=$plasma glmark2=$gm glxgears=$gx chrome=$chrome recoveries=$recovered fps-lines=$fps"
if [ "$kwin" = none ]; then echo "FAIL: KWin is not running"; break; fi
bash "$here/shot.sh" "$TAG-r$round-pre" 2 1
srvlines=$(adb_ shell "su -c 'wc -l < $SERVER_LOG'" | tr -dc '0-9')
adb_ logcat -b crash -c || true
adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid $kwin'"
sleep "$SETTLE"
adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid 0'"
bash "$here/shot.sh" "$TAG-r$round-post" 3 1 | tee "$ANL_DIR/$TAG-r$round-post.md5"
read -r kwin2 plasma2 gm2 gx2 chrome2 recovered2 fps2 < <(snapshot)
echo "after: kwin=$kwin2 plasmashell=$plasma2 glmark2=$gm2 glxgears=$gx2 chrome=$chrome2 recoveries=$recovered2 fps-lines=$fps2"
adb_ shell "su -c 'tail -n +$((srvlines + 1)) $SERVER_LOG'" > "$ANL_DIR/$TAG-r$round-server.log"
latched=$(grep -c "injected:pid=$kwin" "$ANL_DIR/$TAG-r$round-server.log" || true)
grep -aE "inject_device_lost_pid|SessionLatch|session #[0-9]+ (started|pid)|owner=server|lease" \
"$ANL_DIR/$TAG-r$round-server.log" | cut -c1-220 | head -14 || true
ct <<IN || true
echo "--- KWin's MobileGL client log:"; grep -aE "DEVICE LOST|RECOVERED|GL_UNKNOWN_CONTEXT_RESET|re-created on the fresh|Refuse" $COMPOSITOR_LOG | tail -6
echo "--- KWin journal:"; journalctl --no-pager --since -40s 2>/dev/null | grep -aE "kwin_wayland" | grep -aiE "reset|restarted|MobileGL swap|context|fatal|abort" | tail -10
echo "--- clients:"; grep -aE "DEVICE LOST|lost|Fatal" /tmp/mgl-krec-gm.client.log /tmp/mgl-krec-gx.client.log | tail -4
IN
crashes=$(adb_ logcat -b crash -d | grep -c "Fatal signal\|Abort message" || true)
hashes=$(awk '{print $1}' "$ANL_DIR/$TAG-r$round-post.md5" | sort -u | wc -l)
verdict=PASS
[ "$latched" -ge 1 ] || { echo " - the server never latched KWin's session (pid $kwin)"; verdict=FAIL; }
[ "$kwin2" = "$kwin" ] || { echo " - KWin is a different process ($kwin -> $kwin2): it restarted"; verdict=FAIL; }
[ "$plasma2" = "$plasma" ] || { echo " - plasmashell restarted ($plasma -> $plasma2)"; verdict=FAIL; }
[ "$gm2" = "$gm" ] && [ "$gx2" = "$gx" ] || { echo " - a test client restarted or died"; verdict=FAIL; }
[ "${CHROME:-0}" != 1 ] || [ "$chrome2" = "$chrome" ] || { echo " - Chrome restarted"; verdict=FAIL; }
[ "$recovered2" -gt "$recovered" ] || { echo " - KWin's client log shows no new RECOVERED session"; verdict=FAIL; }
[ "$fps2" -gt "$fps" ] || { echo " - glmark2 stopped reporting frames"; verdict=FAIL; }
[ "$hashes" -ge 2 ] || { echo " - the screen does not change after the loss (frozen)"; verdict=FAIL; }
[ "$crashes" -eq 0 ] || { echo " - native crash(es):"; adb_ logcat -b crash -d | tail -8; verdict=FAIL; }
echo "round $round: $verdict"
[ "$verdict" = PASS ] && pass=$((pass + 1))
[ "$verdict" = PASS ] || break
# Re-arm the knob for the same pid: a session must observe 0 before the next value counts.
sleep "$REARM"
done
echo "=== $pass/$ROUNDS rounds passed; screenshots in $ANL_DIR/$TAG-r*-*.png"
[ "$pass" = "$ROUNDS" ]
@@ -27,7 +27,7 @@ for f in "$K"/anland_backend_Arch_v5/src/backends/anland/*; do
lf "$f" "$st/kwsync/anland_backend_Arch_v5/src/backends/anland/$b"
lf "$f" "$st/kwin-sync/anland/$b"
done
for f in kwin.patch mobilegl-startup.sh desktop-session-mobilegl.conf; do
for f in kwin.patch mobilegl-startup.sh; do
lf "$K/Arch_v5/$f" "$st/kwsync/Arch_v5/$f"
lf "$K/Arch_v5/$f" "$st/kwin-sync/misc/$f"
done
@@ -1,55 +0,0 @@
// gpuprobe - a plain Android process (outside MobileGL) that measures whether the GPU keeps executing
// other contexts' work: a pbuffer GLES context clears + draws and glFinish()es every ~10 ms, printing any
// round trip over 50 ms with a CLOCK_REALTIME timestamp. Usage: gpuprobe <seconds> [priority: low|med|high]
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GLES3/gl3.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#ifndef EGL_CONTEXT_PRIORITY_LEVEL_IMG
#define EGL_CONTEXT_PRIORITY_LEVEL_IMG 0x3100
#define EGL_CONTEXT_PRIORITY_HIGH_IMG 0x3101
#define EGL_CONTEXT_PRIORITY_MEDIUM_IMG 0x3102
#define EGL_CONTEXT_PRIORITY_LOW_IMG 0x3103
#endif
static double now_ms(void) { struct timespec ts; clock_gettime(CLOCK_REALTIME, &ts); return ts.tv_sec * 1e3 + ts.tv_nsec / 1e6; }
int main(int argc, char** argv) {
int seconds = argc > 1 ? atoi(argv[1]) : 20;
EGLint prio = EGL_CONTEXT_PRIORITY_MEDIUM_IMG;
if (argc > 2 && !strcmp(argv[2], "high")) prio = EGL_CONTEXT_PRIORITY_HIGH_IMG;
if (argc > 2 && !strcmp(argv[2], "low")) prio = EGL_CONTEXT_PRIORITY_LOW_IMG;
setvbuf(stdout, NULL, _IOLBF, 0);
EGLDisplay d = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(d, NULL, NULL);
const EGLint ca[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT, EGL_RED_SIZE, 8, EGL_NONE};
EGLConfig c; EGLint n;
eglChooseConfig(d, ca, &c, 1, &n);
const EGLint pa[] = {EGL_WIDTH, 256, EGL_HEIGHT, 256, EGL_NONE};
EGLSurface s = eglCreatePbufferSurface(d, c, pa);
const EGLint xa[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_CONTEXT_PRIORITY_LEVEL_IMG, prio, EGL_NONE};
EGLContext x = eglCreateContext(d, c, EGL_NO_CONTEXT, xa);
if (x == EGL_NO_CONTEXT) { printf("no ctx 0x%x\n", eglGetError()); return 1; }
eglMakeCurrent(d, s, s, x);
EGLint got = 0; eglQueryContext(d, x, EGL_CONTEXT_PRIORITY_LEVEL_IMG, &got);
const double t0 = now_ms(); double maxRt = 0; long iters = 0, slow = 0;
printf("[probe] start %.0f prio=0x%x\n", t0, got);
while (now_ms() - t0 < seconds * 1000.0) {
const double a = now_ms();
glClearColor((iters & 1) ? 1.f : 0.f, 0.f, 0.f, 1.f);
glClear(GL_COLOR_BUFFER_BIT);
glFinish();
const double rt = now_ms() - a;
if (rt > maxRt) maxRt = rt;
if (rt > 50) { ++slow; printf("[probe] glFinish %.0f ms ending at %.0f\n", rt, now_ms()); }
++iters;
usleep(10000);
}
printf("[probe] END iters=%ld max=%.0f ms slow=%ld\n", iters, maxRt, slow);
return 0;
}
@@ -1,150 +0,0 @@
// hangclient - a Wayland xdg-toplevel, EGL + desktop GL 3.3 core client that animates and, on request,
// submits fragment work that never ends (the driver has to reset it). Prints per-frame gaps so the same
// binary measures "other app" frame pacing (frame callbacks come from the compositor) when run with -H -1.
//
// hangclient -T tag [-H hang_at_frame] [-N hang_repeat] [-I iters] [-S seconds] [-W w] [-X h] [-F]
// -H n frame at which the hanging draw is submitted (-1: never; default -1)
// -N k how many consecutive hanging frames (default 1)
// -E e re-arm a hang every e frames after the first (0: once)
// -I i loop count of the hanging shader (default 2^31-1)
// -S s run time in seconds (default 30)
// -F glFinish after every frame (puts the wait inside the client's own session)
#define GL_GLEXT_PROTOTYPES 1
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GL/glcorearb.h>
#include <wayland-client.h>
#include <wayland-egl.h>
#include "xdg-shell-client-protocol.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
static struct wl_compositor* g_comp;
static struct xdg_wm_base* g_wm;
static int g_configured, g_closed;
static int g_w = 480, g_h = 360;
static void reg_global(void* d, struct wl_registry* r, uint32_t name, const char* iface, uint32_t ver) {
(void)d;
if (!strcmp(iface, "wl_compositor")) g_comp = wl_registry_bind(r, name, &wl_compositor_interface, 4);
else if (!strcmp(iface, "xdg_wm_base")) g_wm = wl_registry_bind(r, name, &xdg_wm_base_interface, 1);
}
static void reg_remove(void* d, struct wl_registry* r, uint32_t n) { (void)d; (void)r; (void)n; }
static const struct wl_registry_listener reg_l = {reg_global, reg_remove};
static void wm_ping(void* d, struct xdg_wm_base* wm, uint32_t s) { (void)d; xdg_wm_base_pong(wm, s); }
static const struct xdg_wm_base_listener wm_l = {wm_ping};
static void xs_conf(void* d, struct xdg_surface* s, uint32_t serial) { (void)d; xdg_surface_ack_configure(s, serial); g_configured = 1; }
static const struct xdg_surface_listener xs_l = {xs_conf};
static void tl_conf(void* d, struct xdg_toplevel* t, int32_t w, int32_t h, struct wl_array* st) { (void)d; (void)t; (void)st; (void)w; (void)h; }
static void tl_close(void* d, struct xdg_toplevel* t) { (void)d; (void)t; g_closed = 1; }
static const struct xdg_toplevel_listener tl_l = {tl_conf, tl_close};
static double now_ms(void) { struct timespec ts; clock_gettime(CLOCK_REALTIME, &ts); return ts.tv_sec * 1e3 + ts.tv_nsec / 1e6; }
static GLuint sh(GLenum type, const char* src) {
GLuint s = glCreateShader(type);
glShaderSource(s, 1, &src, NULL);
glCompileShader(s);
GLint ok = 0; glGetShaderiv(s, GL_COMPILE_STATUS, &ok);
if (!ok) { char log[2048]; glGetShaderInfoLog(s, sizeof log, NULL, log); fprintf(stderr, "shader: %s\n", log); exit(2); }
return s;
}
int main(int argc, char** argv) {
const char* tag = "hc"; int hangAt = -1, hangN = 1, every = 0, seconds = 30, finish = 0; long iters = 2147483647L;
for (int i = 1; i < argc; ++i) {
if (!strcmp(argv[i], "-T") && i + 1 < argc) tag = argv[++i];
else if (!strcmp(argv[i], "-H") && i + 1 < argc) hangAt = atoi(argv[++i]);
else if (!strcmp(argv[i], "-N") && i + 1 < argc) hangN = atoi(argv[++i]);
else if (!strcmp(argv[i], "-E") && i + 1 < argc) every = atoi(argv[++i]);
else if (!strcmp(argv[i], "-I") && i + 1 < argc) iters = atol(argv[++i]);
else if (!strcmp(argv[i], "-S") && i + 1 < argc) seconds = atoi(argv[++i]);
else if (!strcmp(argv[i], "-W") && i + 1 < argc) g_w = atoi(argv[++i]);
else if (!strcmp(argv[i], "-X") && i + 1 < argc) g_h = atoi(argv[++i]);
else if (!strcmp(argv[i], "-F")) finish = 1;
}
setvbuf(stdout, NULL, _IOLBF, 0);
struct wl_display* dpy = wl_display_connect(NULL);
if (!dpy) { fprintf(stderr, "no wayland\n"); return 1; }
struct wl_registry* reg = wl_display_get_registry(dpy);
wl_registry_add_listener(reg, &reg_l, NULL);
wl_display_roundtrip(dpy);
if (!g_comp || !g_wm) { fprintf(stderr, "no compositor/xdg_wm_base\n"); return 1; }
xdg_wm_base_add_listener(g_wm, &wm_l, NULL);
struct wl_surface* surf = wl_compositor_create_surface(g_comp);
struct xdg_surface* xs = xdg_wm_base_get_xdg_surface(g_wm, surf);
xdg_surface_add_listener(xs, &xs_l, NULL);
struct xdg_toplevel* tl = xdg_surface_get_toplevel(xs);
xdg_toplevel_add_listener(tl, &tl_l, NULL);
xdg_toplevel_set_title(tl, tag);
wl_surface_commit(surf);
while (!g_configured) wl_display_dispatch(dpy);
EGLDisplay ed = eglGetPlatformDisplay(EGL_PLATFORM_WAYLAND_KHR, dpy, NULL);
if (!eglInitialize(ed, NULL, NULL)) { fprintf(stderr, "eglInitialize\n"); return 1; }
eglBindAPI(EGL_OPENGL_API);
const EGLint ca[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT, EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_NONE};
EGLConfig cfg; EGLint n = 0;
if (!eglChooseConfig(ed, ca, &cfg, 1, &n) || n < 1) { fprintf(stderr, "no config\n"); return 1; }
const EGLint xa[] = {EGL_CONTEXT_MAJOR_VERSION, 3, EGL_CONTEXT_MINOR_VERSION, 3, EGL_CONTEXT_OPENGL_PROFILE_MASK, EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT, EGL_NONE};
EGLContext ctx = eglCreateContext(ed, cfg, EGL_NO_CONTEXT, xa);
if (ctx == EGL_NO_CONTEXT) { fprintf(stderr, "no context 0x%x\n", eglGetError()); return 1; }
struct wl_egl_window* ew = wl_egl_window_create(surf, g_w, g_h);
EGLSurface es = eglCreatePlatformWindowSurface(ed, cfg, ew, NULL);
eglMakeCurrent(ed, es, es, ctx);
eglSwapInterval(ed, 1);
const char* vs = "#version 330 core\nlayout(location=0) in vec2 p; uniform float t; out vec2 uv;\n"
"void main(){ uv=p*0.5+0.5; gl_Position=vec4(p*0.4+vec2(0.5*sin(t),0.0),0.0,1.0);}";
const char* fs = "#version 330 core\nin vec2 uv; uniform int iters; uniform float t; out vec4 c;\n"
"void main(){ float a=uv.x; for(int i=0;i<iters;++i){ a=fract(a*1.0001+0.37+uv.y); }\n"
" c=vec4(uv, 0.5+0.5*sin(t)+a*1e-6, 1.0);}";
GLuint prog = glCreateProgram();
glAttachShader(prog, sh(GL_VERTEX_SHADER, vs));
glAttachShader(prog, sh(GL_FRAGMENT_SHADER, fs));
glLinkProgram(prog);
GLint ok = 0; glGetProgramiv(prog, GL_LINK_STATUS, &ok);
if (!ok) { fprintf(stderr, "link failed\n"); return 2; }
GLint uIt = glGetUniformLocation(prog, "iters"), uT = glGetUniformLocation(prog, "t");
GLuint vao, vbo; glGenVertexArrays(1, &vao); glBindVertexArray(vao);
const float q[] = {-1, -1, 1, -1, -1, 1, 1, 1};
glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof q, q, GL_STATIC_DRAW);
glEnableVertexAttribArray(0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
const double t0 = now_ms(); double last = t0, maxGap = 0; long frames = 0, gaps100 = 0;
printf("[%s] start %.0f renderer=%s hangAt=%d N=%d every=%d iters=%ld\n", tag, t0, glGetString(GL_RENDERER), hangAt, hangN, every, iters);
while (!g_closed && now_ms() - t0 < seconds * 1000.0) {
wl_display_dispatch_pending(dpy);
const double t = (now_ms() - t0) / 1000.0;
int hang = 0;
if (hangAt >= 0 && frames >= hangAt) {
long rel = frames - hangAt;
if (every > 0) rel %= every;
hang = rel < hangN;
}
glViewport(0, 0, g_w, g_h);
glClearColor(0.5f + 0.5f * (float)sin(t * 3.0), 0.2f, 0.4f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(prog);
glUniform1i(uIt, hang ? (int)iters : 0);
glUniform1f(uT, (float)t);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
if (hang) printf("[%s] HANG submitted frame %ld at %.0f\n", tag, frames, now_ms());
if (finish) glFinish();
if (!eglSwapBuffers(ed, es)) printf("[%s] swap failed 0x%x at %.0f\n", tag, eglGetError(), now_ms());
const GLenum rs = glGetError();
if (rs != GL_NO_ERROR) printf("[%s] glGetError 0x%x at %.0f\n", tag, rs, now_ms());
const double nowv = now_ms(), gap = nowv - last;
last = nowv; ++frames;
if (gap > maxGap) maxGap = gap;
if (gap > 100.0) { ++gaps100; printf("[%s] GAP %.0f ms ending at %.0f (frame %ld)\n", tag, gap, nowv, frames); }
if (frames % 120 == 0) printf("[%s] frame %ld t=%.1fs fps=%.1f\n", tag, frames, (nowv - t0) / 1e3, frames * 1e3 / (nowv - t0));
}
const double total = now_ms() - t0;
printf("[%s] END frames=%ld fps=%.1f maxGap=%.0f ms gaps>100ms=%ld\n", tag, frames, frames * 1e3 / total, maxGap, gaps100);
return 0;
}
@@ -1,135 +0,0 @@
#!/usr/bin/env bash
# x11-verify.sh <step> [...] - device verification of X11 on the GPU (docs/Disaggregated/notes/anland/
# plan-x11-gpu.md): Xwayland drawing with glamor on MobileGL, and GLX windows presented through
# DRI3 + Present from shared images. Steps, in the order a full run takes them:
#
# preflight read-only: battery, stack status, Xwayland package, render node, xcb libs,
# test apps, Xwayland's extensions and its GLX vendor
# measure <label> [s] glxgears 1280x720 (GEARS_ARGS; vblank_mode=0) for s seconds (10): its fps, then CPU/GPU/dma-buf
# counts (device/x11-measure.sh); also with MOBILEGL_GLX_PRESENT=readback
# deploy-client xbuild.sh + xdeploy.sh of this worktree's client (MGL_XBUILD_DIR)
# deploy-kwin kwin-stage.sh build from ANLAND_WORKTREE; waits for "== ALL DONE =="
# deploy-server build-android.sh + cyc.sh x11-server (swaps the APK lib, RESTARTS the session)
# check the evidence: Xwayland took glamor (journal), its MobileGL log, GLX's path
# line, dma-buf counts in Xwayland/KWin, the server's import lines
# apps X11 clients on screen: konsole and kate on Qt's xcb platform (glamor-drawn
# core X), glxgears (GLX), xterm/xeyes when installed; two screenshots
# stop kill the test apps
#
# Typical run: preflight; measure before; deploy-client; deploy-kwin; deploy-server; check; measure
# after; apps; stop. Battery: every load step refuses below MIN_BATTERY (40) %.
# Env: CHANNEL (ct.sh channel, default x11), ANLAND_WORKTREE (anland x11-gpu worktree, Windows
# form), MGL_XBUILD_DIR (default /home/swung/mgl-xbuild-x11), MIN_BATTERY.
set -euo pipefail
here=$(cd "$(dirname "$0")" && pwd)
. "$here/env.sh"
CH=${CHANNEL:-x11}
: "${MGL_XBUILD_DIR:=/home/swung/mgl-xbuild-x11}"
: "${ANLAND_WORKTREE:=$(cygpath -m "$USERPROFILE" 2>/dev/null)/AndroidStudioProjects/anland/.claude/worktrees/x11-gpu}"
export MGL_XBUILD_DIR ANLAND_WORKTREE
battery_ok() {
local level
level=$(adb_ shell "dumpsys battery" | sed -n 's/^ *level: *//p' | tr -d '\r')
echo "battery: ${level}%"
if [ "${level:-0}" -lt "${MIN_BATTERY:-40}" ]; then
echo "below ${MIN_BATTERY:-40}%: stopping GPU-heavy work; charge the phone first" >&2
return 1
fi
}
push_measure() {
tr -d '\r' < "$here/device/x11-measure.sh" > "$ANL_DIR/x11-measure.sh"
adb_ push "$ANL_DIR/x11-measure.sh" "$DEV_TOOLS/x11-measure.sh" >/dev/null
}
step=${1:?usage: x11-verify.sh <preflight|measure|deploy-client|deploy-kwin|deploy-server|check|apps|stop>}
shift
case "$step" in
preflight)
battery_ok || true
adb_ shell "su -c 'sh $DEV_TOOLS/status.sh'" || true
bash "$here/ct.sh" "$CH" <<'IN'
echo "== packages"; pacman -Q xorg-xwayland libxcb mesa-utils xorg-xdpyinfo qt6-base 2>&1 | sed 's/^/ /'
echo "== render nodes"; ls -l /dev/dri/ 2>&1 | sed 's/^/ /'
U=swung0x48; for n in /dev/dri/renderD*; do sudo -u $U test -r "$n" -a -w "$n" && echo " $U can open $n"; done
echo "== KWin's thin node"; tr '\0' '\n' < /proc/$(pgrep -x kwin_wayland)/environ 2>/dev/null | grep -E "MOBILEGL_GBM_NODE|ANLAND_XWAYLAND_GLAMOR|GBM_BACKEND" | sed 's/^/ /'
echo "== xcb libraries"; for l in libxcb-dri3.so.0 libxcb-present.so.0 libxcb-xfixes.so.0 libxcb-shm.so.0; do ls /usr/lib/$l >/dev/null 2>&1 && echo " $l ok" || echo " $l MISSING"; done
echo "== Xwayland"; pgrep -a -x Xwayland | sed 's/^/ /'
mgrun offscreen xdpyinfo 2>/dev/null | grep -E "^ +(DRI3|Present|MIT-SHM|XFIXES|GLX)$" | sed 's/^/ ext/'
mgrun offscreen glxinfo -B 2>&1 | grep -E "vendor|renderer|direct rendering" | sed 's/^/ /'
IN
;;
measure)
label=${1:?usage: x11-verify.sh measure <label> [seconds]}
secs=${2:-10}
battery_ok
push_measure
for mode in auto readback; do
printf '%s\n' \
"pkill -x glxgears; rm -f /tmp/mgl-x11-gears.client.log /tmp/x11-gears.out" \
"MGLOG=/tmp/mgl-x11-gears.log timeout $((secs + 8)) mgrun offscreen env vblank_mode=${VBLANK_MODE:-0} MOBILEGL_GLX_PRESENT=$mode glxgears ${GEARS_ARGS:--geometry 1280x720} > /tmp/x11-gears.out 2>&1 &" \
"sleep 3" | bash "$here/ct.sh" "$CH" >/dev/null
adb_ shell "su -c 'sh $DEV_TOOLS/x11-measure.sh $label-$mode glxgears $secs'" || true
sleep 6
printf '%s\n' "grep -a 'frames in' /tmp/x11-gears.out | tail -3; grep -a 'presented through' /tmp/mgl-x11-gears.client.log | head -1; pkill -x glxgears; true" \
| bash "$here/ct.sh" "$CH"
done
;;
deploy-client)
bash "$here/xbuild.sh"
CHANNEL=$CH bash "$here/xdeploy.sh"
;;
deploy-kwin)
CHANNEL=$CH bash "$here/kwin-stage.sh" build
for _ in $(seq 1 120); do
out=$(printf 'tail -3 /root/kwin-build.log\n' | bash "$here/ct.sh" "$CH" 2>/dev/null || true)
echo "$out" | tail -1
echo "$out" | grep -q "== ALL DONE ==" && exit 0
echo "$out" | grep -qiE "error|failed" && { echo "KWin build failed" >&2; exit 1; }
sleep 30
done
echo "KWin build did not finish in an hour" >&2; exit 1
;;
deploy-server)
battery_ok
bash "$here/build-android.sh"
CHANNEL=$CH bash "$here/cyc.sh" x11-server
;;
check)
bash "$here/ct.sh" "$CH" <<'IN'
echo "== Xwayland's command line (no -shm with glamor)"; pgrep -a -x Xwayland | sed 's/^/ /'
echo "== Xwayland's glamor (journal)"
journalctl --no-pager --since -30min 2>/dev/null | grep -aiE "glamor|Xwayland.*(EGL|gbm|dri3|falling back)" | tail -10 | sed 's/^/ /'
echo "== Xwayland's MobileGL client log"; grep -aE "presented|shared image|declin|Fatal|ERROR" /tmp/mgl-xwayland.client.log /tmp/mgl-xwayland.client 2>/dev/null | tail -8 | sed 's/^/ /' || echo " (none)"
X=$(pgrep -x Xwayland); K=$(pgrep -x kwin_wayland)
echo "== dma-bufs held: Xwayland $(ls -l /proc/$X/fd 2>/dev/null | grep -c dmabuf), kwin $(ls -l /proc/$K/fd 2>/dev/null | grep -c dmabuf)"
echo "== Xwayland's GLX vendor and extensions"
mgrun offscreen xdpyinfo 2>/dev/null | grep -E "^ +(DRI3|Present|MIT-SHM)$" | sed 's/^/ ext/'
echo "== a GLX window's path"
rm -f /tmp/mgl-x11-check.client.log
MGLOG=/tmp/mgl-x11-check.log timeout 6 mgrun offscreen glxgears >/dev/null 2>&1
grep -a "presented through\|leaves DRI3" /tmp/mgl-x11-check.client.log | sed 's/^/ /'
IN
adb_ logcat -d | grep -aE "MobileGL.*(shared image|dma-buf import|refused)" | tail -8 || true
adb_ logcat -b crash -d | tail -5 || true
;;
apps)
battery_ok
printf '%s\n' \
"pkill -x xterm; pkill -x xeyes; pkill -x glxgears; pkill -x konsole; pkill -x kate" \
"MGLOG=/tmp/mgl-x11-konsole.log mgrun offscreen env QT_QPA_PLATFORM=xcb konsole >/dev/null 2>&1 &" \
"MGLOG=/tmp/mgl-x11-kate.log mgrun offscreen env QT_QPA_PLATFORM=xcb kate >/dev/null 2>&1 &" \
"command -v xterm >/dev/null && MGLOG=/tmp/mgl-x11-xterm.log mgrun offscreen xterm >/dev/null 2>&1 &" \
"command -v xeyes >/dev/null && MGLOG=/tmp/mgl-x11-xeyes.log mgrun offscreen xeyes >/dev/null 2>&1 &" \
"MGLOG=/tmp/mgl-x11-gears.log mgrun offscreen glxgears >/dev/null 2>&1 &" \
"sleep 6; pgrep -a -x konsole; pgrep -a -x kate; pgrep -a -x xterm; pgrep -a -x xeyes; pgrep -a -x glxgears; true" | bash "$here/ct.sh" "$CH"
bash "$here/shot.sh" x11-apps 2 1
;;
stop)
printf '%s\n' "pkill -x xterm; pkill -x xeyes; pkill -x glxgears; pkill -x konsole; pkill -x kate; true" | bash "$here/ct.sh" "$CH"
;;
*)
echo "unknown step $step" >&2; exit 2
;;
esac
-16
View File
@@ -304,7 +304,6 @@ set(SOURCE_FILES
MobileGL/ConfigLoader.cpp
MobileGL/MG_Util/Debug/Log.cpp
MobileGL/MG_Util/X11/DisplayGuard.cpp
MobileGL/MG_Util/Async/JobNode.cpp
MobileGL/MG_Util/Async/ShaderCompilePool.cpp
@@ -402,8 +401,6 @@ set(SOURCE_FILES
MobileGL/MG_Impl/GLXImpl/Exporting/Definitions.cpp
MobileGL/MG_Impl/GLXImpl/Exporting/GlvndVendor.cpp
MobileGL/MG_Impl/GLXImpl/GLXImpl.cpp
MobileGL/MG_Impl/GLXImpl/X11Present.cpp
MobileGL/MG_Impl/GLXImpl/X11PresentXcb.cpp
MobileGL/MG_Impl/GLXImpl/LookUp/LookUp.cpp
MobileGL/MG_Impl/EGLImpl/Exporting/Definitions.cpp
@@ -440,7 +437,6 @@ set(SOURCE_FILES
MobileGL/MG_Backend/Init.cpp
MobileGL/MG_Backend/BackendObject.cpp
MobileGL/MG_Backend/GpuHangWatch.cpp
MobileGL/MG_Backend/DirectGLES/DirectGLES.cpp
MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp
@@ -468,7 +464,6 @@ set(SOURCE_FILES
MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.cpp
MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.cpp
MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.cpp
MobileGL/MG_Backend/DirectVulkan/Renderer/GpuProgressMarkers.cpp
MobileGL/MG_State/GLState/Core.cpp
MobileGL/MG_State/GLState/ShareGroupState.cpp
@@ -1009,17 +1004,6 @@ if (NOT ANDROID AND NOT MOBILEGL_IOS)
endif ()
endif ()
# Discover gtest cases when ctest starts, one binary after another, instead of in a post-build
# step. The post-build discovery of the CMake releases that never pass the target name down
# writes every binary's `--gtest_output=json` result to ONE per-directory file
# (cmake_test_discovery_<hash of an empty name>.json), so binaries linked in parallel in the same
# directory overwrite and delete each other's list: the registered count then differs between
# runs of the same tree and a binary ends up with none or only some of its cases. The pre-test
# mode reads the list from stdout, serially, and also works when the binary is cross-built.
if (NOT DEFINED CMAKE_GTEST_DISCOVER_TESTS_DISCOVERY_MODE)
set(CMAKE_GTEST_DISCOVER_TESTS_DISCOVERY_MODE PRE_TEST)
endif()
if (NOT ANDROID)
# Enable testing in the top-level scope so a CTestTestfile.cmake is emitted
# at the build-tree root. This lets `ctest` be invoked from the top-level
-12
View File
@@ -130,11 +130,6 @@ namespace MobileGL::MG_Config {
Bool AdvertiseFp64 = false;
// MOBILEGL_MAGMA_R11G11B10F_FALLBACK: use fallback format for R11G11B10F on Vulkan.
Bool MagmaR11G11B10FFallback = false;
// MOBILEGL_MAGMA_ALLOW_INVALID_SPIRV: hand a shader module that fails SPIR-V validation to
// the driver anyway. Off by default: Magma declines such a program (no shader module, its
// draws refused by name), because a driver that accepts invalid SPIR-V may fault the GPU
// into device loss. For diagnosing a driver that copes with a specific module only.
Bool MagmaAllowInvalidSpirv = false;
// MOBILEGL_MAGMA_FRAMESINFLIGHT: requested Magma frames in flight, defaulting to 3.
Uint32 MagmaFramesInFlight = 3;
// MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER: GL draws and dispatches Magma records into
@@ -634,13 +629,6 @@ namespace MobileGL::MG_Config {
// poll loop cannot outlive a late report. 0 = every poll crosses, as before P10: the A/B
// arm and the red-once of the no-reply gate (FencePollScenario).
Uint32 PollEscalate = 64;
// MOBILEGL_IPC_RECOVER (client): 1 (default) = after a device loss ends this client's
// session, the application's next eglCreateContext / eglCreate*Surface / eglInitialize
// dials the server for a FRESH session, and contexts created from then on work. Contexts
// (and their objects) from before the loss stay lost, as EGL's power-management event
// has them; surfaces survive and are re-created on the new session when next used.
// 0 = the loss is final for the process (every verb DECLINED for the rest of its life).
Uint32 RecoverAfterLoss = 1;
// MOBILEGL_IPC_ADOPT_TIER, THE ZERO-COPY SWITCH (ruling ID-P11-14, CONTRACT-P11 B2):
// UNSET (kAdoptTierUnset, the default since 2026-09-29, the user's decision) = T0 where the
// session can run it, T2 QUIETLY where it cannot (MGLOG_D only, still counted);
-3
View File
@@ -348,7 +348,6 @@ namespace MobileGL::MG_ConfigLoader {
features.MagmaDeriveNumSubgroups = QueryEnvQuirkOverride("MOBILEGL_MAGMA_DERIVE_NUM_SUBGROUPS");
features.AdvertiseFp64 = QueryEnvFlag("MOBILEGL_ADVERTISE_FP64");
features.MagmaR11G11B10FFallback = QueryEnvFlag("MOBILEGL_MAGMA_R11G11B10F_FALLBACK");
features.MagmaAllowInvalidSpirv = QueryEnvFlag("MOBILEGL_MAGMA_ALLOW_INVALID_SPIRV");
features.MagmaFramesInFlight = QueryEnvUint32("MOBILEGL_MAGMA_FRAMESINFLIGHT", 3, 1, 64);
features.MagmaMaxDrawsPerCommandBuffer =
QueryEnvUint32("MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER", 16384, 0, 1u << 24);
@@ -559,8 +558,6 @@ namespace MobileGL::MG_ConfigLoader {
ipc.PboReadbackSync = QueryEnvUint32("MOBILEGL_IPC_PBO_READBACK_SYNC", 0, 0, 1);
// P10: fence polls answered locally; 0 is the A/B arm (Config.h).
ipc.PollEscalate = QueryEnvUint32("MOBILEGL_IPC_POLL_ESCALATE", 64, 0, 1000000);
// A lost session is replaced by a fresh one on the application's next create (Config.h).
ipc.RecoverAfterLoss = QueryEnvUint32("MOBILEGL_IPC_RECOVER", 1, 0, 1);
// The verify harness compares the pushed block against the applier per verb; a
// batched queue lets the comparer read a supplied field mid-apply, which is a
// torn read rather than a divergence. The batch is therefore off whenever the
-4
View File
@@ -46,9 +46,5 @@ namespace MobileGL {
namespace MG_Impl {
void Init();
// GL framebuffer 0, built into the calling thread's GLContext (the process default at
// Init) and installed as the one every later context starts with. Init's step, and the
// rebuild after a recovered device loss, whose fresh session holds none of the old one's.
void BuildDefaultFramebuffer();
} // namespace MG_Impl
} // namespace MobileGL
-34
View File
@@ -666,23 +666,6 @@ namespace MobileGL {
(void)region;
return true;
}
// IMPLICIT SYNC BY FLUSH (docs/Disaggregated/notes/anland/plan-x11-gpu.md): the session
// on this (the apply) thread ends a frame at a glFlush. Every shared image it used since
// its last boundary is published as written and read by one fence of everything it
// submitted (SharedImages::ReadTracker::PublishFrameAsWrite), and from now on its first
// use of an image in a frame waits for that image's pending reads (it may be about to
// overwrite what another session still samples). A backend without shared images has
// nothing to publish.
virtual Bool PublishSharedImageAccesses() { return true; }
// EGL_ANDROID_native_fence_sync's fence command, on the server: in `*fence`, a sync_file
// (the caller's to close) that signals once everything the session submitted so far has
// completed - and, for a session that writes images, what PublishSharedImageAccesses
// does. -1 when there is none to give: the backend cannot export one, or the work has
// already completed - in both cases it HAS completed when this returns.
virtual Bool ExportNativeFence(int* fence) {
*fence = -1;
return PublishSharedImageAccesses();
}
// ---- shared images, CLIENT side (BackendObject_Remote implements these) ----------
//
@@ -728,17 +711,6 @@ namespace MobileGL {
(void)textureLifetimeId, (void)id;
return false;
}
// In the GL stream, from glFlush/glFinish: PublishSharedImageAccesses on the server,
// returning once the fence is published. Skipped (true) when nothing reached the stream
// since the last one.
virtual Bool FlushSharedImageAccesses() { return false; }
// In the GL stream, from eglCreateSync(EGL_SYNC_NATIVE_FENCE_ANDROID) with no descriptor:
// ExportNativeFence on the server. `*fence` is the sync_file it handed back (the
// caller's to close), or -1 when it had none - the fenced work has then completed.
virtual Bool CreateNativeFence(int* fence) {
*fence = -1;
return false;
}
virtual void Initialize() = 0;
virtual Bool InitCapabilities() = 0;
@@ -749,12 +721,6 @@ namespace MobileGL {
// native state is process-global by construction gives this object its own copy and binds
// it to the calling thread. The default has nothing per process to separate.
virtual void BindSessionStateToThisThread() {}
// A served session's apply thread asks this each time it wakes, BEFORE it applies another
// record: true when this session's own GPU work faulted or hung the GPU and the backend has
// latched the session for it (MGPipeSessionLatch, family DeviceLost), so the next frame -
// which would very likely stop the GPU again - is never applied. Cheap by contract: no
// wait, at most a status read. The default knows of no fault.
virtual Bool LatchIfGpuFaulted() { return false; }
// A served session's ring moved to another of its client's contexts (bind_context). A
// backend whose surface follows the native context it binds needs nothing; one that keeps
// a single native surface binding re-binds the surface that context was last made current
@@ -961,14 +961,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
return true;
}
Bool BackendObject_DirectGLES::LatchIfGpuFaulted() {
#if MOBILEGL_BUILD_DISAGGREGATED
return LatchIfGuiltyBeforeApply();
#else
return false;
#endif
}
void BackendObject_DirectGLES::Initialize() {
MG_Util::BackendLoader::AcquireEGLFunctions(m_EGLFunctions);
MG_Util::BackendLoader::AcquireGLESFunctions(m_GLESFunctions, m_EGLFunctions.eglGetProcAddress);
@@ -1238,23 +1230,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
return DirectGLES::SetCurrentDrawDamageRegion(region);
}
Bool BackendObject_DirectGLES::PublishSharedImageAccesses() {
#if MOBILEGL_BUILD_DISAGGREGATED
return DirectGLES::SharedImageImpl::PublishPendingAccesses();
#else
return true;
#endif
}
Bool BackendObject_DirectGLES::ExportNativeFence(int* fence) {
*fence = -1;
#if MOBILEGL_BUILD_DISAGGREGATED
return DirectGLES::SharedImageImpl::ExportNativeFence(fence);
#else
return true;
#endif
}
Bool BackendObject_DirectGLES::SwapEGLBuffers(EGLDisplay dpy, EGLSurface draw) {
return BackendObject::SwapEGLBuffers(dpy, draw);
}
@@ -32,8 +32,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
public:
~BackendObject_DirectGLES() override;
// The driver's verdict on this session's context (DirectGLES::LatchIfDeviceLost).
Bool LatchIfGpuFaulted() override;
void Initialize() override;
Bool InitCapabilities() override;
Bool InitWindowSurface() override;
@@ -53,10 +51,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
Int32 QueryCurrentBufferAge(Bool damageRegionFollows) override;
// eglSetDamageRegionKHR on a window surface whose driver has EGL_KHR_partial_update.
Bool SetCurrentDamageRegion(const MG_Util::Damage::Region& region) override;
// A glFlush that ends a shared-image producer's frame (SharedImageImpl::PublishPendingAccesses).
Bool PublishSharedImageAccesses() override;
// An EGL native fence of the session's work (SharedImageImpl::ExportNativeFence).
Bool ExportNativeFence(int* fence) override;
void ReleaseEGLSurface(EGLSurface surface) override;
void ReleaseEGLResources() override;
// The server window going and coming back: each window surface on it swaps its native EGL
+32 -199
View File
@@ -8,7 +8,6 @@
#include "DirectGLES.h"
#include "ContextEpoch.h"
#include "MG_Util/X11/DisplayGuard.h"
#include "EGL/egl.h"
#include "MG_Util/Types.h"
#include "Utils.h"
@@ -16770,7 +16769,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
static EGLint QueryDefaultX11VisualId() {
#if defined(__linux__) && !defined(__ANDROID__)
const char* displayName = std::getenv("DISPLAY");
if (!displayName || !MG_Util::X11::MayDialX11Display(displayName)) {
if (!displayName) {
return 0;
}
@@ -16817,7 +16816,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
return 0;
}
const char* displayName = std::getenv("DISPLAY");
if (!displayName || !MG_Util::X11::MayDialX11Display(displayName)) {
if (!displayName) {
return 0;
}
@@ -16982,53 +16981,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
#endif
}
// RESET NOTIFICATION, decided once per process by its first native context (EnsureNativeContext
// says why). MOBILEGL_ESPRYT_RESET_NOTIFICATION=0 keeps the driver's default.
namespace {
// EGL_EXT_create_context_robustness (eglext.h is not part of this file's include set).
constexpr EGLint kEglResetNotificationStrategyExt = 0x3138;
constexpr EGLint kEglLoseContextOnResetExt = 0x31BF;
enum class ResetNotification : Uint8 { Undecided, On, Off };
std::atomic<ResetNotification> g_resetNotification{ResetNotification::Undecided};
Bool ResetNotificationWanted() {
const ResetNotification decided = g_resetNotification.load(std::memory_order_acquire);
if (decided != ResetNotification::Undecided) return decided == ResetNotification::On;
if (const char* value = std::getenv("MOBILEGL_ESPRYT_RESET_NOTIFICATION"); value != nullptr && value[0] == '0')
return false;
if (g_Display == EGL_NO_DISPLAY || !g_EGLFuncs.eglQueryString) return false;
const char* extensions = g_EGLFuncs.eglQueryString(g_Display, EGL_EXTENSIONS);
if (extensions == nullptr) return false;
constexpr const char kWord[] = "EGL_EXT_create_context_robustness";
for (const char* at = std::strstr(extensions, kWord); at != nullptr; at = std::strstr(at + 1, kWord)) {
const char after = at[sizeof(kWord) - 1];
if ((at == extensions || at[-1] == ' ') && (after == '\0' || after == ' ')) return true;
}
return false;
}
void NoteResetNotificationRefused() {
ResetNotification expected = ResetNotification::Undecided;
if (g_resetNotification.compare_exchange_strong(expected, ResetNotification::Off, std::memory_order_acq_rel))
MGLOG_W("DirectGLES: the driver refused EGL_LOSE_CONTEXT_ON_RESET; a context that hangs the GPU is "
"not told, and its session cannot be ended for it");
}
void NoteResetNotificationDecided(Bool used) {
ResetNotification expected = ResetNotification::Undecided;
const ResetNotification decided = used ? ResetNotification::On : ResetNotification::Off;
if (g_resetNotification.compare_exchange_strong(expected, decided, std::memory_order_acq_rel))
MGLOG_I("DirectGLES: native contexts %s reset notification (EGL_LOSE_CONTEXT_ON_RESET): a context "
"whose work hangs or faults the GPU %s",
used ? "ask for" : "do not ask for",
used ? "is named by the driver and ends its own session" : "is not told");
}
} // namespace
Bool NativeContextsNotifyResets() {
return g_resetNotification.load(std::memory_order_acquire) == ResetNotification::On;
}
static Bool EnsureNativeContext(NativeContextTuple& tuple, EGLint surfaceBit, NativeWindowType window) {
if (!EnsureDisplayInitialized()) {
MGLOG_E("EnsureNativeContext: the EGL display did not initialize");
@@ -17077,47 +17029,21 @@ namespace MobileGL::MG_Backend::DirectGLES {
// request yields a 3.0 context that lacks the 3.1/3.2 texture targets the
// capability probes exercise; mobile drivers ignore the minor and hand out
// their maximum either way.
//
// RESET NOTIFICATION. With the driver's default strategy a context whose work hung the GPU
// is never told: after Adreno's ~2 s timeout reset it silently drops everything that context
// submits (the client's window just stops), and its client never learns it should recreate.
// Asking for EGL_LOSE_CONTEXT_ON_RESET lets the driver name the guilty context
// (glGetGraphicsResetStatus answers GUILTY, once) and LatchIfDeviceLost ends that session
// alone, so the client reads a lost context and can recover. (A ~10 s reset that a failed
// preemption ends was not reported to the server's contexts in measurement - see
// GpuHangWatch.h.) Every context of the process shares one group, and contexts that share
// must agree on the strategy, so it is decided once, by the first context, and kept.
for (const EGLint minorVersion : {2, 1, 0}) {
const Bool notify = ResetNotificationWanted();
const EGLint contextAttribs[] = {EGL_CONTEXT_MAJOR_VERSION, 3,
EGL_CONTEXT_MINOR_VERSION, minorVersion,
notify ? kEglResetNotificationStrategyExt : EGL_NONE,
kEglLoseContextOnResetExt,
EGL_NONE};
tuple.Context = g_EGLFuncs.eglCreateContext(g_Display, tuple.Config, share, contextAttribs);
if (tuple.Context == EGL_NO_CONTEXT && notify && share == EGL_NO_CONTEXT) {
// The process's first context: if the same version WITHOUT the strategy is accepted,
// it was the strategy the driver refused, and no context of the process asks for it.
const EGLint plainAttribs[] = {EGL_CONTEXT_MAJOR_VERSION, 3, EGL_CONTEXT_MINOR_VERSION, minorVersion,
EGL_NONE};
tuple.Context = g_EGLFuncs.eglCreateContext(g_Display, tuple.Config, share, plainAttribs);
if (tuple.Context != EGL_NO_CONTEXT) NoteResetNotificationRefused();
}
if (tuple.Context != EGL_NO_CONTEXT) {
NoteResetNotificationDecided(notify);
tuple.Serial = g_nativeContextSerials.fetch_add(1, std::memory_order_relaxed) + 1;
++g_displayUsers;
return true;
}
}
const Bool notify = ResetNotificationWanted();
const EGLint legacyContextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3,
notify ? kEglResetNotificationStrategyExt : EGL_NONE,
kEglLoseContextOnResetExt, EGL_NONE};
const EGLint legacyContextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
tuple.Context = g_EGLFuncs.eglCreateContext(g_Display, tuple.Config, share, legacyContextAttribs);
if (tuple.Context == EGL_NO_CONTEXT) return false;
NoteResetNotificationDecided(notify);
tuple.Serial = g_nativeContextSerials.fetch_add(1, std::memory_order_relaxed) + 1;
++g_displayUsers;
return true;
@@ -17183,14 +17109,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
tuple->Read = EGL_NO_SURFACE;
g_nativeRegistryEpoch.fetch_add(1, std::memory_order_acq_rel);
if (g_displayUsers > 0) --g_displayUsers;
// NOT WHILE A SESSION STILL HOLDS SURFACES. eglTerminate destroys them with the display, and
// the session keeps naming them: the next context made current on one (an application that
// destroys its only context and creates another on the same surface, as eglinfo does with
// its surfaceless stand-in) bound a surface the driver no longer had. The session's own
// teardown terminates the display once its surfaces are gone (DestroyNativeStateOfSession).
Bool surfacesRemain = false;
for (const auto* session : NativeSessions()) surfacesRemain = surfacesRemain || !session->Surfaces.empty();
if (g_displayUsers == 0 && !surfacesRemain && g_Display != EGL_NO_DISPLAY && g_EGLFuncs.eglTerminate) {
if (g_displayUsers == 0 && g_Display != EGL_NO_DISPLAY && g_EGLFuncs.eglTerminate) {
g_EGLFuncs.eglTerminate(g_Display);
NoteDisplayTerminated();
g_Display = EGL_NO_DISPLAY;
@@ -17218,12 +17137,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
// own thread with its own context, and binding a context back onto another window's
// surface drew one window's frame into the other.
NativeSessionState& session = ActiveNativeSession();
// Nothing to make it current on yet: a context bound for the records of its own creation
// (EGLImpl's CreateContext), which no make-current has given a surface (or whose surface
// is gone). Binding it to whichever surface the session holds would hand it another
// context's surface - one the driver may not even have any more. Its first make-current
// binds it natively.
if (tuple.Draw == EGL_NO_SURFACE) return true;
if (tuple.Draw != session.Draw && SessionOwnsSurface(session, tuple.Draw)) {
session.Draw = tuple.Draw;
session.Read = SessionOwnsSurface(session, tuple.Read) ? tuple.Read : tuple.Draw;
@@ -18302,61 +18215,25 @@ namespace MobileGL::MG_Backend::DirectGLES {
}
#if MOBILEGL_BUILD_DISAGGREGATED
namespace {
// Once per thread: a latched session declines everything after this verb anyway, and the
// apply thread is the session's own.
thread_local Bool t_deviceLossLatched = false;
Bool LatchOnResetStatus(const char* site, GLenum status) {
if (status == GL_NO_ERROR) return false;
// ONLY THE GUILTY CONTEXT ENDS ITS SESSION. The contexts ask for reset notification
// (EnsureNativeContext) so the driver can name the context whose work hung or faulted the
// GPU; a reset it reports to an INNOCENT context - one whose work only waited behind the
// stall, the compositor's above all - is noted and the session goes on as it did before
// contexts were told. Adreno 750 measured: the guilty context reads GUILTY once, after
// which the driver drops everything it submits; innocent ones read NO_ERROR.
static thread_local Bool innocentNoted = false;
if (status == GL_INNOCENT_CONTEXT_RESET) {
if (!innocentNoted) {
innocentNoted = true;
MGLOG_W("Espryt:%s - the driver reports a GPU reset this session's context did not cause "
"(GL_INNOCENT_CONTEXT_RESET); the session goes on",
site != nullptr ? site : "?");
}
return false;
}
t_deviceLossLatched = true;
(void)MG_Pipe::MGPipeSessionLatch(MG_Pipe::MGPipeFatalFamily::DeviceLost,
"MGPipe: Fatal{BackendDeviceLost, \"Espryt:%s\"} - this session's EGL "
"context was reset (glGetGraphicsResetStatus 0x%x); the session ends "
"and its client reads a lost context, every other session keeps running",
site != nullptr ? site : "?", static_cast<unsigned>(status));
return true;
}
} // namespace
Bool LatchIfDeviceLost(const char* site, Bool debugKnob) {
if (MG_Config::Transport == MG_Config::TransportMode::Monolith) return false;
if (t_deviceLossLatched) return true;
// Once per thread: a latched session declines everything after this verb anyway, and the
// apply thread is the session's own.
static thread_local Bool latched = false;
if (latched) return true;
GLenum status = GL_NO_ERROR;
if (g_GLESFuncs.glGetGraphicsResetStatus != nullptr && IsBackendContextCurrentOnThisThread()) {
status = g_GLESFuncs.glGetGraphicsResetStatus();
}
if (status == GL_NO_ERROR && debugKnob && MG_Pipe::MGPipeDebugDeviceLossDue()) status = GL_UNKNOWN_CONTEXT_RESET;
return LatchOnResetStatus(site, status);
}
Bool LatchIfGuiltyBeforeApply() {
if (MG_Config::Transport == MG_Config::TransportMode::Monolith) return false;
if (t_deviceLossLatched) return true;
// Asked every time the apply thread wakes, so it must leave nothing behind: not
// IsBackendContextCurrentOnThisThread, whose once-per-frame EGL verification stamp it would
// spend at the top of the loop (where the session may be between two of its contexts) - only
// whether this thread holds a native context and the backend's ownership.
if (g_GLESFuncs.glGetGraphicsResetStatus == nullptr || t_boundNativeContext == EGL_NO_CONTEXT ||
g_backendContextOwnerThread.load(std::memory_order_acquire) != std::this_thread::get_id())
return false;
return LatchOnResetStatus("apply", g_GLESFuncs.glGetGraphicsResetStatus());
if (status == GL_NO_ERROR) return false;
latched = true;
(void)MG_Pipe::MGPipeSessionLatch(MG_Pipe::MGPipeFatalFamily::DeviceLost,
"MGPipe: Fatal{BackendDeviceLost, \"Espryt:%s\"} - this session's EGL "
"context was reset (glGetGraphicsResetStatus 0x%x); the session ends "
"and its client reads a lost context, every other session keeps running",
site != nullptr ? site : "?", static_cast<unsigned>(status));
return true;
}
#endif
@@ -18412,13 +18289,25 @@ namespace MobileGL::MG_Backend::DirectGLES {
if (const auto* entry = FindSessionSurfaceLocked(session, drawSurface))
windowSurface = entry->Window != static_cast<NativeWindowType>(0);
}
EGLBoolean mglSwapped = EGL_FALSE;
if (g_EGLFuncs.eglSwapBuffersWithDamageEXT != nullptr) {
const MG_Util::Damage::Region& damage = MG_Backend::CurrentPresentDamage();
EGLint rects[MG_Util::Damage::kMaxRects * 4] = {};
const EGLint count = static_cast<EGLint>(MG_Util::Damage::NativeSwapRects(windowSurface, damage, rects));
g_EGLFuncs.eglSwapBuffersWithDamageEXT(g_Display, drawSurface, count > 0 ? rects : nullptr, count);
} else {
g_EGLFuncs.eglSwapBuffers(g_Display, drawSurface);
mglSwapped = g_EGLFuncs.eglSwapBuffersWithDamageEXT(g_Display, drawSurface, count > 0 ? rects : nullptr, count);
// A DRIVER THAT NAMES THE ENTRY POINT AND THEN REFUSES THE SWAP. Some vendor EGLs
// export eglSwapBuffersWithDamageEXT and answer EGL_FALSE on a window surface without
// setting an error (measured on a 4.14 vendor kernel with an Adreno driver; the plain
// entry point presents the same surface happily). Keeping the frame on that answer
// queues nothing at all: the compositor composites into a window whose buffer queue
// never sees a buffer. Fall back to the plain call instead of dropping the frame.
if (mglSwapped == EGL_FALSE && g_EGLFuncs.eglSwapBuffers != nullptr) {
MGLOG_W_ONCE("DirectGLES: this driver's eglSwapBuffersWithDamageEXT refused a window "
"surface; presenting through eglSwapBuffers for the rest of the process");
mglSwapped = g_EGLFuncs.eglSwapBuffers(g_Display, drawSurface);
}
} else if (g_EGLFuncs.eglSwapBuffers != nullptr) {
mglSwapped = g_EGLFuncs.eglSwapBuffers(g_Display, drawSurface);
}
if (drawSurface != EGL_NO_SURFACE) {
const std::lock_guard<std::mutex> lock(g_nativeRegistryMutex);
@@ -18935,9 +18824,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
struct ReadFrame {
Uint64 Id = 0;
SI::ReadTracker Tracker;
// The session ends frames at publishing flushes (PublishPendingAccesses): it writes
// images, so its first use of one in a frame waits for that image's pending reads.
Bool ImplicitSync = false;
};
std::atomic<Uint64> g_readFrameIds{0};
@@ -18965,54 +18851,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
CloseFd(fence);
ReadFrame& frame = CurrentReadFrame();
if (state.NotedFrame != frame.Id) {
// A session that renders into images (it ends frames with a publishing flush) may be
// about to overwrite this one: what other sessions still sample goes first.
if (frame.ImplicitSync) {
for (const int read : SI::DupPendingReadFences(*state.Image)) WaitForFenceBeforeLaterCommands(read);
}
frame.Tracker.NoteRead(state.Image);
state.NotedFrame = frame.Id;
}
}
Bool PublishPendingAccesses() {
ReadFrame& frame = CurrentReadFrame();
frame.ImplicitSync = true;
// Sub-data waiting for a sync that nothing of this session would otherwise trigger.
if (t_boundNativeContext != EGL_NO_CONTEXT) TextureImpl::WritePendingSharedImageUploads();
if (frame.Tracker.Pending() == 0) return true;
int fence = -1;
if (t_boundNativeContext != EGL_NO_CONTEXT && !ExportFence(&fence)) {
// No fence to publish: the work is waited out here, and published as completed.
(void)WaitForCompletion();
}
frame.Tracker.PublishFrameAsWrite(fence);
frame.Id = g_readFrameIds.fetch_add(1, std::memory_order_relaxed) + 1;
return true;
}
Bool ExportNativeFence(int* fence) {
*fence = -1;
ReadFrame& frame = CurrentReadFrame();
// No context current: nothing of this session is in flight to fence.
if (t_boundNativeContext == EGL_NO_CONTEXT) return true;
TextureImpl::WritePendingSharedImageUploads();
int exported = -1;
if (!ExportFence(&exported)) {
// No descriptor to give: the work is waited out, so the caller may report it done.
exported = -1;
(void)WaitForCompletion();
}
// A session that writes images (one that ends frames at flushes) ends one here too; a
// compositor's reads stay for its swap, which comes after the fence's work anyway.
if (frame.ImplicitSync && frame.Tracker.Pending() != 0) {
frame.Tracker.PublishFrameAsWrite(exported >= 0 ? ::dup(exported) : -1);
frame.Id = g_readFrameIds.fetch_add(1, std::memory_order_relaxed) + 1;
}
*fence = exported;
return true;
}
void PublishPendingReads() {
ReadFrame& frame = CurrentReadFrame();
if (frame.Tracker.Pending() == 0) return;
@@ -19025,12 +18868,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
// producer), nothing it submitted still samples the image.
(void)WaitForCompletion();
}
// A session that writes images publishes every boundary as a write: an image it rendered
// into must not leave the frame without its generation moving.
if (frame.ImplicitSync)
frame.Tracker.PublishFrameAsWrite(fence);
else
frame.Tracker.PublishFrame(fence);
frame.Tracker.PublishFrame(fence);
frame.Id = g_readFrameIds.fetch_add(1, std::memory_order_relaxed) + 1;
}
@@ -19208,11 +19046,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
}
void AcquireForSampling(const EglImageRef& image) { (void)image; }
void PublishPendingReads() {}
Bool PublishPendingAccesses() { return true; }
Bool ExportNativeFence(int* fence) {
*fence = -1;
return true;
}
void ForgetPresentTargetsAfterTerminate() {}
#endif
} // namespace SharedImageImpl
+4 -21
View File
@@ -162,21 +162,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
// driver whether the calling thread's context was reset (glGetGraphicsResetStatus); a reset -
// or the debug knob MGPipeDebugDeviceLossDue - latches THIS session through
// MGPipeSessionLatch and answers true, and the caller returns from its verb without issuing
// more GL. Asked at the frame boundaries (Present, a shared-image present), before a readback,
// and by the apply loop each time it wakes (LatchIfGpuFaulted), never per draw. The contexts ask
// for reset notification (NativeContextsNotifyResets) so the driver can name the GUILTY one;
// only GUILTY (or a reset of unknown cause) ends the session - an INNOCENT report, a context
// whose work merely waited behind another's hang (the compositor's among them), is only noted.
// more GL. Asked at the frame boundaries (Present, a shared-image present) and before a
// readback, never per draw. The contexts keep the driver's default reset strategy: asking
// every context to lose itself on reset would also end the INNOCENT ones - the compositor's
// among them - on any other client's GPU fault.
// `debugKnob` false: the knob is not consulted here (the on-screen Present, so an injected loss
// lands on an offscreen client's shared-image present or readback, never on the compositor's).
Bool LatchIfDeviceLost(const char* site, Bool debugKnob = true);
// The apply loop's form of it (BackendObject::LatchIfGpuFaulted), asked each time the apply thread
// wakes: the driver's report only, no debug knob, and no EGL ground-truth verification spent.
Bool LatchIfGuiltyBeforeApply();
#endif
// True once the process's native contexts were created with EGL_LOSE_CONTEXT_ON_RESET (decided
// by the first one; the driver must offer EGL_EXT_create_context_robustness).
Bool NativeContextsNotifyResets();
// GL fence sync objects, backed by native ES fences. FenceSync returns null
// (the frontend then falls back to an always-signaled sync) when the calling
// thread does not own the ES context. Waits/queries degrade to "signaled" in
@@ -553,16 +546,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
// at Present and wherever the current native context stops being current (its reads can
// only be fenced from it). Nothing noted = nothing done.
void PublishPendingReads();
// IMPLICIT SYNC BY FLUSH (BackendObject::PublishSharedImageAccesses): everything the
// calling session used since its last boundary is published as written and read by one
// fence, and the session's first use of an image in each frame from now on also waits for
// the image's pending reads.
Bool PublishPendingAccesses();
// EGL_ANDROID_native_fence_sync's fence command (BackendObject::ExportNativeFence): a
// sync_file of everything the current context submitted in `*fence` (-1: none, and the work
// is waited out here), and - for a session that writes images - the boundary
// PublishPendingAccesses makes.
Bool ExportNativeFence(int* fence);
} // namespace SharedImageImpl
#endif
+18 -95
View File
@@ -8858,12 +8858,27 @@ namespace MobileGL::MG_Backend::DirectGLES {
return false;
}
// Sub-data aimed at the image is not replayed into it - the image is written by the
// producer's present - but it must still leave the pending set, or the per-draw clean
// gate (IsDrawSyncCleanByRecord) would never close.
const auto dropPendingUploads = [&record] {
if (record.PendingUploads.empty()) return;
MGLOG_W_ONCE("Shared image texture %u: sub-data on an attached shared image is dropped",
record.Desc.GlNameForDiag);
Vector<std::pair<Uint16, Uint16>> keys;
keys.reserve(record.PendingUploads.size());
for (const auto& pending : record.PendingUploads) {
keys.emplace_back(MG_Pipe::MGPipeSubDataUploadTargetOf(pending.UploadTarget), pending.Level);
}
for (const auto& key : keys) ConsumePipeTextureUpload(record.Desc.Resource, key.first, key.second);
};
// Steady state: bound to this image already (the serial moves with sub-data and with a
// metadata respecify, neither of which changes what the name samples). A failed bind is
// retried only once the record moves. Pending sub-data is the caller's
// (ReplaySharedImageUploads), after the image's sync state has been acquired.
// retried only once the record moves.
if (m_sharedImageId == imageId && m_isInitialized &&
(m_sharedImage != nullptr || m_syncedResourceSerial == record.Serial)) {
dropPendingUploads();
m_syncedResourceSerial = record.Serial;
return true;
}
@@ -8878,6 +8893,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
// Whatever comes next redefines storage through a re-mint (see the imageId == 0 arm).
m_backendStorageImmutable = true;
m_syncedResourceSerial = record.Serial;
dropPendingUploads();
const TextureTarget target = BufferImpl::StagedTextureTargetForPipeTarget(record.Desc.Target);
if (ConvertTextureTargetToBackendGLEnum(target) != GL_TEXTURE_2D) {
@@ -8899,7 +8915,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
return true;
}
m_sharedImage = std::move(image);
m_sharedImageUploadsRgb = false;
// The shape the name now has: the descriptor's level 0, and that one level only.
m_prevTextureInfo = {static_cast<TextureInternalFormat>(record.Desc.InternalFormat),
record.Desc.Width,
@@ -8911,83 +8926,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
record.Desc.FixedSampleLocations != 0};
return true;
}
// SUB-DATA ON A SHARED IMAGE IS WRITTEN INTO IT. An X server drawing with glamor uploads
// its clients' pixels (MIT-SHM / PutImage) into window pixmaps whose level 0 is a shared
// image, with glTexSubImage2D: the texels are in the staged store (the client defined the
// level without data, so only the uploaded boxes are covered), and they go into the
// EGLImage-backed name box by box. Every pending entry leaves the set either way, or the
// per-draw clean gate would never close. Called after AcquireForSampling, so the upload is
// ordered after the image's pending reads and writes like any other use.
void BackendTextureObject::ReplaySharedImageUploads(const MG_Pipe::MGPipeResourceRecord& record) {
if (record.PendingUploads.empty()) return;
Vector<std::pair<Uint16, Uint16>> keys;
Vector<std::pair<Uint16, MG_Pipe::MGPBox>> boxes;
keys.reserve(record.PendingUploads.size());
for (const auto& pending : record.PendingUploads) {
const Uint16 uploadHalf = MG_Pipe::MGPipeSubDataUploadTargetOf(pending.UploadTarget);
keys.emplace_back(uploadHalf, pending.Level);
if (pending.Level != 0) continue; // an image has one level
if (pending.Regions.empty()) {
boxes.emplace_back(uploadHalf, pending.UnionBox);
} else {
for (const auto& region : pending.Regions)
boxes.emplace_back(uploadHalf, MG_Pipe::MGPBox{region.X, region.Y, region.Z, region.W, region.H,
region.D});
}
}
if (m_sharedImage != nullptr && !boxes.empty()) {
auto& store = MG_Remote::Server::ServerStagedTexture();
const Uint64 key = MG_Remote::Server::StagedTextureStore::KeyForHandle(record.Desc.Resource);
Bind(GL_TEXTURE_2D);
ScopedDefaultUnpackState unpackState;
BufferImpl::BindPixelUnpackBufferId(0);
for (const auto& [uploadHalf, box] : boxes) {
Int rowTexels = 0;
// A shared image is RGBA8 to every client that names it (the level the client
// defined over it): four bytes a texel.
const Uint8* bytes =
store.CoveredBoxBytes(key, uploadHalf, 0, box.X, box.Y, box.W, box.H, 4, &rowTexels);
if (bytes == nullptr) {
MGLOG_E_ONCE("Shared image texture %u: an upload of %ux%u at (%d,%d) has no staged texels; "
"not written",
record.Desc.GlNameForDiag, box.W, box.H, box.X, box.Y);
continue;
}
const Uint8* origin =
bytes + (static_cast<SizeT>(box.Y) * static_cast<SizeT>(rowTexels) + static_cast<SizeT>(box.X)) * 4;
if (!m_sharedImageUploadsRgb) {
while (g_GLESFuncs.glGetError() != GL_NO_ERROR) {
}
g_GLESFuncs.glPixelStorei(GL_UNPACK_ROW_LENGTH, rowTexels);
g_GLESFuncs.glTexSubImage2D(GL_TEXTURE_2D, 0, box.X, box.Y, static_cast<GLsizei>(box.W),
static_cast<GLsizei>(box.H), GL_RGBA, GL_UNSIGNED_BYTE, origin);
g_GLESFuncs.glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
// An image of an X format (no alpha) is an RGB8 texture to the driver, which
// takes only RGB texels: this image's uploads are converted from now on.
if (g_GLESFuncs.glGetError() != GL_INVALID_OPERATION) continue;
m_sharedImageUploadsRgb = true;
}
Vector<Uint8> rgb(static_cast<SizeT>(box.W) * box.H * 3);
for (Uint32 row = 0; row < box.H; ++row) {
const Uint8* src = origin + static_cast<SizeT>(row) * static_cast<SizeT>(rowTexels) * 4;
Uint8* dst = rgb.data() + static_cast<SizeT>(row) * box.W * 3;
for (Uint32 x = 0; x < box.W; ++x) {
dst[x * 3 + 0] = src[x * 4 + 0];
dst[x * 3 + 1] = src[x * 4 + 1];
dst[x * 3 + 2] = src[x * 4 + 2];
}
}
g_GLESFuncs.glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
g_GLESFuncs.glTexSubImage2D(GL_TEXTURE_2D, 0, box.X, box.Y, static_cast<GLsizei>(box.W),
static_cast<GLsizei>(box.H), GL_RGB, GL_UNSIGNED_BYTE, rgb.data());
g_GLESFuncs.glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
}
MGLOG_I_ONCE("Shared image texture %u: sub-data written into its image (%s texels)",
record.Desc.GlNameForDiag, m_sharedImageUploadsRgb ? "RGB" : "RGBA");
}
for (const auto& [uploadHalf, level] : keys) ConsumePipeTextureUpload(record.Desc.Resource, uploadHalf, level);
}
#endif
void BackendTextureObject::SyncMipmapsToBackend(
@@ -9041,7 +8979,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
// a write that landed since the last one is waited for on this context's GPU
// before the command this sync is for, and the session's frame notes the read.
if (m_sharedImage != nullptr) SharedImageImpl::AcquireForSampling(m_sharedImage);
ReplaySharedImageUploads(*pushedStorage);
return;
}
// P5e (tx2), CONTRACT-P5E §5.2 (scout G-S2-2): THE VIEW TEST MOVES BEHIND THE
@@ -11311,20 +11248,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
g_boundTexturesCache;
TwinRegistry<MG_State::GLState::ITextureObject, BackendTextureObject, MG_Pipe::MGPipeKind::Texture> g_backendTextureObjects;
#if MOBILEGL_BUILD_DISAGGREGATED
void WritePendingSharedImageUploads() {
auto& applier = MG_Pipe::MGPipeApplier();
for (SizeT slot = 0; slot < applier.TextureResources.size(); ++slot) {
const auto& record = applier.TextureResources[slot];
if (!record.Live || record.SharedImageId == 0 || record.PendingUploads.empty()) continue;
const MG_Pipe::MGPipeHandle handle{static_cast<Uint32>(slot), record.Gen};
auto* twin = g_backendTextureObjects.FindByHandle(handle);
if (twin == nullptr || !*twin) continue;
(*twin)->SyncMipmapsToBackendByHandle(handle);
}
}
#endif
void NoteDriverSideTextureWrite(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject) {
SharedPtr<MG_State::GLState::ITextureObject> storage = textureObject;
// Bounded: GL resolves a view of a view to the original storage, so this takes one step.
-10
View File
@@ -2111,10 +2111,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
// not go on to allocate or upload. False when the record names no image: a twin that
// was bound to one has been told to re-mint, and the normal storage path takes over.
Bool SyncSharedImageStorage(const MG_Pipe::MGPipeResourceRecord& record);
// Pending sub-data written into the attached shared image (Managers.cpp).
void ReplaySharedImageUploads(const MG_Pipe::MGPipeResourceRecord& record);
// The attached image takes RGB texels only (an X format): uploads are converted.
Bool m_sharedImageUploadsRgb = false;
#endif
// Whether this texture's ES storage was minted in an image carrier rather than in the
// frontend format's own layout - the readback has to ask, because for a NORMALIZED
@@ -2487,12 +2483,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
// FBO's texture attachments - onto the backend, through the two borrowed-pair memos
// documented at their definitions. Declared here so tests can drive those memos directly.
void SyncNeccessaryTextures();
#if MOBILEGL_BUILD_DISAGGREGATED
// Every texture of this session bound to a shared image with sub-data still pending is
// synced now, so the uploads are in the images before a flush publishes them (an X
// server's PutImage into a window pixmap no later draw of its own samples).
void WritePendingSharedImageUploads();
#endif
extern Array<Array<BackendTextureObject*, (SizeT)TextureTarget::TextureTargetCount>,
MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS>
g_boundTexturesCache;
+1 -4
View File
@@ -572,10 +572,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
#endif
// The name is the marker: ShaderSourceProcessor only emits it when the source
// names gl_FragColor, and a shader that writes it can have no other output. One that
// names it only in an inactive preprocessor arm keeps the declaration unwritten, and
// the IO resolver moves that inactive output off location 0, so the match below
// (which wants location 0) does not take it.
// wrote gl_FragColor, and such a shader can have no other output.
static const char* const kLoweredName = "mg_FragColor";
if (shaderType != GL_FRAGMENT_SHADER || drawBufferCount <= 1) {
return glslCode;
@@ -422,14 +422,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
static_cast<unsigned long long>(m_magmaSession->Id()));
}
Bool BackendObject_DirectVulkan::LatchIfGpuFaulted() {
#if MOBILEGL_BUILD_DISAGGREGATED
return pVulkanRenderer != nullptr && pVulkanRenderer->LatchIfGpuHung("apply");
#else
return false;
#endif
}
void BackendObject_DirectVulkan::Initialize() {
#if MOBILEGL_BUILD_DISAGGREGATED
VkBufferManager::RegisterWireResourceOps();
@@ -593,25 +585,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
#endif
}
Bool BackendObject_DirectVulkan::PublishSharedImageAccesses() {
#if MOBILEGL_BUILD_DISAGGREGATED
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
return pVulkanRenderer ? pVulkanRenderer->PublishSharedImageAccesses() : true;
#else
return true;
#endif
}
Bool BackendObject_DirectVulkan::ExportNativeFence(int* fence) {
*fence = -1;
#if MOBILEGL_BUILD_DISAGGREGATED
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
return pVulkanRenderer ? pVulkanRenderer->ExportNativeFence(fence) : true;
#else
return true;
#endif
}
// A swapchain image keeps its content through a present whatever region is drawn next: the
// damage region the client may declare is not needed here.
Int32 BackendObject_DirectVulkan::QueryCurrentBufferAge(Bool damageRegionFollows) {
@@ -28,8 +28,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
void Initialize() override;
void BindSessionStateToThisThread() override;
// The GPU hang watch's verdict on this session's device (VulkanRenderer::LatchIfGpuHung).
Bool LatchIfGpuFaulted() override;
void OnClientContextBound(Uint64 token) override;
Bool InitWindowSurface() override;
Bool InitCapabilities() override;
@@ -44,10 +42,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
const MG_Util::Damage::Region& region) override;
// The active surface target's swapchain image ages (VulkanRenderer::CurrentDrawBufferAge).
Int32 QueryCurrentBufferAge(Bool damageRegionFollows) override;
// A glFlush that ends a shared-image producer's frame (VulkanRenderer::PublishSharedImageAccesses).
Bool PublishSharedImageAccesses() override;
// An EGL native fence of the session's work (VulkanRenderer::ExportNativeFence).
Bool ExportNativeFence(int* fence) override;
void ReleaseEGLSurface(EGLSurface surface) override;
void ReleaseEGLResources() override;
// The server window going and coming back: the window surface's target (VkSurfaceKHR,
@@ -1,202 +0,0 @@
// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/GpuProgressMarkers.cpp
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#include "GpuProgressMarkers.h"
#include <MG_Util/Debug/Log.h>
namespace MobileGL::MG_Backend::DirectVulkan {
namespace Watch = MG_Backend::GpuHangWatch;
void GpuProgressMarkers::Init(VkDevice device, Uint32 queueFamilyIndex) {
if (m_device != VK_NULL_HANDLE || device == VK_NULL_HANDLE) return;
if (Watch::BudgetMs() == 0) {
MGLOG_I("Magma: GPU hang watch off (MOBILEGL_GPU_HANG_BUDGET_MS=0)");
return;
}
VkCommandPoolCreateInfo poolInfo{VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO};
poolInfo.queueFamilyIndex = queueFamilyIndex;
if (vkCreateCommandPool(device, &poolInfo, nullptr, &m_pool) != VK_SUCCESS) {
MGLOG_W("Magma: GPU hang watch off - no command pool for its markers");
m_pool = VK_NULL_HANDLE;
return;
}
m_device = device;
{
const std::lock_guard<std::mutex> lock(m_mutex);
if (!AddSlot()) {
MGLOG_W("Magma: GPU hang watch off - the device cannot make its progress markers");
vkDestroyCommandPool(m_device, m_pool, nullptr);
m_pool = VK_NULL_HANDLE;
m_device = VK_NULL_HANDLE;
return;
}
}
m_watch = Watch::Register(this, &Sample, &OnHung);
MGLOG_I("Magma: GPU hang watch on - a submission the GPU started and has not finished after %u ms ends "
"its session",
Watch::BudgetMs());
}
void GpuProgressMarkers::Shutdown() {
// The watch first, outside m_mutex: Unregister waits out a sample in progress, which takes it.
Watch::Unregister(m_watch);
m_watch = 0;
if (m_device == VK_NULL_HANDLE) return;
const std::lock_guard<std::mutex> lock(m_mutex);
for (Slot& slot : m_slots) {
if (slot.Started != VK_NULL_HANDLE) vkDestroyEvent(m_device, slot.Started, nullptr);
if (slot.Finished != VK_NULL_HANDLE) vkDestroyEvent(m_device, slot.Finished, nullptr);
}
m_slots.clear();
if (m_pool != VK_NULL_HANDLE) vkDestroyCommandPool(m_device, m_pool, nullptr); // frees the buffers
m_pool = VK_NULL_HANDLE;
m_device = VK_NULL_HANDLE;
}
Bool GpuProgressMarkers::AddSlot() {
if (m_slots.size() >= kMaxSlots) return false;
Slot slot;
const VkEventCreateInfo eventInfo{VK_STRUCTURE_TYPE_EVENT_CREATE_INFO};
VkCommandBuffer buffers[2] = {VK_NULL_HANDLE, VK_NULL_HANDLE};
VkCommandBufferAllocateInfo allocInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO};
allocInfo.commandPool = m_pool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = 2;
const auto fail = [&] {
if (slot.Started != VK_NULL_HANDLE) vkDestroyEvent(m_device, slot.Started, nullptr);
if (slot.Finished != VK_NULL_HANDLE) vkDestroyEvent(m_device, slot.Finished, nullptr);
if (buffers[0] != VK_NULL_HANDLE) vkFreeCommandBuffers(m_device, m_pool, 2, buffers);
return false;
};
if (vkCreateEvent(m_device, &eventInfo, nullptr, &slot.Started) != VK_SUCCESS ||
vkCreateEvent(m_device, &eventInfo, nullptr, &slot.Finished) != VK_SUCCESS ||
vkAllocateCommandBuffers(m_device, &allocInfo, buffers) != VK_SUCCESS)
return fail();
// Prerecorded once and resubmitted for every submission the slot brackets; SIMULTANEOUS_USE
// because the slot is reused once its `finished` event is set, which can be a moment before
// the submission that set it formally leaves the pending state.
VkCommandBufferBeginInfo beginInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO};
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
if (vkBeginCommandBuffer(buffers[0], &beginInfo) != VK_SUCCESS) return fail();
vkCmdSetEvent(buffers[0], slot.Started, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
if (vkEndCommandBuffer(buffers[0]) != VK_SUCCESS) return fail();
if (vkBeginCommandBuffer(buffers[1], &beginInfo) != VK_SUCCESS) return fail();
vkCmdSetEvent(buffers[1], slot.Finished, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
if (vkEndCommandBuffer(buffers[1]) != VK_SUCCESS) return fail();
slot.Begin = buffers[0];
slot.End = buffers[1];
m_slots.push_back(slot);
return true;
}
GpuProgressMarkers::Bracket GpuProgressMarkers::Acquire() {
Bracket bracket;
if (m_device == VK_NULL_HANDLE) return bracket;
const std::lock_guard<std::mutex> lock(m_mutex);
if (m_lost) return bracket;
Slot* free = nullptr;
for (Slot& slot : m_slots) {
if (slot.Claimed) continue;
// Retire what finished since the watch last looked: frames come faster than its polls.
if (slot.InFlight && vkGetEventStatus(m_device, slot.Finished) == VK_EVENT_SET) slot.InFlight = false;
if (!slot.InFlight && free == nullptr) free = &slot;
}
if (free == nullptr) {
if (!AddSlot()) return bracket;
free = &m_slots.back();
}
if (free->Dirty) {
if (vkResetEvent(m_device, free->Started) != VK_SUCCESS ||
vkResetEvent(m_device, free->Finished) != VK_SUCCESS)
return bracket;
free->Dirty = false;
}
free->Claimed = true;
bracket.Begin = free->Begin;
bracket.End = free->End;
bracket.Slot = static_cast<Uint32>(free - m_slots.data());
return bracket;
}
void GpuProgressMarkers::Submitted(const Bracket& bracket) {
if (!bracket.Valid()) return;
const std::lock_guard<std::mutex> lock(m_mutex);
if (bracket.Slot >= m_slots.size()) return;
Slot& slot = m_slots[bracket.Slot];
slot.Claimed = false;
slot.InFlight = true;
slot.Dirty = true;
slot.Id = m_nextId++;
}
void GpuProgressMarkers::Abandon(const Bracket& bracket) {
if (!bracket.Valid()) return;
const std::lock_guard<std::mutex> lock(m_mutex);
if (bracket.Slot >= m_slots.size()) return;
// A failed vkQueueSubmit may still have consumed nothing or something: reset before reuse.
m_slots[bracket.Slot].Claimed = false;
m_slots[bracket.Slot].Dirty = true;
}
Bool GpuProgressMarkers::Sample(void* self, Vector<MG_Backend::GpuHangWatch::SubmissionProgress>& out) {
auto* markers = static_cast<GpuProgressMarkers*>(self);
const std::lock_guard<std::mutex> lock(markers->m_mutex);
if (markers->m_lost || markers->m_device == VK_NULL_HANDLE) return false;
for (Slot& slot : markers->m_slots) {
if (!slot.InFlight) continue;
const VkResult finished = vkGetEventStatus(markers->m_device, slot.Finished);
const VkResult started = vkGetEventStatus(markers->m_device, slot.Started);
if ((finished != VK_EVENT_SET && finished != VK_EVENT_RESET) ||
(started != VK_EVENT_SET && started != VK_EVENT_RESET)) {
// VK_ERROR_DEVICE_LOST: the driver already reset the device and says so itself.
markers->m_lost = true;
return false;
}
if (finished == VK_EVENT_SET) {
slot.InFlight = false;
continue;
}
out.push_back({slot.Id, started == VK_EVENT_SET, false});
}
return true;
}
void GpuProgressMarkers::OnHung(void* self, Uint64 submissionId, Uint64 runningMs) {
auto* markers = static_cast<GpuProgressMarkers*>(self);
markers->m_hungRunningMs.store(runningMs, std::memory_order_release);
markers->m_hung.store(true, std::memory_order_release);
MGLOG_E("Magma: submission %llu of this session's VkDevice has run %llu ms on the GPU and has not finished - "
"it is what stops the GPU for every process; the session ends at its next record and submits "
"nothing more (budget %u ms, MOBILEGL_GPU_HANG_BUDGET_MS)",
static_cast<unsigned long long>(submissionId), static_cast<unsigned long long>(runningMs),
MG_Backend::GpuHangWatch::BudgetMs());
}
VkResult GpuProgressMarkers::SubmitBracketed(VkQueue queue, VkSubmitInfo& info, VkFence fence,
const Bracket& bracket) {
constexpr Uint32 kMaxOwn = 6;
if (!bracket.Valid() || info.commandBufferCount == 0 || info.commandBufferCount > kMaxOwn)
return vkQueueSubmit(queue, 1, &info, fence);
VkCommandBuffer buffers[kMaxOwn + 2];
Uint32 count = 0;
buffers[count++] = bracket.Begin;
for (Uint32 i = 0; i < info.commandBufferCount; ++i) buffers[count++] = info.pCommandBuffers[i];
buffers[count++] = bracket.End;
const VkCommandBuffer* own = info.pCommandBuffers;
const Uint32 ownCount = info.commandBufferCount;
info.pCommandBuffers = buffers;
info.commandBufferCount = count;
const VkResult result = vkQueueSubmit(queue, 1, &info, fence);
info.pCommandBuffers = own;
info.commandBufferCount = ownCount;
return result;
}
} // namespace MobileGL::MG_Backend::DirectVulkan
@@ -1,95 +0,0 @@
// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/GpuProgressMarkers.h
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#pragma once
#include "../VkIncludes.h"
#include <Includes.h>
#include <MG_Backend/GpuHangWatch.h>
#include <atomic>
#include <mutex>
namespace MobileGL::MG_Backend::DirectVulkan {
// WHICH OF THIS DEVICE'S SUBMISSIONS THE GPU HAS STARTED, AND WHICH IT HAS FINISHED
// (GpuHangWatch.h says why that is the whole attribution of a GPU hang).
//
// A frame's submission is bracketed by two prerecorded one-command buffers: the first sets a
// `started` event at TOP_OF_PIPE, the last sets a `finished` event once everything before it in
// the queue has completed. The host reads both with vkGetEventStatus from the watch thread - no
// fence is shared with the renderer's own waits and resets. On Adreno 750 a submission whose
// fragment shader never ends reads started=SET from its first poll until the kernel resets the
// GPU, and a submission queued behind it reads started=RESET for the whole stall.
//
// The renderer's thread brackets submissions (Acquire / Submitted / Abandon) and asks Hung(); the
// watch thread samples. Everything Vulkan the two share - the events - is touched under m_mutex.
class GpuProgressMarkers {
public:
struct Bracket {
VkCommandBuffer Begin = VK_NULL_HANDLE;
VkCommandBuffer End = VK_NULL_HANDLE;
Uint32 Slot = ~0u;
Bool Valid() const { return Slot != ~0u; }
};
GpuProgressMarkers() = default;
~GpuProgressMarkers() { Shutdown(); }
GpuProgressMarkers(const GpuProgressMarkers&) = delete;
GpuProgressMarkers& operator=(const GpuProgressMarkers&) = delete;
// Off (no brackets, never hung) when the budget is 0 or the device cannot make events.
void Init(VkDevice device, Uint32 queueFamilyIndex);
// Before the device goes; its queue must be idle. Stops the watch first.
void Shutdown();
// The two buffers to put first and last in one submission (an invalid bracket when off or
// when every slot is in flight: the submission then goes unwatched).
Bracket Acquire();
// The submission carrying `bracket` was accepted by vkQueueSubmit / was not submitted.
void Submitted(const Bracket& bracket);
void Abandon(const Bracket& bracket);
// The watch named one of this device's submissions as hanging the GPU.
Bool Hung() const { return m_hung.load(std::memory_order_acquire); }
Uint64 HungRunningMs() const { return m_hungRunningMs.load(std::memory_order_acquire); }
Bool Active() const { return m_watch != 0; }
// vkQueueSubmit of `info` with `bracket` wrapped around its command buffers (which it puts
// back before returning). At most 6 buffers of the caller's.
static VkResult SubmitBracketed(VkQueue queue, VkSubmitInfo& info, VkFence fence, const Bracket& bracket);
private:
struct Slot {
VkEvent Started = VK_NULL_HANDLE;
VkEvent Finished = VK_NULL_HANDLE;
VkCommandBuffer Begin = VK_NULL_HANDLE;
VkCommandBuffer End = VK_NULL_HANDLE;
Uint64 Id = 0;
Bool InFlight = false; // submitted and not yet seen finished
Bool Claimed = false; // handed out by Acquire, not yet submitted or abandoned
Bool Dirty = false; // its events were set by a past submission: reset before reuse
};
static constexpr Uint32 kMaxSlots = 16;
Bool AddSlot();
static Bool Sample(void* self, Vector<MG_Backend::GpuHangWatch::SubmissionProgress>& out);
static void OnHung(void* self, Uint64 submissionId, Uint64 runningMs);
std::mutex m_mutex;
VkDevice m_device = VK_NULL_HANDLE;
VkCommandPool m_pool = VK_NULL_HANDLE;
Vector<Slot> m_slots;
Uint64 m_nextId = 1;
Uint64 m_watch = 0;
Bool m_lost = false;
std::atomic<Bool> m_hung{false};
std::atomic<Uint64> m_hungRunningMs{0};
};
} // namespace MobileGL::MG_Backend::DirectVulkan
@@ -391,15 +391,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
VkPipeline PipelineFactory::CreatePipeline(const PipelineCreatePayload& payload) const {
MOBILEGL_ASSERT(payload.stages != nullptr && !payload.stages->empty(), "PipelineFactory: stages are empty");
// The assert compiles out of shipping builds, and a program declined for an invalid
// module (VkProgramObject::invalidSpirvDeclined) has no stages at all: a caller that
// forgot to refuse it must get a skipped draw, not a stageCount=0 pipeline.
if (payload.stages == nullptr || payload.stages->empty()) {
MGLOG_E_ONCE("PipelineFactory::CreatePipeline: refusing a pipeline with no shader stages "
"(programHash=0x%llx); its draws are skipped",
static_cast<unsigned long long>(payload.programHash));
return VK_NULL_HANDLE;
}
MOBILEGL_ASSERT(payload.vertexInputState != nullptr, "PipelineFactory: vertexInputState is null");
MOBILEGL_ASSERT(payload.pipelineLayout != VK_NULL_HANDLE, "PipelineFactory: pipelineLayout is null");
MOBILEGL_ASSERT(payload.renderPass != VK_NULL_HANDLE, "PipelineFactory: renderPass is null");
@@ -12,9 +12,7 @@
#include "MG_Util/ShaderTranspiler/ShaderCompiler.h"
#include "MG_Util/ShaderTranspiler/SpvcSession.h"
#include "MG_Util/ShaderTranspiler/Types.h"
#include <Config.h>
#include <algorithm>
#include <atomic>
#include <bit>
#include <cmath>
#include <cstring>
@@ -2275,84 +2273,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
return false;
}
}
// ScreenModuleForDriver's memory. Keyed by content, never by program: the same bytes get
// the same answer whichever program, variant or session carries them.
struct DriverModuleVerdictCache {
struct Entry {
Uint64 wordCount = 0;
Bool valid = true;
String reason;
};
// Generous for any one application's distinct stage modules; past it the whole table
// is dropped rather than tracked per entry - a re-validation is the only cost.
static constexpr SizeT kMaxEntries = 8192;
std::mutex mutex;
UnorderedMap<Uint64, Entry> entries;
std::atomic<Uint64> validatorRuns{0};
};
DriverModuleVerdictCache& GetDriverModuleVerdictCache() {
// Leaked on purpose: screened from session threads that may outlive static destruction.
static auto* cache = new DriverModuleVerdictCache();
return *cache;
}
} // namespace
ProgramFactory::DriverModuleVerdict ProgramFactory::ScreenModuleForDriver(const Vector<Uint>& spirv,
Bool allowInvalid, String* outReason) {
if (outReason != nullptr) outReason->clear();
if (spirv.empty()) return DriverModuleVerdict::Valid;
auto& cache = GetDriverModuleVerdictCache();
const Uint64 key = XXH64(spirv.data(), spirv.size() * sizeof(Uint), 0);
Bool valid = true;
String reason;
Bool known = false;
{
const std::lock_guard<std::mutex> lock(cache.mutex);
const auto it = cache.entries.find(key);
if (it != cache.entries.end() && it->second.wordCount == spirv.size()) {
known = true;
valid = it->second.valid;
reason = it->second.reason;
}
}
if (!known) {
// Outside the lock: two threads screening the same new module both validate, and
// agree; nothing waits on another session's spirv-val.
MG_Util::ShaderTranspiler::ShaderCompiler::PrepareSpirvValidation();
cache.validatorRuns.fetch_add(1, std::memory_order_relaxed);
spv_context context = spvContextCreate(GetSpirvTargetEnv(spirv));
spv_validator_options options = spvValidatorOptionsCreate();
spvValidatorOptionsSetFriendlyNames(options, true);
spv_const_binary_t binary = {spirv.data(), spirv.size()};
spv_diagnostic diagnostic = nullptr;
const spv_result_t result = spvValidateWithOptions(context, options, &binary, &diagnostic);
valid = result == SPV_SUCCESS;
if (!valid) {
reason = diagnostic != nullptr && diagnostic->error != nullptr ? diagnostic->error : "<no diagnostic>";
// The process-wide counter the validating test lanes assert on.
MG_Util::ShaderTranspiler::ShaderCompiler::NoteSpirvValidationFailure();
}
spvDiagnosticDestroy(diagnostic);
spvValidatorOptionsDestroy(options);
spvContextDestroy(context);
const std::lock_guard<std::mutex> lock(cache.mutex);
if (cache.entries.size() >= DriverModuleVerdictCache::kMaxEntries) cache.entries.clear();
cache.entries[key] = DriverModuleVerdictCache::Entry{spirv.size(), valid, reason};
}
if (valid) return DriverModuleVerdict::Valid;
if (outReason != nullptr) *outReason = Move(reason);
return allowInvalid ? DriverModuleVerdict::AdmittedInvalid : DriverModuleVerdict::DeclinedInvalid;
}
Uint64 ProgramFactory::DriverModuleValidatorRuns() {
return GetDriverModuleVerdictCache().validatorRuns.load(std::memory_order_relaxed);
}
// A shader that assigns gl_FragDepth (SPIR-V DepthReplacing) supplies depth itself
// instead of taking the pipeline's interpolated Z, so a driver that varies the vertex
// position math between pipelines cannot desynchronize it; the blended depth-write
@@ -3892,42 +3814,27 @@ namespace MobileGL::MG_Backend::DirectVulkan {
const Bool remapOk = RemapDescriptorBindingsForVulkan(moduleSpirvs, m_maxBindings, moduleSpirvs);
MOBILEGL_ASSERT(remapOk, "ProgramFactory::GetOrCreateProgram: descriptor binding remap failed");
// Last look at the exact bytes the driver receives, in EVERY build rather than only in
// DEBUG or with MOBILEGL_ENABLE_SPIRV_VALIDATION armed, and for every stage BEFORE any
// module is created. By here the descriptor bindings have been remapped and the layout
// about to be reflected describes the remapped module, so there is no module left that
// is both valid and consistent with it to fall back to (the recovery that exists lives
// one step earlier, at the clip/XFB fixups). What is left is to keep the bytes away from
// the driver: a driver is not a validating entry point, and an invalid module it accepts
// can fault the GPU into device loss (a frontend translation once put a sampler inside
// the default uniform block, and Adreno page-faulted reading its "descriptor" out of
// uniform-buffer bytes). One invalid stage declines the whole program: no shader module
// of it is created, and every draw or dispatch of it is refused by name
// (VkProgramObject::invalidSpirvDeclined). MOBILEGL_MAGMA_ALLOW_INVALID_SPIRV hands the
// bytes over anyway, for diagnosing a driver that copes.
for (SizeT i = 0; i < moduleCount; ++i) {
String reason;
const DriverModuleVerdict verdict = ScreenModuleForDriver(
moduleSpirvs[i], MG_Config::Features.MagmaAllowInvalidSpirv, &reason);
if (verdict == DriverModuleVerdict::DeclinedInvalid) {
MGLOG_E_ONCE("ProgramFactory: declining program %u - its stage %d module fails SPIR-V validation (%s); "
"no shader module is created and its draws are refused. "
"MOBILEGL_MAGMA_ALLOW_INVALID_SPIRV=1 hands such modules to the driver anyway.",
program.GetExternalIndex(), static_cast<Int>(stages[i]), reason.c_str());
entry.invalidSpirvDeclined = true;
break;
}
if (verdict == DriverModuleVerdict::AdmittedInvalid) {
MGLOG_E_ONCE("ProgramFactory: handing vkCreateShaderModule an INVALID module for program %u stage %d "
"because MOBILEGL_MAGMA_ALLOW_INVALID_SPIRV is set (%s)",
program.GetExternalIndex(), static_cast<Int>(stages[i]), reason.c_str());
}
}
for (SizeT i = 0; i < moduleCount && !entry.invalidSpirvDeclined; ++i) {
auto& moduleSpv = moduleSpirvs[i];
if (moduleSpv.empty()) continue;
// Last look at the exact bytes the driver receives, in EVERY build rather than only
// in DEBUG or with MOBILEGL_ENABLE_SPIRV_VALIDATION armed. This one only reports:
// by here the descriptor bindings have been remapped and the layout about to be
// reflected describes the remapped module, so there is no module left that is both
// valid and consistent with it to fall back to. The recovery lives one step earlier,
// at the clip/XFB fixups (see the revert there) - which is where a transform can
// introduce a reference to a delisted interface variable, the failure this whole
// guard exists for. Anything that reaches this line names itself in the log of a
// shipping build instead of dying anonymously inside the driver.
SpirvValidationFailure finalFailure{};
if (!ValidateTransformedSpirv(moduleSpv, stages[i], program.GetExternalIndex(), &finalFailure)) {
MGLOG_E_ONCE("ProgramFactory: handing vkCreateShaderModule an INVALID module for program %u stage %d - "
"a backend transform after the clip/XFB fixups broke it (%s)",
program.GetExternalIndex(), static_cast<Int>(stages[i]),
finalFailure.message.c_str());
}
// Does the stage the driver will treat as the last pre-rasterization one actually
// carry Xfb? Asked of the FINAL bytes, so it answers for whatever the whole transform
// chain produced - a rewound clip/XFB backstop, a capture pass that resolved no
@@ -229,11 +229,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
// the cache entry, so every later draw of the same program variant reads the same
// answer instead of re-deciding it.
Bool pointSizeCapabilityUnsupported = false;
// One of the program's final modules fails SPIR-V validation, so none of its modules
// was created and every draw or dispatch of it is refused by name (the ProgramInvalidSpirv /
// ComputeProgramInvalidSpirv wire declines) - see ProgramFactory::ScreenModuleForDriver.
// Sticky like the flag above: it lives on the cache entry, so the one log line is honest.
Bool invalidSpirvDeclined = false;
Bool needsPassthroughTessControl = false;
// ...and the pass-through this renderer can synthesize carries gl_Position and
// nothing else, so it is only correct when the evaluation stage's inputs are
@@ -294,11 +289,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
storageBlockIndexByBinding = std::move(other.storageBlockIndexByBinding);
hasStorageImages = other.hasStorageImages;
declinedDescriptors = other.declinedDescriptors;
// The three refusal flags travel like every other field: a robin-hood insert swaps
// entries, and a flag left behind would refuse (or admit) the wrong program.
invalidSpirvDeclined = other.invalidSpirvDeclined;
xfbCaptureDeclined = other.xfbCaptureDeclined;
pointSizeCapabilityUnsupported = other.pointSizeCapabilityUnsupported;
globalUboBinding = other.globalUboBinding;
activeVertexInputLocationMask = other.activeVertexInputLocationMask;
vertexInputTypes = other.vertexInputTypes;
@@ -320,9 +310,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
other.pipelineLayout = VK_NULL_HANDLE;
other.hasStorageImages = false;
other.declinedDescriptors = false;
other.invalidSpirvDeclined = false;
other.xfbCaptureDeclined = false;
other.pointSizeCapabilityUnsupported = false;
other.globalUboBinding = -1;
other.activeVertexInputLocationMask = 0;
other.activeFragmentOutputLocationMask = 0;
@@ -366,11 +353,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
storageBlockIndexByBinding = std::move(other.storageBlockIndexByBinding);
hasStorageImages = other.hasStorageImages;
declinedDescriptors = other.declinedDescriptors;
// The three refusal flags travel like every other field: a robin-hood insert swaps
// entries, and a flag left behind would refuse (or admit) the wrong program.
invalidSpirvDeclined = other.invalidSpirvDeclined;
xfbCaptureDeclined = other.xfbCaptureDeclined;
pointSizeCapabilityUnsupported = other.pointSizeCapabilityUnsupported;
globalUboBinding = other.globalUboBinding;
activeVertexInputLocationMask = other.activeVertexInputLocationMask;
vertexInputTypes = other.vertexInputTypes;
@@ -392,9 +374,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
other.pipelineLayout = VK_NULL_HANDLE;
other.hasStorageImages = false;
other.declinedDescriptors = false;
other.invalidSpirvDeclined = false;
other.xfbCaptureDeclined = false;
other.pointSizeCapabilityUnsupported = false;
other.globalUboBinding = -1;
other.activeVertexInputLocationMask = 0;
other.activeFragmentOutputLocationMask = 0;
@@ -525,29 +504,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
// VkRenderPassManager::OnPresent's sweep.
void OnFrameBoundary();
// What the last look at a module's final bytes - the exact words vkCreateShaderModule
// would receive - decided.
enum class DriverModuleVerdict : Uint8 {
Valid, // validates: handed to the driver
DeclinedInvalid, // fails validation: never handed over, the program's work is declined
AdmittedInvalid, // fails validation, handed over anyway (MOBILEGL_MAGMA_ALLOW_INVALID_SPIRV)
};
// Validates `spirv` for the Vulkan environment its version word names and turns the
// result into a verdict. A driver is not a validating entry point: Adreno page-faulted
// into device loss on a module that carried a sampler inside a uniform block, Mali
// SIGSEGVs inside pipeline creation. So an invalid module is declined unless
// `allowInvalid` (the escape hatch) says to hand it over regardless.
//
// The validator's answer is remembered per module content (64-bit hash plus word count),
// process-wide: a program variant, an evicted-then-rebuilt entry and two programs that
// share a stage all re-screen the same bytes, and only the first pays for spirv-val.
// `outReason` receives the validator's message for an invalid module.
static DriverModuleVerdict ScreenModuleForDriver(const Vector<Uint>& spirv, Bool allowInvalid,
String* outReason = nullptr);
// How many times ScreenModuleForDriver actually ran the validator (cache misses), for
// the tests that pin the cache.
static Uint64 DriverModuleValidatorRuns();
static VkShaderStageFlagBits ToVkStage(ShaderStage stage);
static VkFormat ConvertSpirvImageFormatToVkFormat(SpvImageFormat format);
static SamplerNumericDomain UniformTypeToSamplerNumericDomain(GLenum glType);
@@ -8,7 +8,6 @@
#include "VulkanRenderer.h"
#include "SubmitFencePrefix.h"
#include "MG_Util/X11/DisplayGuard.h"
#include "OffscreenSurfaceRoute.h"
#include "MG_Backend/DirectVulkan/SubgroupSupportPolicy.h"
@@ -3275,9 +3274,6 @@ void main() {
CreateAllocator();
CreateCommandPool();
#if MOBILEGL_BUILD_DISAGGREGATED
m_progressMarkers.Init(m_device, m_physicalDevice.queueFamilies.graphicsFamily);
#endif
// Frames-in-flight is a request, not a guarantee: it also seeds the swapchain image
// count (SwapchainObject clamps the hint into [minImageCount, maxImageCount]). Not every
@@ -3507,9 +3503,6 @@ void main() {
if (m_device != VK_NULL_HANDLE) {
VK_VERIFY(vkDeviceWaitIdle(m_device));
}
#if MOBILEGL_BUILD_DISAGGREGATED
m_progressMarkers.Shutdown();
#endif
// Parked surface targets (ActivateSurfaceTarget) go before the device and instance.
for (auto& [_, target] : m_parkedTargets) DestroyParkedTarget(target);
m_parkedTargets.clear();
@@ -3517,10 +3510,6 @@ void main() {
// P7 wave 2 package B3: the session's decline tally. Silent when nothing declined, so a
// green lane stays quiet and a lane that dropped a draw cannot (rule I's observable).
WireDeclineTally::Dump("shutdown");
// The SPIR-V screen's engagement proof: a decline-free session above reads as "screened
// and valid" only with this count beside it (distinct modules, process-wide).
MGLOG_I("MGWIRE-SPIRV-SCREEN[shutdown] modulesValidated=%llu",
static_cast<unsigned long long>(ProgramFactory::DriverModuleValidatorRuns()));
DestroyWireDrawPass();
CollectWireObjects(m_submitCounter, true);
ClearAllWireDrawPassCaches();
@@ -6846,7 +6835,7 @@ void main() {
// A refused program cannot reach here today - the full path refuses before it ever
// records a snapshot - but declining the fast path costs one compare and means the
// refusal does not depend on that ordering staying true.
if (programObj.pointSizeCapabilityUnsupported || programObj.invalidSpirvDeclined) {
if (programObj.pointSizeCapabilityUnsupported) {
return false;
}
@@ -7329,7 +7318,7 @@ void main() {
// The build already said why, once, naming the program and the stage. Refusing here -
// before any pipeline is built from it - is what makes that message a decline rather
// than a note attached to invalid usage the driver still receives.
if (programObj.pointSizeCapabilityUnsupported || programObj.invalidSpirvDeclined) {
if (programObj.pointSizeCapabilityUnsupported) {
return false;
}
// For the snapshot's memoised entry pointer: if anything below inserts into the
@@ -7789,8 +7778,6 @@ void main() {
}
ProgramFactory::CompileOptionFlags transformFlags = 0;
const auto& programObj = m_programFactory->GetOrCreateProgram(program, transformFlags);
// No shader module of a program that failed validation exists; the build said why, once.
if (programObj.invalidSpirvDeclined) return;
if (!frame.isCommandRecording) {
m_frameContext.BeginCommandRecording();
@@ -7853,8 +7840,6 @@ void main() {
}
ProgramFactory::CompileOptionFlags transformFlags = 0;
const auto& programObj = m_programFactory->GetOrCreateProgram(program, transformFlags);
// No shader module of a program that failed validation exists; the build said why, once.
if (programObj.invalidSpirvDeclined) return;
if (!frame.isCommandRecording) {
m_frameContext.BeginCommandRecording();
@@ -14179,16 +14164,10 @@ void main() {
submitInfo.pCommandBuffers = commandBuffers;
#if MOBILEGL_BUILD_DISAGGREGATED
// Shared-image fences staged for the work recorded since the last submission.
if (LatchIfGpuHung("flush-submit")) return false;
SharedImageSubmitSync sharedImageSync;
AttachSharedImageSync(submitInfo, sharedImageSync);
const GpuProgressMarkers::Bracket bracket = m_progressMarkers.Acquire();
const VkResult result = GpuProgressMarkers::SubmitBracketed(m_graphicsQueue, submitInfo, fence, bracket);
if (result == VK_SUCCESS) m_progressMarkers.Submitted(bracket);
else m_progressMarkers.Abandon(bracket);
#else
const VkResult result = vkQueueSubmit(m_graphicsQueue, 1, &submitInfo, fence);
#endif
const VkResult result = vkQueueSubmit(m_graphicsQueue, 1, &submitInfo, fence);
if (result != VK_SUCCESS) {
NoteDeviceLoss(result, "SubmitPendingCommandBuffer vkQueueSubmit");
MGLOG_E_ONCE("SubmitPendingCommandBuffer: vkQueueSubmit returned %d", result);
@@ -14319,31 +14298,6 @@ void main() {
}
return true;
}
Bool VulkanRenderer::LatchIfGpuHung(const char* site) {
if (!m_progressMarkers.Hung()) return false;
if (!m_deviceLost) {
// NOT LOST TO THE DRIVER: a submission that a failed preemption leaves running is reset
// without a device loss, and the next one would stop the GPU again. Treated as lost from
// here on - nothing more is submitted - and the session ends as one whose device was.
m_deviceLost = true;
MGLOG_E("DirectVulkan: the GPU hang watch named this session's VkDevice (a submission ran %llu ms "
"without finishing, at %s); the device is treated as LOST and nothing more is submitted",
static_cast<unsigned long long>(m_progressMarkers.HungRunningMs()),
site != nullptr ? site : "?");
}
// Where no session latch is armed (no served session) the device only stays "lost".
if (!m_deviceLossLatched && MG_Pipe::MGPipeSessionLatchArmed()) {
m_deviceLossLatched = true;
(void)MG_Pipe::MGPipeSessionLatch(MG_Pipe::MGPipeFatalFamily::DeviceLost,
"MGPipe: Fatal{BackendDeviceLost, \"Magma:gpu-hang:%s\"} - this "
"session's GPU work ran past the hang budget and stopped the GPU for "
"every process; the session ends and its client reads a lost context, "
"every other session keeps running",
site != nullptr ? site : "?");
}
return true;
}
#endif
Bool VulkanRenderer::FlushForSyncPoint(Uint64 submitIndex) {
@@ -14693,17 +14647,10 @@ void main() {
}
auto submitPacket = m_frameContext.GetSubmitInfo(shouldSubmitCommandBuffer, m_imageIndexAcquired);
#if MOBILEGL_BUILD_DISAGGREGATED
if (LatchIfGpuHung("present-submit")) return;
SharedImageSubmitSync sharedImageSync;
AttachSharedImageSync(submitPacket.submitInfo, sharedImageSync);
const GpuProgressMarkers::Bracket bracket = m_progressMarkers.Acquire();
const VkResult presentSubmit = GpuProgressMarkers::SubmitBracketed(m_graphicsQueue, submitPacket.submitInfo,
frame.imageInFlightFence, bracket);
if (presentSubmit == VK_SUCCESS) m_progressMarkers.Submitted(bracket);
else m_progressMarkers.Abandon(bracket);
#else
const VkResult presentSubmit = vkQueueSubmit(m_graphicsQueue, 1, &submitPacket.submitInfo, frame.imageInFlightFence);
#endif
const VkResult presentSubmit = vkQueueSubmit(m_graphicsQueue, 1, &submitPacket.submitInfo, frame.imageInFlightFence);
NoteDeviceLoss(presentSubmit, "Present vkQueueSubmit");
#if MOBILEGL_BUILD_DISAGGREGATED
if (presentSubmit != VK_SUCCESS && LatchWireDeviceLoss("present-submit")) return;
@@ -16765,10 +16712,7 @@ void main() {
}
const char* displayName = std::getenv("DISPLAY");
// Never the display this process serves (MG_Util/X11/DisplayGuard.h).
auto* display = displayName != nullptr && MG_Util::X11::MayDialX11Display(displayName)
? xOpenDisplay(displayName)
: nullptr;
auto* display = xOpenDisplay(displayName);
if (display == nullptr) {
MGLOG_F("XOpenDisplay(%s) failed while creating a Vulkan Xlib window surface; there is no usable X "
"display for the requested window surface",
@@ -23,7 +23,6 @@
#include "VkTextureManager.h"
#include "VkTimerQueryManager.h"
#if MOBILEGL_BUILD_DISAGGREGATED
#include "GpuProgressMarkers.h"
#include "WireRenderPassCompatibility.h"
#include <MG_Remote/Server/SharedImageRegistry.h>
#endif
@@ -192,15 +191,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
// renderer has written before - the rest of it is left as it is; a first write, a scaled
// or turned copy copies all of it.
Bool BlitDefaultFramebufferToSharedImage(const SharedImageView& image, const MG_Util::Damage::Region& region);
// IMPLICIT SYNC BY FLUSH (BackendObject::PublishSharedImageAccesses): every image acquired
// since the last boundary goes back to the foreign family, the recording is submitted with
// the exportable semaphore, and its sync_file is published to each as a write and a read.
// From then on an image's first acquire per frame also waits for its pending reads.
Bool PublishSharedImageAccesses();
// EGL_ANDROID_native_fence_sync's fence command (BackendObject::ExportNativeFence): the
// submission's sync_file in `*fence` (-1: none, and the work is waited out here), and - for
// a session that writes images - the boundary PublishSharedImageAccesses makes.
Bool ExportNativeFence(int* fence);
// EGL_BUFFER_AGE_EXT of the active target's default framebuffer for the next frame: the age
// of the swapchain image acquired for it (SwapchainObject::BufferAgeOf). Asking makes the
// target keep its presented images' content from then on.
@@ -409,11 +399,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
// without recording or submitting anything more. False: an ordinary failure, the site
// keeps the death it had. `site` names it in the latch line.
Bool LatchWireDeviceLoss(const char* site);
// THE GPU HANG WATCH (GpuProgressMarkers.h): true once the watch named one of this device's
// submissions as the one that stops the GPU. The device is then treated as lost, this session
// is latched, and the caller returns from its verb without submitting anything more. Asked
// before every frame submission and by the apply loop before it applies another record.
Bool LatchIfGpuHung(const char* site);
#endif
// Flush gated on usefulness: only flushes when `submitIndex` is still
// unsubmitted, so poll loops on already-submitted fences do not split
@@ -632,8 +617,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
Bool m_deviceLost = false;
Bool m_deviceLossLatched = false;
#if MOBILEGL_BUILD_DISAGGREGATED
// Brackets this device's frame submissions for the GPU hang watch (LatchIfGpuHung).
GpuProgressMarkers m_progressMarkers;
struct WireImage {
VkImage image = VK_NULL_HANDLE;
VkFormat format = VK_FORMAT_UNDEFINED;
@@ -738,11 +721,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
// m_sharedImageSyncFd: the device imports and exports SYNC_FD binary semaphores; without
// it the waits happen on the CPU and nothing is exported (see WireSharedImage.inc).
Bool m_sharedImageSyncFd = false;
// The session writes images - it ends frames at publishing flushes
// (PublishSharedImageAccesses), or it reached one through a framebuffer (ResolveWireImage):
// a first acquire waits for the image's pending reads as well, and its boundaries publish
// what it used as written.
Bool m_sharedImageImplicitSync = false;
PFN_vkImportSemaphoreFdKHR m_importSemaphoreFd = nullptr;
PFN_vkGetSemaphoreFdKHR m_getSemaphoreFd = nullptr;
struct SharedImageWait {
@@ -126,11 +126,3 @@ MGL_WIRE_DECLINE(MipmapDepthStencilAspect)
// is missing, or the three group-count words lie outside it or are misaligned.
MGL_WIRE_DECLINE(DispatchIndirectBufferUnbound)
MGL_WIRE_DECLINE(DispatchIndirectRange)
// ---- ProgramFactory::ScreenModuleForDriver ------------------------------------------------
// One of the bound program's final modules fails SPIR-V validation, so no shader module of it was
// created (VkProgramObject::invalidSpirvDeclined): SetupWireDraw refuses the draw, and the two
// dispatch arms the dispatch. A driver handed the module could fault the GPU into device loss.
// MOBILEGL_MAGMA_ALLOW_INVALID_SPIRV=1 builds the module anyway, and then neither row moves.
MGL_WIRE_DECLINE(ProgramInvalidSpirv)
MGL_WIRE_DECLINE(ComputeProgramInvalidSpirv)
@@ -230,10 +230,6 @@
flags |= ProgramFactory::CompileOptionBit::ZeroBaseVertex;
programObject = &m_programFactory->GetOrCreateProgram(program, flags);
}
if (programObject->invalidSpirvDeclined) {
MGL_WIRE_DECLINE_AT(ProgramInvalidSpirv, "a module of the program fails SPIR-V validation and was never built");
return false;
}
if (programObject->pointSizeCapabilityUnsupported) {
MGL_WIRE_DECLINE_AT(PointSizeCapability, "the program writes gl_PointSize and the device cannot express it");
return false;
@@ -779,10 +775,6 @@
return;
}
const auto& programObj = m_programFactory->GetOrCreateProgram(program, {});
if (programObj.invalidSpirvDeclined) {
MGL_WIRE_DECLINE_AT(ComputeProgramInvalidSpirv, "a module of the compute program fails SPIR-V validation and was never built");
return;
}
if (!m_uniformManager->PrepareWireTextureResources(program, programObj)) {
MGL_WIRE_DECLINE_AT(ComputeTextureResourcesUnprepared, "a sampled/storage image could not be made ready for the dispatch");
return;
@@ -855,10 +847,6 @@
return;
}
const auto& programObj = m_programFactory->GetOrCreateProgram(program, {});
if (programObj.invalidSpirvDeclined) {
MGL_WIRE_DECLINE_AT(ComputeProgramInvalidSpirv, "a module of the compute program fails SPIR-V validation and was never built");
return;
}
if (!m_uniformManager->PrepareWireTextureResources(program, programObj)) {
MGL_WIRE_DECLINE_AT(ComputeTextureResourcesUnprepared, "a sampled/storage image could not be made ready for the dispatch");
return;
@@ -161,12 +161,7 @@
auto* resource = m_textureManager->SyncTextureResourceByHandle(out.storage, renderbuffer);
if (!resource) MagmaWireFatal("framebuffer-resource");
// Another session writes it: acquired (WireSharedImage.inc) before the layout is read below.
// An image reached through a framebuffer is one this session renders into (or copies
// through), which makes it a writer of images from now on.
if (resource->sharedImageId != 0) {
m_sharedImageImplicitSync = true;
AcquireSharedImage(*resource);
}
if (resource->sharedImageId != 0) AcquireSharedImage(*resource);
out.image = resource->image;
out.format = viewFormat != VK_FORMAT_UNDEFINED ? viewFormat : resource->format;
out.extent = {std::max(resource->extent.width >> level, 1u),
@@ -517,11 +517,6 @@
// The write's fence gates the submission carrying the acquire: this recording's, or an
// earlier one if a flush takes it first - either way ahead of every later command.
StageSharedImageWait(fence, kSharedImageUseStages);
// A session that writes images (implicit sync by flush) may be about to overwrite what
// another session still samples: those reads go first.
if (m_sharedImageImplicitSync && !resource.sharedImageHeld) {
for (const int read : SI::DupPendingReadFences(*image)) StageSharedImageWait(read, kSharedImageUseStages);
}
const Uint32 family = static_cast<Uint32>(m_physicalDevice.queueFamilies.graphicsFamily);
VkImageMemoryBarrier barrier{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
@@ -600,72 +595,6 @@
static_cast<Uint32>(releases.size()), releases.data());
}
Bool VulkanRenderer::PublishSharedImageAccesses() {
m_sharedImageImplicitSync = true;
if (m_sharedImageReads.Pending() == 0 && m_sharedImagesHeld.empty()) return true;
ReleaseHeldSharedImages();
if (m_sharedImageSyncFd && m_sharedImageSignal == VK_NULL_HANDLE)
m_sharedImageSignal = TakeSharedImageSemaphore(/*exportable=*/true);
m_sharedImageSignalSubmitted = VK_NULL_HANDLE;
if (!FlushPendingCommands()) {
MGLOG_E_ONCE("Magma: a flush's shared-image accesses could not be submitted");
m_sharedImageReads.PublishFrame(-1); // drops the references; nothing to order against
return false;
}
const VkSemaphore signal = std::exchange(m_sharedImageSignalSubmitted, VK_NULL_HANDLE);
int fence = -1;
if (signal == VK_NULL_HANDLE || !ExportSharedImageSignal(signal, fence)) {
// No fence came out of it: the submission is waited for and published as completed.
fence = -1;
if (!WaitForSubmitsUpTo(m_submitCounter, UINT64_MAX)) {
MGLOG_E_ONCE("Magma: a flush's shared-image accesses could not be waited for");
}
}
m_sharedImageReads.PublishFrameAsWrite(fence);
return true;
}
// THE NATIVE FENCE. A sync_file of everything the session submitted so far, for the client's
// EGL_ANDROID_native_fence_sync: the application hands the descriptor on (Chrome's GPU process,
// to the browser that commits the buffer), so it has to signal no earlier than the last of that
// work. With nothing recorded, an empty
// recording is submitted to carry the signal: the in-order queue runs it after every earlier
// submission, and it is tracked like any other (the semaphore's reuse waits for it).
Bool VulkanRenderer::ExportNativeFence(int* fence) {
*fence = -1;
if (m_device == VK_NULL_HANDLE || m_graphicsQueue == VK_NULL_HANDLE || m_frameContext.GetFrameCount() == 0)
return true; // nothing was ever submitted: nothing to fence
// A session that writes images ends its frame here, as at a flush; a compositor that only
// samples them keeps its reads for its present, which follows the fence's work anyway.
const Bool boundary = m_sharedImageImplicitSync;
if (boundary) ReleaseHeldSharedImages();
if (m_sharedImageSyncFd && m_sharedImageSignal == VK_NULL_HANDLE)
m_sharedImageSignal = TakeSharedImageSemaphore(/*exportable=*/true);
m_sharedImageSignalSubmitted = VK_NULL_HANDLE;
if (!HasPendingRecordedWork() && m_sharedImageSignal != VK_NULL_HANDLE)
m_frameContext.BeginCommandRecording();
const Bool submitted = HasPendingRecordedWork() && FlushPendingCommands();
if (HasPendingRecordedWork()) MGLOG_E_ONCE("Magma: a native fence's commands could not be submitted");
const VkSemaphore signal =
submitted ? std::exchange(m_sharedImageSignalSubmitted, VK_NULL_HANDLE) : VK_NULL_HANDLE;
int exported = -1;
if (signal == VK_NULL_HANDLE || !ExportSharedImageSignal(signal, exported)) exported = -1;
if (exported < 0) {
// No descriptor: the work is waited out, so the caller may report it completed.
if (!WaitForSubmitsUpTo(m_submitCounter, UINT64_MAX))
MGLOG_E_ONCE("Magma: a native fence's work could not be waited for");
}
if (boundary && m_sharedImageReads.Pending() != 0) {
int published = -1;
#if !defined(_WIN32)
if (exported >= 0) published = ::dup(exported);
#endif
m_sharedImageReads.PublishFrameAsWrite(published);
}
*fence = exported;
return true;
}
void VulkanRenderer::PublishSharedImageReads() {
const VkSemaphore signal = std::exchange(m_sharedImageSignalSubmitted, VK_NULL_HANDLE);
int fence = -1;
@@ -678,11 +607,7 @@
}
// No fence (no export on this device): the frame's reads go unpublished - the file
// comment says why that is the choice.
// A session that writes images publishes every boundary as a write (PublishSharedImageAccesses).
if (m_sharedImageImplicitSync)
m_sharedImageReads.PublishFrameAsWrite(fence);
else
m_sharedImageReads.PublishFrame(fence);
m_sharedImageReads.PublishFrame(fence);
}
void VulkanRenderer::AbandonSharedImageReads() {
-184
View File
@@ -1,184 +0,0 @@
// MobileGL - MobileGL/MG_Backend/GpuHangWatch.cpp
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#include "GpuHangWatch.h"
#include <MG_Util/Debug/Log.h>
#include <algorithm>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <cstdlib>
#include <thread>
#if defined(__ANDROID__)
#include <sys/system_properties.h>
#endif
#if defined(__linux__) || defined(__ANDROID__)
#include <pthread.h>
#endif
namespace MobileGL::MG_Backend::GpuHangWatch {
namespace {
constexpr Uint32 kDefaultPollMs = 250;
std::atomic<Uint32> g_pollOverrideMs{0};
std::atomic<Uint32> g_budgetOverrideMs{0};
std::atomic<Bool> g_budgetOverridden{false};
Uint64 NowMs() {
return static_cast<Uint64>(std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count());
}
Uint32 ReadBudgetMs() {
const char* value = std::getenv("MOBILEGL_GPU_HANG_BUDGET_MS");
#if defined(__ANDROID__)
char property[PROP_VALUE_MAX] = {};
if (value == nullptr && __system_property_get("debug.mobilegl.gpu_hang_budget_ms", property) > 0)
value = property;
#endif
if (value == nullptr || *value == '\0') return kDefaultBudgetMs;
char* end = nullptr;
const unsigned long parsed = std::strtoul(value, &end, 10);
if (end == value) return kDefaultBudgetMs;
return static_cast<Uint32>(std::min<unsigned long>(parsed, 600000ul));
}
struct Entry {
Uint64 Handle = 0;
void* Self = nullptr;
SampleFn Sample = nullptr;
HungFn Hung = nullptr;
Detector Decide{0};
Bool Done = false; // named a hang, or its device is gone: never sampled again
};
// Leaked at exit, with its thread: the watch holds no GPU object of its own, and a backend
// unregisters before it destroys what its sampler reads.
struct Watch {
std::mutex Mutex;
std::condition_variable Wake;
Vector<Entry> Entries;
Uint64 NextHandle = 1;
Bool ThreadStarted = false;
};
Watch& TheWatch() {
static Watch& watch = *new Watch();
return watch;
}
void PollOnce(Watch& watch) {
const Uint64 now = NowMs();
Vector<SubmissionProgress> sample;
for (Entry& entry : watch.Entries) {
if (entry.Done) continue;
sample.clear();
if (!entry.Sample(entry.Self, sample)) {
entry.Done = true;
continue;
}
const Uint64 hung = entry.Decide.Observe(sample, now);
if (hung == 0) continue;
entry.Done = true;
entry.Hung(entry.Self, hung, entry.Decide.RunningMs(hung, now));
}
}
void WatchThreadMain() {
#if defined(__linux__) || defined(__ANDROID__)
pthread_setname_np(pthread_self(), "mgl-gpu-watch");
#endif
Watch& watch = TheWatch();
std::unique_lock<std::mutex> lock(watch.Mutex);
for (;;) {
watch.Wake.wait_for(lock, std::chrono::milliseconds(PollIntervalMs()));
PollOnce(watch);
}
}
} // namespace
Uint32 BudgetMs() {
if (g_budgetOverridden.load(std::memory_order_acquire)) return g_budgetOverrideMs.load(std::memory_order_acquire);
static const Uint32 budget = ReadBudgetMs();
return budget;
}
Uint32 PollIntervalMs() {
const Uint32 overrideMs = g_pollOverrideMs.load(std::memory_order_acquire);
return overrideMs != 0 ? overrideMs : kDefaultPollMs;
}
void SetPollIntervalForTesting(Uint32 ms) { g_pollOverrideMs.store(ms, std::memory_order_release); }
void SetBudgetForTesting(Uint32 ms) {
g_budgetOverrideMs.store(ms, std::memory_order_release);
g_budgetOverridden.store(ms != 0, std::memory_order_release);
}
Uint64 Detector::Observe(const Vector<SubmissionProgress>& sample, Uint64 nowMs) {
Vector<Running> still;
still.reserve(sample.size());
Uint64 named = 0;
for (const SubmissionProgress& progress : sample) {
if (!progress.Started || progress.Finished) continue;
Uint64 since = nowMs;
for (const Running& seen : m_running) {
if (seen.Id == progress.Id) {
since = seen.SinceMs;
break;
}
}
still.push_back({progress.Id, since});
if (named == 0 && m_budgetMs != 0 && nowMs - since >= m_budgetMs) named = progress.Id;
}
m_running.swap(still);
return named;
}
Uint64 Detector::RunningMs(Uint64 id, Uint64 nowMs) const {
for (const Running& seen : m_running)
if (seen.Id == id) return nowMs - seen.SinceMs;
return 0;
}
Uint64 Register(void* self, SampleFn sample, HungFn hung) {
const Uint32 budget = BudgetMs();
if (budget == 0 || sample == nullptr || hung == nullptr) return 0;
Watch& watch = TheWatch();
const std::lock_guard<std::mutex> lock(watch.Mutex);
Entry entry;
entry.Handle = watch.NextHandle++;
entry.Self = self;
entry.Sample = sample;
entry.Hung = hung;
entry.Decide = Detector(budget);
watch.Entries.push_back(entry);
if (!watch.ThreadStarted) {
watch.ThreadStarted = true;
std::thread(WatchThreadMain).detach();
}
return entry.Handle;
}
void Unregister(Uint64 handle) {
if (handle == 0) return;
Watch& watch = TheWatch();
// The poll pass runs under this lock, so taking it waits out any call into the entry.
const std::lock_guard<std::mutex> lock(watch.Mutex);
for (SizeT i = 0; i < watch.Entries.size(); ++i) {
if (watch.Entries[i].Handle != handle) continue;
watch.Entries.erase(watch.Entries.begin() + static_cast<std::ptrdiff_t>(i));
return;
}
}
} // namespace MobileGL::MG_Backend::GpuHangWatch
-94
View File
@@ -1,94 +0,0 @@
// MobileGL - MobileGL/MG_Backend/GpuHangWatch.h
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#pragma once
// A SESSION WHOSE GPU WORK NEVER ENDS IS FOUND AND NAMED, SO IT CANNOT HANG THE GPU AGAIN.
//
// A submission whose shader never ends stops the whole GPU, not one context: every process's work -
// the compositor's, other clients', processes outside MobileGL at the highest context priority -
// waits until the kernel resets it. Measured on Adreno 750: ~2 s when nothing of higher priority
// waits (the context is then lost: Vulkan answers VK_ERROR_DEVICE_LOST), ~10 s when something of
// higher priority does (a failed preemption; the context is NOT lost, and its next frame hangs the
// GPU again). Nothing in user space can shorten one such stall; what the server can do is make sure
// the session that caused it never submits again, so a page or program that hangs every frame
// costs the desktop one stall instead of one per frame.
//
// The attribution must be exact - every session's work is pending while the GPU is stuck, and the
// compositor's must never be blamed. A backend that can tell, per in-flight submission, whether the
// GPU has STARTED it and whether it has FINISHED it gives exactly that: the GPU runs one submission
// at a time on a ring, so the one that started and does not finish is the one that hangs, and the
// ones queued behind it have not started. Magma brackets each submission with two events
// (DirectVulkan/Renderer/GpuProgressMarkers.h). Espryt relies on the driver instead: its contexts ask
// for reset notification and glGetGraphicsResetStatus names the guilty one - measured after a ~2 s
// timeout reset; after a ~10 s failed-preemption reset the server's contexts were NOT told (a
// standalone process's context was), so on Espryt that path is not contained yet.
//
// The Detector is the decision, pure and testable; the watch thread samples every registered backend
// on its own clock, because the session that hangs is often not running - its apply thread waits for
// its own fence, or for the backend turn another session holds while it waits for the GPU.
#include <Includes.h>
#include <mutex>
namespace MobileGL::MG_Backend::GpuHangWatch {
// MOBILEGL_GPU_HANG_BUDGET_MS: how long one submission may run once the GPU has started it before
// its session is ended as the one that hangs the GPU. Default 2000 - the kernel resets a hung GPU
// by itself after about that when nothing preempts it, and no desktop frame runs that long. 0 = off.
Uint32 BudgetMs();
constexpr Uint32 kDefaultBudgetMs = 2000;
// One in-flight submission as the GPU reports progress on it.
struct SubmissionProgress {
Uint64 Id = 0; // the backend's own monotonic id for it; never reused
Bool Started = false; // the GPU has begun executing it
Bool Finished = false; // ... and completed it
};
// Which submission, if any, has run past the budget: started, not finished, and seen in that
// state for at least `budgetMs` (from the first sample that saw it running - the watch cannot know
// when between two samples it began, so a hang is named between budget and budget + one interval).
class Detector {
public:
explicit Detector(Uint32 budgetMs) : m_budgetMs(budgetMs) {}
// One sample of every in-flight submission at `nowMs`. Returns the id of the submission that
// ran past the budget, or 0. Submissions missing from the sample are forgotten.
Uint64 Observe(const Vector<SubmissionProgress>& sample, Uint64 nowMs);
// How long the named submission had been seen running when Observe named it.
Uint64 RunningMs(Uint64 id, Uint64 nowMs) const;
private:
struct Running {
Uint64 Id = 0;
Uint64 SinceMs = 0;
};
Uint32 m_budgetMs = 0;
Vector<Running> m_running;
};
// ---- the process-wide watch ---------------------------------------------------------------
//
// A backend registers a sampler and a callback. The watch thread calls the sampler every
// PollIntervalMs() on its own thread, and the callback once, when the Detector names a
// submission; the backend acts on it from its own thread (it may not latch a session from this
// one). Both are called with the watch's lock held: keep them short, and never call Unregister
// from them. Unregister returns only once no call into the registration runs or will run.
using SampleFn = Bool (*)(void* self, Vector<SubmissionProgress>& out); // false: stop watching it
using HungFn = void (*)(void* self, Uint64 submissionId, Uint64 runningMs);
Uint64 Register(void* self, SampleFn sample, HungFn hung);
void Unregister(Uint64 handle);
Uint32 PollIntervalMs();
// Tests: the interval and the budget the next Register uses (0 restores the defaults).
void SetPollIntervalForTesting(Uint32 ms);
void SetBudgetForTesting(Uint32 ms);
} // namespace MobileGL::MG_Backend::GpuHangWatch
+31 -563
View File
@@ -8,7 +8,6 @@
#include "EGLImpl.h"
#include "EGLPlatformExtensions.h"
#include "SharedImageFlushPolicy.h"
#include "WaylandWindow.h"
#include "../GetProcAddress.h"
#include <Init.h>
@@ -25,31 +24,18 @@
// (PipeFill.cpp's emitters) and because the frame channel belongs to the server role - this
// file must not name ServerLoop's forwarders directly.
#include <MG_Remote/Client/WireTables.h>
// The recovery after a device loss (RecoverLostSession below): the session, the remote backend's
// surface book, and the GL framebuffer 0 that is rebuilt on the fresh session.
#include <MG_Remote/Client/BackendObject_Remote.h>
#include <MG_Remote/Client/ClientSession.h>
#include <MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h>
#include <MG_State/GLState/Core.h>
#include <optional>
#endif
#include <atomic>
#include <cstdlib>
#include <cstring>
#include <mutex>
#include <sstream>
#if defined(__linux__) && !defined(__ANDROID__)
#include <dlfcn.h>
#endif
#include <algorithm>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
namespace MobileGL::MG_Impl::EGLImpl {
namespace {
// SetDispatcherCurrentApiHook.
std::atomic<EGLenum (*)()> g_dispatcherCurrentApi{nullptr};
using EGLStateContext = MG_State::EGLState::EGLContext;
EGLStateContext* GetState() {
@@ -88,8 +74,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
}
#if MOBILEGL_BUILD_DISAGGREGATED
using MG_Remote::Client::ClientSession;
// P14 S1 (docs/Disaggregated/design/11-state-ownership.md). THE CONTEXT BINDING, AND
// THE ONE PLACE IT IS EMITTED.
//
@@ -161,82 +145,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
}
namespace {
// RECORDS WRITTEN FOR A CONTEXT THAT IS NOT THE CALLING THREAD'S. eglCreateContext builds
// the new context's GL state (its default objects are created there) and eglDestroyContext
// ends a context's objects, on whatever thread calls them - one with another context
// current, or none. Those records belong to the context being created or destroyed, so the
// stream is bound to it first; the next GL entry point binds the stream back to its own
// thread's context (GLStreamScope). The caller holds StreamMutex().
void StreamBindContextLocked(Uint64 token, Uint64 shareGroupToken) {
if (token == g_boundContextToken) return;
if (MG_Remote::Client::EmitBindContextRecord(token)) {
g_boundContextToken = token;
g_boundShareGroupToken = shareGroupToken;
}
}
// THE ONE WAY A CONTEXT ENDS on a split client, whether eglDestroyContext ended it at once
// or its deferred destroy completed when the last thread released it. `glState` is the
// context's GL state, whose last owner this is: dropping it ends the context's own objects
// (and its share group's, when it is the group's last context). They end under the
// context's own binding, the residual fill's object pins included (a pinned vertex array
// or program of this context would otherwise end inside some later thread's draw), and
// only then does the server drop the context - the order the records need, because the
// server files nothing under a context it no longer has. A context lost with an ended
// session goes in silence, as before.
void FinishContextDestroy(Uint64 token, Uint64 shareGroupToken, SharedPtr<MG_State::GLState::GLContext> glState,
Bool lost) {
if (token == 0 || lost || !StreamGateActive()) {
std::optional<ClientSession::ScopedWireMute> silence;
if (lost) silence.emplace();
glState.reset();
return;
}
StreamBindContextLocked(token, shareGroupToken);
// The pins live in the client's own residual block - its own memory only when the
// server is another process; in the one-process shape the apply thread reads that block
// too, and only a barriered apply's return may touch it (ClientSession::ReleaseFillPins).
if (ClientSession* session = ClientSession::Active();
session != nullptr && session->Started() && MG_Config::Transport != MG_Config::TransportMode::InProcess) {
session->WaitForApplyToCatchUp("eglDestroyContext");
session->ReleaseFillPins();
}
glState.reset();
// The server drops its binding to 0 when the bound context is destroyed
// (ServerSession::DestroyContext's compare-and-swap); the gate mirrors it so the next
// write re-binds.
if (g_boundContextToken == token) {
g_boundContextToken = 0;
g_boundShareGroupToken = 0;
}
const auto emitted = MG_Remote::Client::SendDestroyContextFrame(token);
if (emitted == MG_Remote::Client::ContextFrameEmit::Refused) {
MGLOG_E_ONCE("eglDestroyContext: the server holds no context token %llu; the "
"session's table and this client's EGL book have drifted apart",
static_cast<unsigned long long>(token));
}
}
} // namespace
void FinishReapedContexts(MG_State::EGLState::EGLContext* state) {
if (state == nullptr) return;
if (!StreamGateActive()) {
(void)state->TakeReapedContexts(); // dropping them ends their GL state
return;
}
for (auto& reaped : state->TakeReapedContexts()) {
const Bool lost = reaped.GLStateObject != nullptr &&
(reaped.GLStateObject->IsFromEndedWireSession() || ClientSession::SessionLatchedLost());
FinishContextDestroy(reaped.ClientContextToken, reaped.ShareGroupToken, Move(reaped.GLStateObject), lost);
}
}
namespace {
#else
// A monolith has no stream to bind: a context whose deferred destroy completed simply ends.
void FinishReapedContexts(MG_State::EGLState::EGLContext* state) {
if (state != nullptr) (void)state->TakeReapedContexts();
}
#endif
String CurrentThreadIdString() {
std::ostringstream stream;
@@ -308,43 +216,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
return *surfaces;
}
// EGL_KHR_surfaceless_context. The EGL state records a surfaceless binding as exactly that
// (eglGetCurrentSurface answers EGL_NO_SURFACE), but every backend renders into the surface
// it was bound to, and a session's capabilities are published on its first bind to one. So
// the backend is bound to a 1x1 pbuffer of the display's own instead: one per display, made
// on the first surfaceless bind, never handed to the application, and gone with the display
// (eglTerminate). Guarded by EGLOperationMutex.
std::unordered_map<EGLDisplay, EGLSurface>& SurfacelessStandIns() {
static auto* standIns = new std::unordered_map<EGLDisplay, EGLSurface>();
return *standIns;
}
// eglCreatePbufferSurface for the stand-in, except that a split client creates it on the
// server as a stand-in, which takes no surface mode there (a server-owned window may follow).
EGLSurface CreateSurfacelessStandInPbuffer(EGLStateContext* state, EGLDisplay dpy, EGLConfig config,
const EGLint* attribs);
// The display's stand-in, made now if it has none (or the one it had did not survive).
// EGL_NO_SURFACE when the backend could not make a pbuffer; the EGL error is then set.
EGLSurface SurfacelessStandIn(EGLStateContext* state, EGLDisplay dpy) {
auto& standIns = SurfacelessStandIns();
if (const auto it = standIns.find(dpy); it != standIns.end()) {
if (state->ValidateSurfaceOnDisplay(dpy, it->second)) return it->second;
standIns.erase(it);
}
// Any of the display's configs will do: a stand-in is never read back or presented.
EGLConfig config = nullptr;
EGLint count = 0;
if (!state->GetConfigs(dpy, &config, 1, &count) || count < 1 || config == nullptr) {
state->SetError(EGL_BAD_ALLOC);
return EGL_NO_SURFACE;
}
const EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE};
const EGLSurface standIn = CreateSurfacelessStandInPbuffer(state, dpy, config, attribs);
if (standIn != EGL_NO_SURFACE) standIns[dpy] = standIn;
return standIn;
}
#if MOBILEGL_WAYLAND_WINDOWS
// Every Wayland window surface's presentation, by surface. Guarded by EGLOperationMutex,
// which every entry point that reaches it holds.
@@ -443,130 +314,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
}
}
#endif
#if MOBILEGL_BUILD_DISAGGREGATED
using MG_Remote::Client::ClientSession;
// IS `context` LOST. It was built against a server session that has since ended (a device
// loss, recovered), or it lives on the session that is lost right now: either way its
// objects are on no server this process can reach, and EGL's answer for it is
// EGL_CONTEXT_LOST until the application destroys it.
Bool ContextIsLost(EGLStateContext* state, EGLContext context) {
if (!StreamGateActive() || context == EGL_NO_CONTEXT) return false;
const SharedPtr<MG_State::GLState::GLContext> glState = state->GetContextGLState(context);
if (!glState) return false;
return glState->IsFromEndedWireSession() || ClientSession::SessionLatchedLost();
}
// THE RECOVERY'S EGL HALF. The caller holds EGLOperationMutex - which every GL entry point
// takes too (GLStreamScope), so no other thread is in the middle of a GL call - and is an
// entry point an application reaches when it rebuilds after a loss: eglCreateContext,
// eglCreate*Surface, eglInitialize. A no-op unless the session is latched lost.
//
// 1. ClientSession ends the lost session and dials a fresh one; its FinishStartup forgets
// every client cache of the old one and moves the wire epoch, which is what makes every
// context built before lost (their objects die later without a word on the new wire).
// 2. The process default context and GL framebuffer 0 are rebuilt on the fresh session:
// every context created from now on starts with framebuffer 0 bound, and the old one's
// attachments are textures the fresh server never heard of.
// 3. The remote backend initializes the display again on the new server and forgets which
// surfaces and shared images the old one had; each surface is re-created there when it
// is next made current (EGL keeps surfaces across a power-management loss).
// 4. Wayland presentations drop the lost session's shared images and allocate new ones.
Bool RecoverLostSession() {
if (!StreamGateActive() || !ClientSession::SessionLatchedLost()) return true;
ClientSession* session = ClientSession::Active();
{
const ClientSession::ScopedWireMute mute;
if (session->RecoverAfterDeviceLoss() != MOBILEGL_OK) return false;
}
// Nothing is bound on the fresh session: the next thread that writes binds its own.
g_boundContextToken = 0;
g_boundShareGroupToken = 0;
const ClientSession::ScopedCurrentSessionWork work;
SharedPtr<MG_State::GLState::GLContext> lostDefault = MG_State::ReplaceProcessDefaultGLContext();
UniquePtr<MG_Impl::GLImpl::FramebufferImpl::DefaultFramebufferInfo> lostFramebuffer =
Move(MG_Impl::GLImpl::FramebufferImpl::pDefaultFramebufferInfo);
{
// Built into the new default context, whatever this thread has current (a lost
// context stays this thread's GL state until the application releases it).
SharedPtr<MG_State::GLState::GLContext> caller = MG_State::pGLContext;
MG_State::pGLContext = MG_State::ProcessDefaultGLContext();
MG_Impl::BuildDefaultFramebuffer();
MG_State::pGLContext = Move(caller);
}
{
const ClientSession::ScopedWireMute mute;
lostFramebuffer.reset();
lostDefault.reset();
}
if (auto* remote = dynamic_cast<MG_Remote::Client::BackendObject_Remote*>(MG_Backend::pActiveBackendObject.get()))
remote->OnSessionReplaced();
#if MOBILEGL_WAYLAND_WINDOWS
for (auto& [surface, presentation] : WaylandSurfaces()) presentation->OnSessionReplaced();
#endif
return true;
}
// THE SHARE GROUPS THAT REPLACE LOST ONES, by the lost group's token. An application that
// keeps one long-lived context to share with (Qt's global share context) recreates its
// other contexts after a loss still naming that context, which is lost and stays so. Those
// contexts are put in ONE new share group instead of each in a group of its own: the first
// starts it, the later ones share with a live member of it. Without this, every window of
// such an application lands in a separate share group after the loss, a shape the
// application never asked for. Guarded by EGLOperationMutex.
std::unordered_map<Uint64, Vector<EGLContext>>& ReplacementShareContexts() {
static auto* replacements = new std::unordered_map<Uint64, Vector<EGLContext>>();
return *replacements;
}
// The context a new context should share with in place of the lost `shareCtx`: a live
// member of the group that replaces the lost one, or EGL_NO_CONTEXT to start that group.
EGLContext ReplacementShareContext(EGLStateContext* state, EGLDisplay dpy, Uint64 lostGroup) {
Vector<EGLContext>& members = ReplacementShareContexts()[lostGroup];
members.erase(std::remove_if(members.begin(), members.end(),
[&](EGLContext member) {
return !state->ValidateContextOnDisplay(dpy, member) ||
ContextIsLost(state, member);
}),
members.end());
return members.empty() ? EGL_NO_CONTEXT : members.front();
}
void ForgetReplacementShareContext(EGLContext context) {
for (auto& [group, members] : ReplacementShareContexts())
members.erase(std::remove(members.begin(), members.end(), context), members.end());
}
// The surface entry points' guard: a surface created after a loss is created on a fresh
// session. EGL_BAD_ALLOC when no session could be brought up.
Bool RecoverBeforeCreatingSurface(EGLStateContext* state) {
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
if (RecoverLostSession()) return true;
state->SetError(EGL_BAD_ALLOC);
return false;
}
#endif
EGLSurface CreateSurfacelessStandInPbuffer(EGLStateContext* state, EGLDisplay dpy, EGLConfig config,
const EGLint* attribs) {
#if MOBILEGL_BUILD_DISAGGREGATED
auto* remote = dynamic_cast<MG_Remote::Client::BackendObject_Remote*>(GetBackendObject(state));
if (remote == nullptr) return CreatePbufferSurface(dpy, config, attribs);
if (!RecoverBeforeCreatingSurface(state)) return EGL_NO_SURFACE;
const EGLSurface surface = state->CreatePbufferSurface(dpy, config, attribs);
if (surface == EGL_NO_SURFACE) return EGL_NO_SURFACE;
if (!remote->CreateEGLSurfacelessStandIn(surface, GetAttribValue(attribs, EGL_WIDTH, 1),
GetAttribValue(attribs, EGL_HEIGHT, 1))) {
state->DestroySurface(dpy, surface);
state->SetError(EGL_BAD_ALLOC);
return EGL_NO_SURFACE;
}
return surface;
#else
return CreatePbufferSurface(dpy, config, attribs);
#endif
}
} // namespace
EGLSurface CreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window,
@@ -575,9 +322,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
if (!state) {
return EGL_NO_SURFACE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
if (!RecoverBeforeCreatingSurface(state)) return EGL_NO_SURFACE;
#endif
#if MOBILEGL_WAYLAND_WINDOWS
if (RefuseGbmWindow(state, dpy)) return EGL_NO_SURFACE;
{
@@ -690,20 +434,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
// A swap of a lost context's frame: EGL_CONTEXT_LOST (EGL 1.5 3.2), and nothing presented.
// A Wayland window is still committed, with no new buffer (WindowSurface::CommitPendingState):
// Qt asks for a frame callback before every swap and draws the window again only once it
// has fired, so a swap that never committed froze the window for good - a Plasma panel
// that hit the loss in its own swap never redrew, not even to rebuild its context.
if (ContextIsLost(state, state->GetCurrentContext())) {
#if MOBILEGL_WAYLAND_WINDOWS
if (auto it = WaylandSurfaces().find(draw); it != WaylandSurfaces().end()) it->second->CommitPendingState();
#endif
state->SetError(EGL_CONTEXT_LOST);
return EGL_FALSE;
}
#endif
auto* backendObject = GetBackendObject(state);
if (!backendObject) {
@@ -727,28 +457,9 @@ namespace MobileGL::MG_Impl::EGLImpl {
#if MOBILEGL_WAYLAND_WINDOWS
// A Wayland window shows what is attached to it: the frame is read back and attached
// BEFORE the swap, while it is still the drawable's content.
if (auto it = WaylandSurfaces().find(draw); it != WaylandSurfaces().end()) {
#if MOBILEGL_BUILD_DISAGGREGATED
// A loss that this very present runs into is reported here, as the one above: a
// frame of the lost device shown as if it were the window's would leave the toolkit
// with a transparent window it learns only afterwards it has to redraw.
const auto sessionLost = +[]() -> Bool {
auto* current = GetState();
return current != nullptr && ContextIsLost(current, current->GetCurrentContext());
};
#else
Bool (*const sessionLost)() = nullptr;
#endif
switch (it->second->Present(damage, state->GetSwapInterval(dpy), sessionLost)) {
case Wayland::WindowSurface::PresentResult::kPresented: break;
case Wayland::WindowSurface::PresentResult::kLost:
it->second->CommitPendingState();
state->SetError(EGL_CONTEXT_LOST);
return EGL_FALSE;
case Wayland::WindowSurface::PresentResult::kNotShown:
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
if (auto it = WaylandSurfaces().find(draw); it != WaylandSurfaces().end() && !it->second->Present(damage)) {
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
#endif
const Bool swapped = damage.IsFull() ? backendObject->SwapEGLBuffers(dpy, draw)
@@ -779,56 +490,10 @@ namespace MobileGL::MG_Impl::EGLImpl {
if (!state) {
return EGL_NO_CONTEXT;
}
// The API the context is for, as the dispatcher reports it (SetDispatcherCurrentApiHook):
// an ES context made without an eglBindAPI - or with one of the default - is an ES context.
if (const auto currentApi = g_dispatcherCurrentApi.load()) {
const EGLenum api = currentApi();
if (api == EGL_OPENGL_API || api == EGL_OPENGL_ES_API) state->SetBoundAPI(api);
}
#if MOBILEGL_BUILD_DISAGGREGATED
// AFTER A DEVICE LOSS THIS IS WHERE AN APPLICATION REBUILDS, so this is where a fresh
// session comes up (RecoverLostSession) - before the context's GL state is built, because
// building it already emits the creates of its default objects. Sharing with a lost
// context would share objects no reachable server holds.
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
// The lost share group this context replaces (ReplacementShareContexts), 0 for none.
Uint64 replacedGroup = 0;
if (StreamGateActive()) {
if (!RecoverLostSession()) {
state->SetError(EGL_BAD_ALLOC);
return EGL_NO_CONTEXT;
}
if (shareCtx != EGL_NO_CONTEXT && ContextIsLost(state, shareCtx)) {
// Its objects are on no server, so the context does not share them: it joins the
// group that replaces the lost one (the other contexts recreated in its place).
if (!state->ValidateContextOnDisplay(dpy, shareCtx)) {
state->SetError(EGL_BAD_CONTEXT);
return EGL_NO_CONTEXT;
}
replacedGroup = state->GetContextShareGroupToken(shareCtx);
const EGLContext lostShare = shareCtx;
shareCtx = ReplacementShareContext(state, dpy, replacedGroup);
MGLOG_I_ONCE("eglCreateContext: the share context %p was lost with its session (device loss); "
"contexts that name it share with each other in a new share group instead",
lostShare);
}
}
// The calling thread may still have a lost context current: what is built here is the
// fresh session's all the same.
const ClientSession::ScopedCurrentSessionWork currentSession;
// A split client builds the context's GL state only once the server has its token (below).
const Bool splitClient = MG_Config::Transport != MG_Config::TransportMode::Monolith &&
!MG_Remote::Client::RunsAsTheServerRole();
#else
constexpr Bool splitClient = false;
#endif
EGLContext context = state->CreateContext(dpy, config, shareCtx, attrib_list, splitClient);
const EGLContext context = state->CreateContext(dpy, config, shareCtx, attrib_list);
if (context == EGL_NO_CONTEXT) {
return EGL_NO_CONTEXT;
}
#if MOBILEGL_BUILD_DISAGGREGATED
if (replacedGroup != 0) ReplacementShareContexts()[replacedGroup].push_back(context);
#endif
#if MOBILEGL_BUILD_DISAGGREGATED
// P14 S1 (docs/Disaggregated/design/11-state-ownership.md). THE TOKEN CROSSES BEFORE
// eglCreateContext RETURNS. EGLState minted it, together with the share group it was
@@ -844,49 +509,13 @@ namespace MobileGL::MG_Impl::EGLImpl {
// pre-Start bring-up, the server role) keeps it: there is no server to refuse.
if (MG_Config::Transport != MG_Config::TransportMode::Monolith &&
!MG_Remote::Client::RunsAsTheServerRole()) {
auto emitted = MG_Remote::Client::SendCreateContextFrame(
const auto emitted = MG_Remote::Client::SendCreateContextFrame(
state->GetContextClientToken(context), state->GetContextShareGroupToken(context), 0);
// THE LOSS CAN BE FOUND OUT HERE: a session whose server is gone, which nothing had
// noticed yet, refuses the create by hanging up on it. That is the loss, not a refusal:
// the half-built context goes (its objects silently - they were never on any server),
// a fresh session comes up, and the context is built again on it, once.
if (emitted == MG_Remote::Client::ContextFrameEmit::Refused && ClientSession::SessionLatchedLost()) {
{
const ClientSession::ScopedWireMute mute;
state->DestroyContext(dpy, context);
}
context = EGL_NO_CONTEXT;
if (RecoverLostSession()) {
// The context it was to share with went with the session, too.
if (shareCtx != EGL_NO_CONTEXT && ContextIsLost(state, shareCtx)) {
replacedGroup = state->GetContextShareGroupToken(shareCtx);
shareCtx = ReplacementShareContext(state, dpy, replacedGroup);
}
context = state->CreateContext(dpy, config, shareCtx, attrib_list, splitClient);
}
if (context == EGL_NO_CONTEXT) {
state->SetError(EGL_BAD_ALLOC);
return EGL_NO_CONTEXT;
}
if (replacedGroup != 0) ReplacementShareContexts()[replacedGroup].push_back(context);
emitted = MG_Remote::Client::SendCreateContextFrame(state->GetContextClientToken(context),
state->GetContextShareGroupToken(context), 0);
}
if (emitted == MG_Remote::Client::ContextFrameEmit::Refused) {
state->DestroyContext(dpy, context);
state->SetError(EGL_BAD_ACCESS);
return EGL_NO_CONTEXT;
}
// NOW THE CONTEXT'S GL STATE, under its own binding. Building it creates the context's
// default objects (a texture per target, ...), and the records that create them belong
// to THIS context's share group on the server - not to whichever context the stream
// was last bound to by some other thread, which is where they landed when the state was
// built before the token crossed: a context in a share group of its own then drew with
// default objects its group never had.
if (emitted == MG_Remote::Client::ContextFrameEmit::Sent) {
StreamBindContextLocked(state->GetContextClientToken(context), state->GetContextShareGroupToken(context));
}
(void)state->BuildContextGLState(context);
}
#endif
return context;
@@ -897,12 +526,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
if (!state) {
return EGL_FALSE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
// An application that re-initializes a display after a loss (without the eglTerminate that
// would have torn the library down) gets a fresh session here, as eglCreateContext would.
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
(void)RecoverLostSession();
#endif
if (!state->InitializeDisplay(dpy, major, minor)) {
return EGL_FALSE;
}
@@ -946,13 +569,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
if (!state) {
return EGL_FALSE;
}
// A release (explicit, or the implicit one of binding another context) may complete the
// deferred destroy of the context it releases; that destroy is finished on the way out,
// under the lock, whichever way this call returns.
struct FinishReapedOnExit {
EGLStateContext* State;
~FinishReapedOnExit() { FinishReapedContexts(State); }
} finishReaped{state};
const auto oldDisplay = state->GetCurrentDisplay();
const auto oldDraw = state->GetCurrentSurface(EGL_DRAW);
@@ -963,28 +579,11 @@ namespace MobileGL::MG_Impl::EGLImpl {
// knows it. Read here because `state->MakeCurrent` below has already committed the
// new one by the time the emission points are reached.
const Uint64 oldContextToken = state->GetContextClientToken(oldContext);
// Read before the release too: a thread letting go of a context lost with an ended session
// says nothing to the fresh one (its binding never named that context).
const Bool oldContextLost = ContextIsLost(state, oldContext);
#endif
const String threadId = CurrentThreadIdString();
MGLOG_D("eglMakeCurrent begin thread=%s dpy=%p draw=%p read=%p ctx=%p oldDpy=%p oldDraw=%p oldRead=%p oldCtx=%p",
threadId.c_str(), dpy, draw, read, ctx, oldDisplay, oldDraw, oldRead, oldContext);
#if MOBILEGL_BUILD_DISAGGREGATED
// EGL 1.5 3.7.3 / 3.2: after a power-management event - a lost device, here - making a
// context created before it current fails with EGL_CONTEXT_LOST. The application destroys
// it and creates another; a release, and every context created since, go on as usual.
if (ctx != EGL_NO_CONTEXT && ContextIsLost(state, ctx)) {
// Once per process: an application that keeps binding the context it lost (instead of
// destroying it and creating another) never reaches the recovery.
MGLOG_I_ONCE("eglMakeCurrent: context %p was lost with its session (device loss): EGL_CONTEXT_LOST "
"until the application destroys it; a context created after the loss gets a fresh session",
ctx);
state->SetError(EGL_CONTEXT_LOST);
return EGL_FALSE;
}
#endif
#if MOBILEGL_WAYLAND_WINDOWS
if (draw != EGL_NO_SURFACE) ApplyWaylandResize(state, dpy, draw);
@@ -1009,11 +608,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
}
MGLOG_D("eglMakeCurrent release succeeded thread=%s", threadId.c_str());
#if MOBILEGL_BUILD_DISAGGREGATED
{
std::optional<ClientSession::ScopedWireMute> silence;
if (oldContextLost) silence.emplace();
EmitContextBinding(state, EGL_NO_CONTEXT, oldContextToken);
}
EmitContextBinding(state, EGL_NO_CONTEXT, oldContextToken);
#endif
return EGL_TRUE;
}
@@ -1024,22 +619,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
state->MakeCurrent(oldDisplay, oldDraw, oldRead, oldContext);
return EGL_FALSE;
}
// A surfaceless binding (EGL_KHR_surfaceless_context; EGLState took it above and records
// EGL_NO_SURFACE): the backend gets the display's stand-in pbuffer to render into.
EGLSurface backendDraw = draw;
EGLSurface backendRead = read;
if (draw == EGL_NO_SURFACE && read == EGL_NO_SURFACE) {
backendDraw = backendRead = SurfacelessStandIn(state, dpy);
if (backendDraw == EGL_NO_SURFACE) {
const EGLint error = state->ConsumeError();
MGLOG_E_ONCE("eglMakeCurrent: no stand-in pbuffer for a surfaceless binding thread=%s (error=0x%04x)",
threadId.c_str(), error);
state->MakeCurrent(oldDisplay, oldDraw, oldRead, oldContext);
state->SetError(error != EGL_SUCCESS ? error : EGL_BAD_ALLOC);
return EGL_FALSE;
}
}
if (!backendObject->MakeEGLCurrent(dpy, backendDraw, backendRead, ctx)) {
if (!backendObject->MakeEGLCurrent(dpy, draw, read, ctx)) {
MGLOG_E_ONCE("eglMakeCurrent backend attach failed thread=%s dpy=%p draw=%p read=%p ctx=%p", threadId.c_str(),
dpy, draw, read, ctx);
state->SetError(EGL_BAD_ACCESS);
@@ -1060,35 +640,34 @@ namespace MobileGL::MG_Impl::EGLImpl {
return EGL_FALSE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
// Under the operation lock, like every GL call: what ends here writes records.
const std::lock_guard<std::recursive_mutex> destroyLock(EGLOperationMutex());
// P14 S1. Read BEFORE the client's own book drops the context: after DestroyContext
// the handle no longer resolves and the token is unrecoverable. The frame is sent
// AFTER the client's state machine has accepted the destroy, so one EGL refused never
// reaches the server - the two ends stay in step without the server having to guess why
// a token vanished.
// AFTER the client's state machine has accepted the destroy, so one EGL refused (a
// context still current on some thread, EGL_BAD_ACCESS) never reaches the server - the
// two ends stay in step without the server having to guess why a token vanished.
const Uint64 contextToken = state->GetContextClientToken(ctx);
const Uint64 shareGroupToken = state->GetContextShareGroupToken(ctx);
// A LOST CONTEXT IS DESTROYED IN SILENCE. Its objects die here, and a death that reached
// the wire would land on whichever session is current now - a fresh one after a recovery,
// which never created them.
const Bool lost = ContextIsLost(state, ctx);
// The context's GL state, held across the book's drop so that its objects end in
// FinishContextDestroy, under the context's own binding, rather than inside EGLState.
SharedPtr<MG_State::GLState::GLContext> glState = state->GetContextGLState(ctx);
Bool deferred = false;
if (!state->DestroyContext(dpy, ctx, &deferred)) {
return EGL_FALSE;
}
ForgetReplacementShareContext(ctx);
// CURRENT TO A THREAD (this one or another): EGL destroys it once it is released, and that
// release finishes it (FinishReapedContexts). Until then its thread keeps drawing in it.
if (deferred) return EGL_TRUE;
FinishContextDestroy(contextToken, shareGroupToken, Move(glState), lost);
#else
#endif
if (!state->DestroyContext(dpy, ctx)) {
return EGL_FALSE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
if (contextToken != 0 && MG_Config::Transport != MG_Config::TransportMode::Monolith &&
!MG_Remote::Client::RunsAsTheServerRole()) {
const std::lock_guard<std::recursive_mutex> streamLock(EGLOperationMutex());
// The server drops its binding to 0 when the current context is destroyed
// (ServerSession::DestroyContext's compare-and-swap); the gate mirrors it so the next
// write re-binds.
if (g_boundContextToken == contextToken) {
g_boundContextToken = 0;
g_boundShareGroupToken = 0;
}
const auto emitted = MG_Remote::Client::SendDestroyContextFrame(contextToken);
if (emitted == MG_Remote::Client::ContextFrameEmit::Refused) {
MGLOG_E_ONCE("eglDestroyContext: the server holds no context token %llu; the "
"session's table and this client's EGL book have drifted apart",
static_cast<unsigned long long>(contextToken));
}
}
#endif
return EGL_TRUE;
}
@@ -1120,12 +699,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
if (!state->TerminateDisplay(dpy)) {
return EGL_FALSE;
}
{
// The display's surfaces went with it, its surfaceless stand-in among them; the backend
// side goes with ReleaseEGLResources below.
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
SurfacelessStandIns().erase(dpy);
}
if (auto* backendObject = MG_Backend::pActiveBackendObject.get()) {
// The display's dma-buf EGLImages went with it; so do their shared-image references.
for (const Uint64 sharedImageId : state->TakeOrphanedSharedImages()) {
@@ -1152,18 +725,11 @@ namespace MobileGL::MG_Impl::EGLImpl {
// Always succeeds (EGL 1.4 §3.11): after the last eglTerminate tore MobileGL down there is
// simply nothing of this thread's left to release.
if (!MG_State::pEGLContext) return EGL_TRUE;
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
auto* state = GetState();
if (auto* backendObject = MG_Backend::pActiveBackendObject.get()) {
(void)backendObject->MakeEGLCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
}
state->ReleaseThread();
#if MOBILEGL_BUILD_DISAGGREGATED
// The release edge, as eglMakeCurrent's release sends it: this thread has no context now,
// and the binding must not keep naming the one it had.
EmitContextBinding(state, EGL_NO_CONTEXT, 0);
#endif
FinishReapedContexts(state);
return EGL_TRUE;
}
@@ -1365,9 +931,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
if (!state) {
return EGL_NO_SURFACE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
if (!RecoverBeforeCreatingSurface(state)) return EGL_NO_SURFACE;
#endif
const EGLint width = GetAttribValue(attrib_list, EGL_WIDTH, 1);
const EGLint height = GetAttribValue(attrib_list, EGL_HEIGHT, 1);
EGLSurface surface = state->CreatePbufferSurface(dpy, config, attrib_list);
@@ -1529,49 +1092,9 @@ namespace MobileGL::MG_Impl::EGLImpl {
if (!state) {
return EGL_NO_SYNC;
}
#if MOBILEGL_BUILD_DISAGGREGATED
// EGL_ANDROID_native_fence_sync's fence command: a native fence with no descriptor of the
// application's. The server publishes the current context's shared-image accesses - its
// writes into dma-bufs become visible to the compositor's session, as at a glFlush - and
// hands back a sync_file of the work, which the application passes on with the buffer
// (Chrome's GPU process creates one per frame instead of flushing, when the compositor's
// kernel takes dma-buf fences). Answered through the round trip, so it is flushed too.
if (type == EGL_SYNC_NATIVE_FENCE_ANDROID && SharedImagesAvailable()) {
Bool hasFd = false;
for (const EGLAttrib* at = attrib_list; at != nullptr && at[0] != EGL_NONE; at += 2) {
if (at[0] == EGL_SYNC_NATIVE_FENCE_FD_ANDROID && at[1] != EGL_NO_NATIVE_FENCE_FD_ANDROID) hasFd = true;
}
if (!hasFd) {
if (GetCurrentContext() == EGL_NO_CONTEXT) {
state->SetError(EGL_BAD_MATCH);
return EGL_NO_SYNC;
}
int fence = -1;
{
const GLStreamScope stream;
MG_Pipe::MGPipeClientDrainTextureUploads();
auto* backendObject = MG_Backend::pActiveBackendObject.get();
if (backendObject == nullptr || !backendObject->CreateNativeFence(&fence)) {
MGLOG_E_ONCE("eglCreateSync: the server did not answer a native fence; none is created");
state->SetError(EGL_BAD_ALLOC);
return EGL_NO_SYNC;
}
}
return state->CreateNativeFenceSync(dpy, fence, EGL_SYNC_PRIOR_COMMANDS_COMPLETE);
}
}
#endif
return state->CreateSync(dpy, type, attrib_list);
}
EGLint DupNativeFenceFD(EGLDisplay dpy, EGLSync sync) {
auto* state = GetState();
if (!state) {
return EGL_NO_NATIVE_FENCE_FD_ANDROID;
}
return state->DupNativeFenceFD(dpy, sync);
}
EGLBoolean DestroySync(EGLDisplay dpy, EGLSync sync) {
auto* state = GetState();
if (!state) {
@@ -1596,8 +1119,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
return state->GetSyncAttrib(dpy, sync, attribute, value) ? EGL_TRUE : EGL_FALSE;
}
void SetDispatcherCurrentApiHook(EGLenum (*hook)()) { g_dispatcherCurrentApi.store(hook); }
Bool SharedImagesAvailable() {
#if MOBILEGL_BUILD_DISAGGREGATED
// A split client's backend is the remote one, which forwards the shared-image verbs to
@@ -1618,38 +1139,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
return true;
}
namespace {
std::atomic<Bool>& SharedImageBoundToTexture() {
static std::atomic<Bool> bound{false};
return bound;
}
} // namespace
void NoteSharedImageBoundToTexture() { SharedImageBoundToTexture().store(true, std::memory_order_relaxed); }
void FlushSharedImageAccesses() {
if (!SharedImageBoundToTexture().load(std::memory_order_relaxed) &&
std::getenv("MOBILEGL_SHARED_IMAGE_FLUSH_SYNC") == nullptr)
return;
#if MOBILEGL_BUILD_DISAGGREGATED
static const Bool ownsServerWindow = MG_Config::ServerOwnedWindowSurfaces();
#else
constexpr Bool ownsServerWindow = false;
#endif
if (!FlushPublishesSharedImageAccesses(SharedImagesAvailable(), SharedImageBoundToTexture().load(),
ownsServerWindow, std::getenv("MOBILEGL_SHARED_IMAGE_FLUSH_SYNC")))
return;
auto* backendObject = MG_Backend::pActiveBackendObject.get();
#if MOBILEGL_BUILD_DISAGGREGATED
// Uploads still waiting for a validate point go first: they are part of what is published.
MG_Pipe::MGPipeClientDrainTextureUploads();
#endif
if (backendObject != nullptr && !backendObject->FlushSharedImageAccesses()) {
MGLOG_E_ONCE("glFlush: this session's shared-image accesses could not be published; another session may "
"read them early");
}
}
EGLImage CreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
const EGLAttrib* attrib_list) {
auto* state = GetState();
@@ -1683,16 +1172,8 @@ namespace MobileGL::MG_Impl::EGLImpl {
state->SetError(EGL_BAD_MATCH);
return EGL_NO_IMAGE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
const Uint64 wireEpoch = MG_State::CurrentWireEpoch();
#else
const Uint64 wireEpoch = 0;
#endif
const EGLImage image = state->CreateSharedImage(dpy, {.Id = sharedImageId,
.Width = request.Width,
.Height = request.Height,
.Fourcc = request.Fourcc,
.WireEpoch = wireEpoch});
const EGLImage image = state->CreateSharedImage(
dpy, {.Id = sharedImageId, .Width = request.Width, .Height = request.Height, .Fourcc = request.Fourcc});
if (image == EGL_NO_IMAGE) (void)backendObject->ReleaseSharedImage(sharedImageId);
return image;
}
@@ -1702,20 +1183,10 @@ namespace MobileGL::MG_Impl::EGLImpl {
if (!state) {
return EGL_FALSE;
}
// The session the image's reference was taken on: a reference of a session that has ended
// died with it, and the same image imported again on the fresh session has the same id - a
// release of the old one sent there would drop the new one's reference.
MG_State::EGLState::EGLContext::SharedImageInfo shared;
const Bool sharedImage = state->GetSharedImage(image, &shared);
Uint64 sharedImageId = 0;
if (!state->DestroyImage(dpy, image, &sharedImageId)) {
return EGL_FALSE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
if (sharedImage && shared.WireEpoch != MG_State::CurrentWireEpoch()) sharedImageId = 0;
#else
(void)sharedImage;
#endif
// A texture the image was bound to keeps its own reference on the server (EGLImage
// siblings outlive the image), so only this handle's goes.
if (sharedImageId != 0) {
@@ -1795,9 +1266,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
if (!state) {
return EGL_NO_SURFACE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
if (!RecoverBeforeCreatingSurface(state)) return EGL_NO_SURFACE;
#endif
#if MOBILEGL_WAYLAND_WINDOWS
if (RefuseGbmWindow(state, dpy)) return EGL_NO_SURFACE;
{
-13
View File
@@ -56,8 +56,6 @@ namespace MobileGL::MG_Impl::EGLImpl {
EGLBoolean DestroySync(EGLDisplay dpy, EGLSync sync);
EGLint ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
EGLBoolean GetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib* value);
// EGL_ANDROID_native_fence_sync: a copy of a native fence sync's sync_file.
EGLint DupNativeFenceFD(EGLDisplay dpy, EGLSync sync);
EGLImage CreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
const EGLAttrib* attrib_list);
EGLBoolean DestroyImage(EGLDisplay dpy, EGLImage image);
@@ -68,19 +66,8 @@ namespace MobileGL::MG_Impl::EGLImpl {
// a split client's does, a monolith's does not. Decides the dma-buf EGL extensions, the
// Wayland linux-dmabuf presentation and GL_OES_EGL_image.
Bool SharedImagesAvailable();
// Under a dispatching libEGL the dispatcher, not this library, owns eglBindAPI's state: it does
// not forward a bind of the API it already reports (EGL_OPENGL_ES_API, EGL's default), so a
// context would otherwise be created for whatever this library assumed. The glvnd vendor
// installs the dispatcher's own answer here; eglCreateContext asks it.
void SetDispatcherCurrentApiHook(EGLenum (*hook)());
// The shared image an EGLImage names (EGL_LINUX_DMA_BUF_EXT), for glEGLImageTargetTexture2DOES.
Bool LookupSharedImage(EGLImage image, Uint64* id, EGLint* width, EGLint* height);
// glEGLImageTargetTexture2DOES bound a shared image to a texture: from now on glFlush/glFinish
// may be shared-image boundaries (SharedImageFlushPolicy.h).
void NoteSharedImageBoundToTexture();
// From glFlush/glFinish, under the stream lock: publish this session's shared-image accesses
// when the policy says a flush is a boundary in this process. Cheap when it is not.
void FlushSharedImageAccesses();
EGLDisplay GetPlatformDisplay(EGLenum platform, void* native_display, const EGLAttrib* attrib_list);
EGLSurface CreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void* native_window,
const EGLAttrib* attrib_list);
@@ -18,30 +18,19 @@ namespace MobileGL::MG_Impl::EGLImpl {
inline constexpr const char* kPlatformExtensionString =
"EGL_EXT_client_extensions EGL_EXT_platform_base EGL_KHR_platform_base "
"EGL_MESA_platform_surfaceless" MOBILEGL_PLATFORM_WAYLAND_EXTENSIONS;
// EGL_EXT_create_context_robustness: a context may ask for EGL_LOSE_CONTEXT_ON_RESET, and a
// split client's contexts are lost exactly when their server session is (a device loss on the
// server ends that session). An application learns of it through glGetGraphicsResetStatus only
// if it could ask for it here: ANGLE's GL-on-EGL backend mirrors this extension onto its own
// display, and Chrome checks that display for it before it ever queries the reset status.
inline constexpr const char* kDisplayExtensionString =
"EGL_KHR_create_context EGL_KHR_surfaceless_context EGL_KHR_no_config_context EGL_EXT_platform_base "
"EGL_EXT_create_context_robustness EGL_KHR_platform_base "
"EGL_KHR_create_context EGL_EXT_platform_base EGL_KHR_platform_base "
"EGL_MESA_platform_surfaceless" MOBILEGL_PLATFORM_WAYLAND_EXTENSIONS;
// The display list again, with the dma-buf import a backend with shared images has (a split
// client: the server allocates the images and names the descriptors that come back). A
// monolith has no allocator to recognise a dma-buf with, so it never advertises these. The
// same server answers the buffer age of its surfaces and takes swap damage to its presents.
inline constexpr const char* kDisplayExtensionStringWithSharedImages =
"EGL_KHR_create_context EGL_KHR_surfaceless_context EGL_KHR_no_config_context EGL_EXT_platform_base "
"EGL_EXT_create_context_robustness EGL_KHR_platform_base "
"EGL_KHR_create_context EGL_EXT_platform_base EGL_KHR_platform_base "
"EGL_MESA_platform_surfaceless" MOBILEGL_PLATFORM_WAYLAND_EXTENSIONS
" EGL_KHR_image_base EGL_EXT_image_dma_buf_import EGL_EXT_image_dma_buf_import_modifiers"
" EGL_EXT_buffer_age EGL_KHR_partial_update EGL_KHR_swap_buffers_with_damage"
" EGL_EXT_swap_buffers_with_damage"
// Native fences come from the server's sessions (a sync_file of a session's submitted work),
// which is also what publishes a context's writes into dma-bufs to the compositor without a
// swap: Chrome's GPU process ends each frame with one rather than a flush.
" EGL_KHR_fence_sync EGL_KHR_wait_sync EGL_ANDROID_native_fence_sync";
" EGL_EXT_swap_buffers_with_damage";
inline constexpr const char* kClientExtensionString =
"EGL_EXT_client_extensions EGL_KHR_create_context EGL_EXT_platform_base "
"EGL_KHR_platform_base EGL_MESA_platform_surfaceless" MOBILEGL_PLATFORM_WAYLAND_EXTENSIONS;
@@ -287,10 +287,8 @@ MOBILEGL_EGL_API EGLBoolean eglDestroySync(EGLDisplay dpy, EGLSync sync) {
return MobileGL::MG_Impl::EGLImpl::DestroySync(dpy, sync);
}
// The waits take no stream lock: they read EGL state only (its own lock), never the stream, and a
// native fence's wait blocks for as long as the fenced work runs - with the lock held, every other
// thread's GL call would wait with it.
MOBILEGL_EGL_API EGLint eglClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout) {
const MobileGL::MG_Impl::EGLImpl::StreamLockScope mglStreamLock;
MGLOG_D("eglClientWaitSync(dpy=%p, sync=%p, flags=%d, timeout=%llu)", dpy, sync, flags,
static_cast<unsigned long long>(timeout));
return MobileGL::MG_Impl::EGLImpl::ClientWaitSync(dpy, sync, flags, timeout);
@@ -302,65 +300,6 @@ MOBILEGL_EGL_API EGLBoolean eglGetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLin
return MobileGL::MG_Impl::EGLImpl::GetSyncAttrib(dpy, sync, attribute, value);
}
// EGL_KHR_fence_sync / EGL_KHR_wait_sync / EGL_ANDROID_native_fence_sync's spellings, which
// ANGLE's GLES-on-EGL backend loads by name (and only through them offers fences to Chrome): the
// same objects as EGL 1.5's, with EGLint attribute lists.
namespace {
// EGL_KHR_fence_sync's attribute list widened to EGL 1.5's; at most 16 pairs, as no sync type
// takes more than two attributes.
bool WidenSyncAttribs(const EGLint* in, EGLAttrib* out, int capacity) {
int n = 0;
for (const EGLint* at = in; at != nullptr && at[0] != EGL_NONE; at += 2) {
if (n + 3 > capacity) return false;
out[n++] = static_cast<EGLAttrib>(at[0]);
out[n++] = static_cast<EGLAttrib>(at[1]);
}
out[n] = EGL_NONE;
return true;
}
} // namespace
MOBILEGL_EGL_API EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint* attrib_list) {
const MobileGL::MG_Impl::EGLImpl::StreamLockScope mglStreamLock;
MGLOG_D("eglCreateSyncKHR(dpy=%p, type=%u, attrib_list=%p)", dpy, type, attrib_list);
EGLAttrib attribs[33];
if (!WidenSyncAttribs(attrib_list, attribs, 33)) return EGL_NO_SYNC_KHR;
return MobileGL::MG_Impl::EGLImpl::CreateSync(dpy, type, attribs);
}
MOBILEGL_EGL_API EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) {
const MobileGL::MG_Impl::EGLImpl::StreamLockScope mglStreamLock;
MGLOG_D("eglDestroySyncKHR(dpy=%p, sync=%p)", dpy, sync);
return MobileGL::MG_Impl::EGLImpl::DestroySync(dpy, sync);
}
MOBILEGL_EGL_API EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout) {
MGLOG_D("eglClientWaitSyncKHR(dpy=%p, sync=%p, flags=%d, timeout=%llu)", dpy, sync, flags,
static_cast<unsigned long long>(timeout));
return MobileGL::MG_Impl::EGLImpl::ClientWaitSync(dpy, sync, flags, timeout);
}
MOBILEGL_EGL_API EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint* value) {
const MobileGL::MG_Impl::EGLImpl::StreamLockScope mglStreamLock;
MGLOG_D("eglGetSyncAttribKHR(dpy=%p, sync=%p, attribute=%d, value=%p)", dpy, sync, attribute, value);
if (value == nullptr) return MobileGL::MG_Impl::EGLImpl::GetSyncAttrib(dpy, sync, attribute, nullptr);
EGLAttrib wide = 0;
const EGLBoolean ok = MobileGL::MG_Impl::EGLImpl::GetSyncAttrib(dpy, sync, attribute, &wide);
if (ok == EGL_TRUE) *value = static_cast<EGLint>(wide);
return ok;
}
MOBILEGL_EGL_API EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) {
MGLOG_D("eglWaitSyncKHR(dpy=%p, sync=%p, flags=%d)", dpy, sync, flags);
return MobileGL::MG_Impl::EGLImpl::WaitSync(dpy, sync, flags) == EGL_TRUE ? EGL_TRUE : EGL_FALSE;
}
MOBILEGL_EGL_API EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync) {
const MobileGL::MG_Impl::EGLImpl::StreamLockScope mglStreamLock;
MGLOG_D("eglDupNativeFenceFDANDROID(dpy=%p, sync=%p)", dpy, sync);
return MobileGL::MG_Impl::EGLImpl::DupNativeFenceFD(dpy, sync);
}
MOBILEGL_EGL_API EGLImage eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
const EGLAttrib* attrib_list) {
const MobileGL::MG_Impl::EGLImpl::StreamLockScope mglStreamLock;
@@ -445,8 +384,8 @@ MOBILEGL_EGL_API EGLSurface eglCreatePlatformPixmapSurface(EGLDisplay dpy, EGLCo
return MobileGL::MG_Impl::EGLImpl::CreatePlatformPixmapSurface(dpy, config, native_pixmap, attrib_list);
}
// No stream lock, like eglClientWaitSync's: a native fence's server wait blocks the calling thread.
MOBILEGL_EGL_API EGLBoolean eglWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags) {
const MobileGL::MG_Impl::EGLImpl::StreamLockScope mglStreamLock;
MGLOG_D("eglWaitSync(dpy=%p, sync=%p, flags=%d)", dpy, sync, flags);
return MobileGL::MG_Impl::EGLImpl::WaitSync(dpy, sync, flags);
}
@@ -44,12 +44,6 @@ extern "C" EGLBoolean eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface dra
extern "C" EGLBoolean eglSwapBuffersWithDamageEXT(EGLDisplay dpy, EGLSurface draw, const EGLint* rects,
EGLint n_rects);
extern "C" EGLBoolean eglSetDamageRegionKHR(EGLDisplay dpy, EGLSurface surface, EGLint* rects, EGLint n_rects);
extern "C" EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint* attrib_list);
extern "C" EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync);
extern "C" EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
extern "C" EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint* value);
extern "C" EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags);
extern "C" EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync);
extern "C" EGLBoolean eglQueryDmaBufFormatsEXT(EGLDisplay dpy, EGLint max_formats, EGLint* formats,
EGLint* num_formats);
extern "C" EGLBoolean eglQueryDmaBufModifiersEXT(EGLDisplay dpy, EGLint format, EGLint max_modifiers,
@@ -270,12 +264,6 @@ namespace {
{"eglClientWaitSync", reinterpret_cast<void*>(eglClientWaitSync)},
{"eglGetSyncAttrib", reinterpret_cast<void*>(eglGetSyncAttrib)},
{"eglWaitSync", reinterpret_cast<void*>(eglWaitSync)},
{"eglCreateSyncKHR", reinterpret_cast<void*>(eglCreateSyncKHR)},
{"eglDestroySyncKHR", reinterpret_cast<void*>(eglDestroySyncKHR)},
{"eglClientWaitSyncKHR", reinterpret_cast<void*>(eglClientWaitSyncKHR)},
{"eglGetSyncAttribKHR", reinterpret_cast<void*>(eglGetSyncAttribKHR)},
{"eglWaitSyncKHR", reinterpret_cast<void*>(eglWaitSyncKHR)},
{"eglDupNativeFenceFDANDROID", reinterpret_cast<void*>(eglDupNativeFenceFDANDROID)},
{"eglCreateImage", reinterpret_cast<void*>(eglCreateImage)},
{"eglDestroyImage", reinterpret_cast<void*>(eglDestroyImage)},
{"eglCreateImageKHR", reinterpret_cast<void*>(eglCreateImageKHR)},
@@ -364,12 +352,6 @@ extern "C" MOBILEGL_EGL_API EGLBoolean __egl_Main(uint32_t version, const __EGLa
return EGL_FALSE;
}
g_eglExports = exports;
if (exports->getCurrentApi != nullptr) {
MobileGL::MG_Impl::EGLImpl::SetDispatcherCurrentApiHook([]() -> EGLenum {
return g_eglExports != nullptr && g_eglExports->getCurrentApi != nullptr ? g_eglExports->getCurrentApi()
: EGL_NONE;
});
}
imports->getPlatformDisplay = VendorGetPlatformDisplay;
imports->getSupportsAPI = VendorGetSupportsAPI;
-63
View File
@@ -1,63 +0,0 @@
// MobileGL - MobileGL/MG_Impl/EGLImpl/FrameThrottle.h
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#pragma once
// HOW A WAYLAND WINDOW'S SWAPS ARE PACED. A Wayland compositor tells a client when to draw next with
// wl_surface.frame: the callback is done when the compositor has used the frame - painted it, or
// decided it would not be seen - and a compositor that shows nothing (its output is off, the window
// is hidden) sends none at all. Every commit asks for one (one outstanding at a time), and the swap
// after it may wait:
//
// - swap interval above 0: until the callback is done, however long that takes. An application
// drawing as fast as eglSwapBuffers lets it then draws at the compositor's pace, and stops while
// the compositor shows nothing (what every EGL on Wayland does).
// - swap interval 0: not while the compositor keeps answering - an unpaced application stays
// unpaced. But a callback left unanswered for kStarvedAfterMs means nothing of the window is
// being shown; the swap then waits up to kStarvedWaitMs for it, so an application that draws on
// its own clock (a browser on an animated page) drops to about one frame a second instead of
// burning CPU and GPU on frames nobody sees, and is back at full rate with the first answer.
//
// The bookkeeping, apart from libwayland (WaylandWindow.cpp issues the requests and dispatches).
#include <Includes.h>
namespace MobileGL::MG_Impl::EGLImpl::Wayland {
class FrameThrottle {
public:
static constexpr Int64 kStarvedAfterMs = 200;
static constexpr Int64 kStarvedWaitMs = 1000;
static constexpr Int64 kForever = -1;
// Before a commit: whether it carries a frame request (none is outstanding).
Bool WantsFrameRequest() const { return !m_outstanding; }
// A frame request went with the commit made at `nowMs` (a monotonic clock).
void Requested(Int64 nowMs) {
m_outstanding = true;
m_requestedAtMs = nowMs;
}
// The compositor answered the request (wl_callback.done).
void Done() { m_outstanding = false; }
// Before a swap's frame is drawn into a buffer, at `nowMs`: how long it waits for the
// outstanding callback - 0 = not at all, kForever = until it comes.
Int64 WaitBudgetMs(Int swapInterval, Int64 nowMs) const {
if (!m_outstanding) return 0;
if (swapInterval > 0) return kForever;
return nowMs - m_requestedAtMs >= kStarvedAfterMs ? kStarvedWaitMs : 0;
}
Bool Outstanding() const { return m_outstanding; }
private:
Bool m_outstanding = false;
Int64 m_requestedAtMs = 0;
};
} // namespace MobileGL::MG_Impl::EGLImpl::Wayland
@@ -1,42 +0,0 @@
// MobileGL - MobileGL/MG_Impl/EGLImpl/SharedImageFlushPolicy.h
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#pragma once
// WHEN glFlush IS A SHARED-IMAGE BOUNDARY (docs/Disaggregated/notes/anland/plan-x11-gpu.md).
//
// A dma-buf producer that renders into its buffers and hands them on after a glFlush (an X
// server's glamor committing a window pixmap) relies on implicit sync: whoever samples the buffer
// next is ordered after the flushed work by the kernel. MobileGL's images are ordered by its server
// instead, and the server learns of a write at a boundary - a swap, a present, or this flush. So a
// flush becomes a round trip that publishes the session's accesses, but only in a process for which
// that can matter: it has bound a shared image to a texture, it does not own the server's window
// (the compositor samples client buffers and ends its frames at its swaps), and nobody turned it
// off. MOBILEGL_SHARED_IMAGE_FLUSH_SYNC=1 forces it on (still only with shared images), =0 off.
//
// Header-only and pure: a host test pins the table.
#include <Includes.h>
#include <cstring>
namespace MobileGL::MG_Impl::EGLImpl {
inline Bool FlushPublishesSharedImageAccesses(Bool sharedImagesAvailable, Bool boundSharedImageToTexture,
Bool ownsServerWindow, const char* overrideValue) {
if (!sharedImagesAvailable) return false;
if (overrideValue != nullptr && overrideValue[0] != '\0') {
if (std::strcmp(overrideValue, "0") == 0 || std::strcmp(overrideValue, "off") == 0 ||
std::strcmp(overrideValue, "false") == 0)
return false;
if (std::strcmp(overrideValue, "1") == 0 || std::strcmp(overrideValue, "on") == 0 ||
std::strcmp(overrideValue, "true") == 0)
return true;
}
return boundSharedImageToTexture && !ownsServerWindow;
}
} // namespace MobileGL::MG_Impl::EGLImpl
+5 -157
View File
@@ -7,7 +7,6 @@
// End of Source File Header
#include "WaylandWindow.h"
#include "FrameThrottle.h"
#if MOBILEGL_WAYLAND_WINDOWS
@@ -19,14 +18,12 @@
#include <MG_Impl/GLImpl/RenderState/GL_RenderState.h>
#include <MG_Util/Debug/Log.h>
#include <cerrno>
#include <chrono>
#include <cstdarg>
#include <cstdint>
#include <cstring>
#include <dlfcn.h>
#include <fcntl.h>
#include <mutex>
#include <poll.h>
#include <sys/mman.h>
#include <sys/uio.h>
#include <unistd.h>
@@ -120,7 +117,6 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
constexpr uint32_t kBufferDestroy = 0;
constexpr uint32_t kSurfaceAttach = 1;
constexpr uint32_t kSurfaceDamage = 2;
constexpr uint32_t kSurfaceFrame = 3;
constexpr uint32_t kSurfaceCommit = 6;
constexpr uint32_t kSurfaceDamageBuffer = 9; // since wl_surface version 4
constexpr uint32_t kMarshalFlagDestroy = 1u << 0;
@@ -148,8 +144,6 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
const wl_interface* shmInterface = nullptr;
const wl_interface* shmPoolInterface = nullptr;
const wl_interface* bufferInterface = nullptr;
// Optional: without it a window's swaps are not paced by frame callbacks.
const wl_interface* callbackInterface = nullptr;
wl_proxy* (*marshalFlags)(wl_proxy*, uint32_t, const wl_interface*, uint32_t, uint32_t, ...) = nullptr;
int (*addListener)(wl_proxy*, void (**)(void), void*) = nullptr;
void (*destroy)(wl_proxy*) = nullptr;
@@ -163,11 +157,6 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
int (*dispatchQueue)(void*, wl_event_queue*) = nullptr;
int (*dispatchQueuePending)(void*, wl_event_queue*) = nullptr;
int (*flush)(void*) = nullptr;
// Optional: a bounded wait for a frame callback (FrameThrottle's interval-0 case).
int (*prepareReadQueue)(void*, wl_event_queue*) = nullptr;
int (*getFd)(void*) = nullptr;
int (*readEvents)(void*) = nullptr;
void (*cancelRead)(void*) = nullptr;
};
// Loaded once. RTLD_NOLOAD first: a Wayland client has the library already, and the copy
@@ -185,7 +174,6 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
api.shmInterface = static_cast<const wl_interface*>(sym("wl_shm_interface"));
api.shmPoolInterface = static_cast<const wl_interface*>(sym("wl_shm_pool_interface"));
api.bufferInterface = static_cast<const wl_interface*>(sym("wl_buffer_interface"));
api.callbackInterface = static_cast<const wl_interface*>(sym("wl_callback_interface"));
api.marshalFlags = reinterpret_cast<decltype(api.marshalFlags)>(sym("wl_proxy_marshal_flags"));
api.addListener = reinterpret_cast<decltype(api.addListener)>(sym("wl_proxy_add_listener"));
api.destroy = reinterpret_cast<decltype(api.destroy)>(sym("wl_proxy_destroy"));
@@ -200,11 +188,6 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
api.dispatchQueuePending =
reinterpret_cast<decltype(api.dispatchQueuePending)>(sym("wl_display_dispatch_queue_pending"));
api.flush = reinterpret_cast<decltype(api.flush)>(sym("wl_display_flush"));
api.prepareReadQueue =
reinterpret_cast<decltype(api.prepareReadQueue)>(sym("wl_display_prepare_read_queue"));
api.getFd = reinterpret_cast<decltype(api.getFd)>(sym("wl_display_get_fd"));
api.readEvents = reinterpret_cast<decltype(api.readEvents)>(sym("wl_display_read_events"));
api.cancelRead = reinterpret_cast<decltype(api.cancelRead)>(sym("wl_display_cancel_read"));
api.loaded = api.displayInterface && api.registryInterface && api.shmInterface &&
api.shmPoolInterface && api.bufferInterface && api.marshalFlags && api.addListener && api.destroy &&
api.getVersion && api.createWrapper && api.wrapperDestroy && api.setQueue &&
@@ -345,18 +328,8 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
EGLint committedWidth = 0;
EGLint committedHeight = 0;
// SWAP PACING (FrameThrottle.h). The frame request goes through a wrapper of the
// application's wl_surface that lives on this window's queue, so its callback is
// dispatched here and never by the application.
void* surfaceWrapper = nullptr;
wl_proxy* frameCallback = nullptr;
FrameThrottle throttle;
Int loggedInterval = -1;
~Impl() {
const Api& api = WaylandApi();
if (frameCallback) api.destroy(frameCallback);
if (surfaceWrapper) api.wrapperDestroy(surfaceWrapper);
for (auto& buffer : buffers) Release(buffer);
for (auto& buffer : dmabufBuffers) Release(buffer);
if (dmabuf) api.marshalFlags(dmabuf, kDmabufDestroy, nullptr, api.getVersion(dmabuf), kMarshalFlagDestroy);
@@ -550,71 +523,6 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
useDmabuf = false;
}
void FrameDone(wl_proxy* callback) {
if (callback != frameCallback) return;
WaylandApi().destroy(callback);
frameCallback = nullptr;
throttle.Done();
}
static Int64 NowMs() {
return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count();
}
// A broken connection answers nothing again; stop pacing on it.
void AbandonFrame() {
if (frameCallback) WaylandApi().destroy(frameCallback);
frameCallback = nullptr;
throttle.Done();
}
// Waits, as FrameThrottle decides, for the callback of the frame before this one: the
// compositor has used that one. It sends none while it shows nothing.
void WaitForFrame(Int swapInterval) {
const Api& api = WaylandApi();
const Int64 budget = throttle.WaitBudgetMs(swapInterval, NowMs());
if (budget == 0) return;
if (budget == FrameThrottle::kForever) {
while (throttle.Outstanding()) {
if (api.dispatchQueue(display, queue) < 0) return AbandonFrame();
}
return;
}
if (!api.prepareReadQueue || !api.getFd || !api.readEvents || !api.cancelRead) return;
const Int64 deadline = NowMs() + budget;
while (throttle.Outstanding()) {
// libwayland's read protocol: whatever is queued first, then one read of the
// socket for this queue, bounded by the deadline.
while (api.prepareReadQueue(display, queue) != 0) {
if (api.dispatchQueuePending(display, queue) < 0) return AbandonFrame();
}
if (!throttle.Outstanding()) {
api.cancelRead(display);
return;
}
api.flush(display);
const Int64 remaining = deadline - NowMs();
if (remaining <= 0) {
api.cancelRead(display);
return;
}
pollfd fd{api.getFd(display), POLLIN, 0};
const int ready = poll(&fd, 1, static_cast<int>(remaining));
if (ready <= 0) {
api.cancelRead(display);
if (ready < 0 && errno == EINTR) continue;
return;
}
if (api.readEvents(display) < 0) return AbandonFrame();
if (api.dispatchQueuePending(display, queue) < 0) return AbandonFrame();
}
}
// The next commit asks for a frame callback (none outstanding).
void RequestFrame(wl_proxy* surface);
// `wlBuffer` becomes the window's content: attach, damage, commit. `damage` is the frame's
// (GL window coordinates); a buffer's rows run top-down, so each rectangle is flipped. A
// compositor without damage_buffer (wl_surface < 4), a new size or the first commit is
@@ -623,7 +531,6 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
const Api& api = WaylandApi();
wl_proxy* surface = window->surface;
const uint32_t surfaceVersion = api.getVersion(surface);
RequestFrame(surface);
api.marshalFlags(surface, kSurfaceAttach, nullptr, surfaceVersion, 0, wlBuffer, window->dx, window->dy);
const Bool whole = damage.IsFull() || surfaceVersion < 4 || committedWidth != width ||
committedHeight != height || window->dx != 0 || window->dy != 0;
@@ -674,11 +581,6 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
void (*const kRegistryListener[])(void) = {reinterpret_cast<void (*)(void)>(&OnRegistryGlobal),
reinterpret_cast<void (*)(void)>(&OnRegistryGlobalRemove)};
void OnFrameDone(void* data, wl_proxy* callback, uint32_t) {
static_cast<WindowSurface::Impl*>(data)->FrameDone(callback);
}
void (*const kFrameListener[])(void) = {reinterpret_cast<void (*)(void)>(&OnFrameDone)};
// The application destroyed its wl_egl_window first: nothing may be read from it after this.
void OnWindowDestroyed(void* data) { static_cast<WindowSurface::Impl*>(data)->window = nullptr; }
} // namespace
@@ -725,22 +627,6 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
return eglWindow->width > 0 && eglWindow->height > 0;
}
void WindowSurface::Impl::RequestFrame(wl_proxy* surface) {
const Api& api = WaylandApi();
if (api.callbackInterface == nullptr || !throttle.WantsFrameRequest()) return;
if (surfaceWrapper == nullptr) {
surfaceWrapper = api.createWrapper(surface);
if (surfaceWrapper == nullptr) return;
api.setQueue(static_cast<wl_proxy*>(surfaceWrapper), queue);
}
auto* wrapper = static_cast<wl_proxy*>(surfaceWrapper);
frameCallback = api.marshalFlags(wrapper, kSurfaceFrame, api.callbackInterface, api.getVersion(wrapper), 0,
nullptr);
if (frameCallback == nullptr) return;
api.addListener(frameCallback, const_cast<void (**)(void)>(kFrameListener), this);
throttle.Requested(NowMs());
}
WindowSurface::WindowSurface(UniquePtr<Impl> impl) : m_impl(std::move(impl)) {}
WindowSurface::~WindowSurface() = default;
@@ -806,42 +692,9 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
return true;
}
void WindowSurface::OnSessionReplaced() {
Bool WindowSurface::Present(const MG_Util::Damage::Region& damage) {
Impl& impl = *m_impl;
const Api& api = WaylandApi();
for (auto& buffer : impl.dmabufBuffers) {
if (buffer.buffer) {
api.marshalFlags(buffer.buffer, kBufferDestroy, nullptr, api.getVersion(buffer.buffer),
kMarshalFlagDestroy);
}
buffer = DmabufBuffer{};
}
impl.dmabufDamage.InvalidateAll();
// The linux-dmabuf global is still bound (FallBackToShm keeps it); a window that never had
// it, or gave it up at creation because nothing could be allocated, stays on wl_shm.
impl.useDmabuf = impl.dmabufWanted && impl.dmabuf != nullptr;
}
void WindowSurface::CommitPendingState() {
Impl& impl = *m_impl;
if (impl.window == nullptr || impl.window->surface == nullptr) return;
const Api& api = WaylandApi();
wl_proxy* surface = impl.window->surface;
api.marshalFlags(surface, kSurfaceCommit, nullptr, api.getVersion(surface), 0);
api.flush(impl.display);
}
WindowSurface::PresentResult WindowSurface::Present(const MG_Util::Damage::Region& damage, Int swapInterval,
Bool (*sessionLost)()) {
Impl& impl = *m_impl;
if (impl.window == nullptr) return PresentResult::kNotShown;
if (swapInterval != impl.loggedInterval) {
MGLOG_I("Wayland: window surface %dx%d swaps with interval %d (%s)", impl.width, impl.height,
static_cast<int>(swapInterval),
swapInterval > 0 ? "paced by frame callbacks" : "unpaced while the compositor shows it");
impl.loggedInterval = swapInterval;
}
impl.WaitForFrame(swapInterval);
if (impl.window == nullptr) return false;
if (impl.useDmabuf) {
// The server copies the frame into the image GPU-side, top row first - a wl_buffer's
@@ -856,12 +709,9 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
if (backendObject->PresentToSharedImage(buffer->imageId, copy)) {
impl.Commit(buffer->buffer, damage);
buffer->busy = true;
return PresentResult::kPresented;
return true;
}
}
// The image went with a lost server: the window keeps its shared images (a fresh
// session replaces them, OnSessionReplaced) and shows no frame of the lost device.
if (sessionLost != nullptr && sessionLost()) return PresentResult::kLost;
MGLOG_E_ONCE("Wayland: a frame could not be presented through a linux-dmabuf shared image; the window "
"falls back to wl_shm");
impl.FallBackToShm();
@@ -870,17 +720,15 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
ShmBuffer* buffer = impl.NextFree();
if (buffer == nullptr) {
MGLOG_E_ONCE("Wayland: no wl_shm buffer could be taken for the frame; it is not shown");
return PresentResult::kNotShown;
return false;
}
// GL's rows run bottom-up and RGBA; a wl_shm buffer's run top-down and B, G, R, A.
ReadBackFrameBGRA(impl.width, impl.height, impl.scratch, static_cast<Uint8*>(buffer->map),
static_cast<SizeT>(buffer->stride));
// A read-back the device was lost under answered zeros: the buffer stays free.
if (sessionLost != nullptr && sessionLost()) return PresentResult::kLost;
impl.Commit(buffer->buffer, MG_Util::Damage::Region::Full());
buffer->busy = true;
return PresentResult::kPresented;
return true;
}
} // namespace MobileGL::MG_Impl::EGLImpl::Wayland
+3 -25
View File
@@ -75,42 +75,20 @@ namespace MobileGL::MG_Impl::EGLImpl::Wayland {
// Puts the current context's default-framebuffer frame on the window: copied into a
// shared image (or read back into a wl_shm buffer, the application's read-framebuffer and
// pack state put back exactly as they were), then attach, damage, commit. A shared-image
// present that fails moves the window to wl_shm for good. kNotShown (logged) when the
// frame did not reach the window; the swap itself goes on regardless.
// present that fails moves the window to wl_shm for good. False (logged) when the frame
// did not reach the window; the swap itself goes on regardless.
//
// `damage` (GL window coordinates, clipped to the window; Full = all of it) is what the
// frame changed. A shared image is copied only where it differs from the frame - the
// frame's damage and every frame's since that image was last written - and the surface is
// damaged only where the frame changed, flipped to the buffer's top-left origin.
//
// `swapInterval` above 0 paces the swaps by the compositor's frame callbacks: this waits
// for the previous frame's before taking a buffer (FrameThrottle.h).
//
// `sessionLost` (may be null) says whether the device was lost under the frame. A frame
// that failed - or was read back - on a lost device is nothing but zeros: kLost, with no
// buffer attached and the window left where it was, so the caller reports the loss at
// this swap instead of showing a transparent window that the toolkit never redraws.
enum class PresentResult { kPresented, kNotShown, kLost };
PresentResult Present(const MG_Util::Damage::Region& damage, Int swapInterval, Bool (*sessionLost)());
Bool Present(const MG_Util::Damage::Region& damage);
// wl_egl_window_resize's effect, taken: true (with the new size) when the application gave
// its wl_egl_window a size this presentation is not at yet. The presentation adopts it -
// its next buffer is that size - and the caller resizes the drawable behind it.
Bool TakeResize(EGLint* width, EGLint* height);
// A swap that presents nothing (its context was lost) still commits the application's
// wl_surface, with no new buffer: the frame callback a toolkit asked for just before the
// swap is surface state that only a commit applies, and a toolkit that waits for it before
// drawing again would never draw again - not even to find out that it has to rebuild.
void CommitPendingState();
// The server session that allocated this window's shared images was lost and a fresh one
// replaced it: the images went with their server. Their wl_buffers are destroyed here,
// nothing is released (the fresh server never issued those ids), and the window goes
// back to shared images - allocated anew, on the fresh server, at the next present - if
// it was using them, or had fallen back to wl_shm only for a present the loss broke.
void OnSessionReplaced();
struct Impl;
private:
@@ -123,8 +123,6 @@ MOBILEGL_GL_API void glFinish() {
MGLOG_D("Implementing function: %s(...)", __FUNCTION__);
const MobileGL::MG_Impl::EGLImpl::GLStreamScope mglStreamScope;
#if MOBILEGL_BUILD_DISAGGREGATED
// A shared-image producer's boundary first (implicit sync; EGLImpl/SharedImageFlushPolicy.h).
MobileGL::MG_Impl::EGLImpl::FlushSharedImageAccesses();
MobileGL::MG_Pipe::MGPipeClientFinish();
#endif
}
@@ -132,7 +130,6 @@ MOBILEGL_GL_API void glFlush() {
MGLOG_D("Implementing function: %s(...)", __FUNCTION__);
const MobileGL::MG_Impl::EGLImpl::GLStreamScope mglStreamScope;
#if MOBILEGL_BUILD_DISAGGREGATED
MobileGL::MG_Impl::EGLImpl::FlushSharedImageAccesses();
MobileGL::MG_Pipe::MGPipeClientFlush();
#endif
}
@@ -435,9 +432,9 @@ DECLARE_GL_FUNCTION_HEAD(void, FramebufferTexture, GLenum target, GLenum attachm
DECLARE_GL_FUNCTION_STUB_HEAD(void, PrimitiveBoundingBox, GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PrimitiveBoundingBox, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW)
DECLARE_GL_FUNCTION_HEAD(GLenum, GetGraphicsResetStatus) DECLARE_GL_FUNCTION_END(GLenum, GetGraphicsResetStatus)
DECLARE_GL_FUNCTION_HEAD(void, ReadnPixels, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ReadnPixels, x, y, width, height, format, type, bufSize, data)
DECLARE_GL_FUNCTION_HEAD(void, GetnUniformfv, GLuint program, GLint location, GLsizei bufSize, GLfloat* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetnUniformfv, program, location, bufSize, params)
DECLARE_GL_FUNCTION_HEAD(void, GetnUniformiv, GLuint program, GLint location, GLsizei bufSize, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetnUniformiv, program, location, bufSize, params)
DECLARE_GL_FUNCTION_HEAD(void, GetnUniformuiv, GLuint program, GLint location, GLsizei bufSize, GLuint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetnUniformuiv, program, location, bufSize, params)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnUniformfv, GLuint program, GLint location, GLsizei bufSize, GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnUniformfv, program, location, bufSize, params)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnUniformiv, GLuint program, GLint location, GLsizei bufSize, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnUniformiv, program, location, bufSize, params)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnUniformuiv, GLuint program, GLint location, GLsizei bufSize, GLuint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnUniformuiv, program, location, bufSize, params)
DECLARE_GL_FUNCTION_HEAD(void, MinSampleShading, GLfloat value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MinSampleShading, value)
DECLARE_GL_FUNCTION_HEAD(void, PatchParameteri, GLenum pname, GLint value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, PatchParameteri, pname, value)
DECLARE_GL_FUNCTION_HEAD(void, TexParameterIiv, GLenum target, GLenum pname, const GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TexParameterIiv, target, pname, params)
@@ -1121,7 +1118,7 @@ DECLARE_GL_FUNCTION_HEAD(void, GetTextureSubImage, GLuint texture, GLint level,
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetCompressedTextureSubImage, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetCompressedTextureSubImage, texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnCompressedTexImage, GLenum target, GLint lod, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnCompressedTexImage, target, lod, bufSize, pixels)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnTexImage, GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnTexImage, target, level, format, type, bufSize, pixels)
DECLARE_GL_FUNCTION_HEAD(void, GetnUniformdv, GLuint program, GLint location, GLsizei bufSize, GLdouble* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetnUniformdv, program, location, bufSize, params)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnUniformdv, GLuint program, GLint location, GLsizei bufSize, GLdouble* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnUniformdv, program, location, bufSize, params)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnMapdv, GLenum target, GLenum query, GLsizei bufSize, GLdouble* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnMapdv, target, query, bufSize, v)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnMapfv, GLenum target, GLenum query, GLsizei bufSize, GLfloat* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnMapfv, target, query, bufSize, v)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnMapiv, GLenum target, GLenum query, GLsizei bufSize, GLint* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnMapiv, target, query, bufSize, v)
@@ -1292,6 +1289,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, PointParameterfARB, GLenum pname, GLfloat pa
DECLARE_GL_FUNCTION_STUB_HEAD(void, PointParameterfvARB, GLenum pname, const GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PointParameterfvARB, pname, params)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnTexImageARB, GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* img) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnTexImageARB, target, level, format, type, bufSize, img)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnCompressedTexImageARB, GLenum target, GLint lod, GLsizei bufSize, void* img) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnCompressedTexImageARB, target, lod, bufSize, img)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnUniformdvARB, GLuint program, GLint location, GLsizei bufSize, GLdouble* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnUniformdvARB, program, location, bufSize, params)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnMapdvARB, GLenum target, GLenum query, GLsizei bufSize, GLdouble* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnMapdvARB, target, query, bufSize, v)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnMapfvARB, GLenum target, GLenum query, GLsizei bufSize, GLfloat* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnMapfvARB, target, query, bufSize, v)
DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnMapivARB, GLenum target, GLenum query, GLsizei bufSize, GLint* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnMapivARB, target, query, bufSize, v)
@@ -2992,50 +2990,6 @@ MOBILEGL_GL_API void glGetnUniformuivARB(GLuint program, GLint location, GLsizei
glGetnUniformuiv(program, location, bufSize, params);
}
MOBILEGL_GL_API void glGetnUniformdvARB(GLuint program, GLint location, GLsizei bufSize, GLdouble* params) {
glGetnUniformdv(program, location, bufSize, params);
}
// KHR_robustness and EXT_robustness name the same entry points with their own suffixes (an ES
// application, ANGLE's GL backend among them, looks them up by those names).
MOBILEGL_GL_API GLenum glGetGraphicsResetStatusKHR(void) {
return glGetGraphicsResetStatus();
}
MOBILEGL_GL_API GLenum glGetGraphicsResetStatusEXT(void) {
return glGetGraphicsResetStatus();
}
MOBILEGL_GL_API void glReadnPixelsKHR(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
GLsizei bufSize, void* data) {
glReadnPixels(x, y, width, height, format, type, bufSize, data);
}
MOBILEGL_GL_API void glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
GLsizei bufSize, void* data) {
glReadnPixels(x, y, width, height, format, type, bufSize, data);
}
MOBILEGL_GL_API void glGetnUniformfvKHR(GLuint program, GLint location, GLsizei bufSize, GLfloat* params) {
glGetnUniformfv(program, location, bufSize, params);
}
MOBILEGL_GL_API void glGetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, GLfloat* params) {
glGetnUniformfv(program, location, bufSize, params);
}
MOBILEGL_GL_API void glGetnUniformivKHR(GLuint program, GLint location, GLsizei bufSize, GLint* params) {
glGetnUniformiv(program, location, bufSize, params);
}
MOBILEGL_GL_API void glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint* params) {
glGetnUniformiv(program, location, bufSize, params);
}
MOBILEGL_GL_API void glGetnUniformuivKHR(GLuint program, GLint location, GLsizei bufSize, GLuint* params) {
glGetnUniformuiv(program, location, bufSize, params);
}
MOBILEGL_GL_API void glGetObjectLabelEXT(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length,
GLchar* label) {
glGetObjectLabel(identifier, name, bufSize, length, label);
+15 -146
View File
@@ -592,90 +592,12 @@ namespace MobileGL::MG_Impl::GLImpl {
}
namespace {
// Extensions this library implements itself, appended after the backend's own list (the
// server's, under split), which cannot know about them:
// * GL_OES_EGL_image binds the EGL side's dma-buf images, which only a backend with
// shared images has (EGLImpl::SharedImagesAvailable);
// * the robustness family - reset notification (glGetGraphicsResetStatus, the contexts'
// EGL reset strategy, GL_CONTEXT_LOST) and the bounded queries (glReadnPixels,
// glGetnUniform*) are this frontend's, whatever the backend. KHR for GL and ES, ARB for
// GL applications that ask for that name, EXT for ES applications that ask for that one.
// Robust buffer ACCESS is a separate promise (GL_CONTEXT_ROBUST_ACCESS) and is not
// implied by any of them.
// One list for glGetString and glGetStringi, so the two forms always agree.
Bool EsIdentityActive();
const Vector<const char*>& ClientSideExtensions() {
static const Vector<const char*> withImages = {"GL_OES_EGL_image", "GL_KHR_robustness",
"GL_ARB_robustness", "GL_EXT_robustness"};
static const Vector<const char*> withoutImages = {"GL_KHR_robustness", "GL_ARB_robustness",
"GL_EXT_robustness"};
// Under the ES identity (EsIdentityActive) the ES names of what desktop GL has in core:
// BGRA textures, render targets and read-backs. GL_BGRA_EXT / GL_BGRA8_EXT as internal
// formats are taken as RGBA storage (TextureEnumConverter), the byte order being the
// pixel transfer format's, as on desktop GL.
static const Vector<const char*> esWithImages = {
"GL_OES_EGL_image", "GL_KHR_robustness", "GL_ARB_robustness",
"GL_EXT_robustness", "GL_EXT_texture_format_BGRA8888", "GL_EXT_read_format_bgra"};
static const Vector<const char*> esWithoutImages = {"GL_KHR_robustness", "GL_ARB_robustness",
"GL_EXT_robustness", "GL_EXT_texture_format_BGRA8888",
"GL_EXT_read_format_bgra"};
const Bool images = MG_Impl::EGLImpl::SharedImagesAvailable();
if (EsIdentityActive()) return images ? esWithImages : esWithoutImages;
return images ? withImages : withoutImages;
// GL_OES_EGL_image binds the EGL side's dma-buf images, which only a backend with shared
// images has (EGLImpl::SharedImagesAvailable). The backend's own list - the server's,
// under split - cannot know that, so the extension is appended after it.
const char* ClientSideExtension() {
return MG_Impl::EGLImpl::SharedImagesAvailable() ? "GL_OES_EGL_image" : nullptr;
}
// Robust buffer access as GL 4.5 / KHR_robust_buffer_access_behavior define it: the backend
// promises it by listing one of the behavior extensions. Neither backend does today, so a
// context that asked for robust access gets it reported as absent rather than claimed.
Bool BackendProvidesRobustBufferAccess() {
const auto& backend = MG_Backend::pActiveBackendObject;
if (!backend) return false;
const auto& extensions = backend->GetRendererInfo().RendererGLInfo.Extensions;
return std::find(extensions.begin(), extensions.end(), E_GL_KHR_robust_buffer_access_behavior) !=
extensions.end() ||
std::find(extensions.begin(), extensions.end(), E_GL_ARB_robust_buffer_access_behavior) !=
extensions.end();
}
// MOBILEGL_ES_CONTEXT_IDENTITY=1: a context created for the OpenGL ES API names itself OpenGL
// ES 3.2 (GL_VERSION, GL_SHADING_LANGUAGE_VERSION, GL_MAJOR/MINOR_VERSION) instead of the
// desktop version every context reports by default. Opt-in, for an application that
// decides what it may use from that identity: ANGLE's GL-on-EGL backend offers
// GL_OES_EGL_image - which Chrome's GPU process presents through - only over a native
// driver that calls itself OpenGL ES, and reads the desktop identity's extension names
// otherwise.
Bool EsIdentityActive() {
static const Bool requested = [] {
const char* value = std::getenv("MOBILEGL_ES_CONTEXT_IDENTITY");
return value != nullptr && value[0] == '1';
}();
return requested && MG_State::pEGLContext &&
MG_State::pEGLContext->GetCurrentContextClientAPI() == EGL_OPENGL_ES_API;
}
Bool CurrentContextHasRobustAccess() {
return MG_State::pEGLContext && MG_State::pEGLContext->IsCurrentContextRobustAccessRequested() &&
BackendProvidesRobustBufferAccess();
}
#if MOBILEGL_BUILD_DISAGGREGATED
// KHR_robustness 2.6.1: a context whose reset notification behavior is
// NO_RESET_NOTIFICATION is never told of a reset - glGetGraphicsResetStatus answers
// GL_NO_ERROR and no command raises GL_CONTEXT_LOST. That is what an explicit core-profile
// context gets. Everywhere else (MG_State::IsRelaxedSemanticsActive) the loss is reported
// to every context, as before the strategy existed: an application that queries the reset
// status without having asked for notification still learns that its context is gone,
// which on a split client it is - there is nothing to recover in place. A context created
// with EGL_LOSE_CONTEXT_ON_RESET is always told.
Bool ResetIsNotified() {
if (MG_State::pEGLContext &&
MG_State::pEGLContext->GetCurrentContextResetNotificationStrategy() == EGL_LOSE_CONTEXT_ON_RESET) {
return true;
}
return MG_State::IsRelaxedSemanticsActive();
}
#endif
} // namespace
/* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
@@ -713,12 +635,6 @@ namespace MobileGL::MG_Impl::GLImpl {
if (const auto at = backendName.find("OpenGL ES"); at != String::npos) {
backendName.replace(at, sizeof("OpenGL ES") - 1, "GLES");
}
if (EsIdentityActive()) {
versionStr = std::format("OpenGL ES 3.2 {} {}, {} Backend, GIT@" GIT_COMMIT_HASH_SHORT, MG_Config::ProjectName,
MG_Config::CoreVersion.toFormattedString(MG_Config::DefaultVersionStringFormatAttrib),
backendName);
return (const GLubyte*)versionStr.c_str();
}
versionStr =
std::format("{} {} {}, {} Backend, GIT@" GIT_COMMIT_HASH_SHORT,
rendererInfo.RendererGLInfo.TargetGLVersion.toString(), MG_Config::ProjectName,
@@ -735,7 +651,6 @@ namespace MobileGL::MG_Impl::GLImpl {
return (const GLubyte*)rendererString.c_str();
}
case GL_SHADING_LANGUAGE_VERSION:
if (EsIdentityActive()) return (const GLubyte*)"OpenGL ES GLSL ES 3.20";
shadingLanguageVersion =
std::format("{} {}", rendererInfo.RendererGLInfo.TargetGLSLVersion.toString({true, false}),
MG_Config::ProjectName);
@@ -749,7 +664,7 @@ namespace MobileGL::MG_Impl::GLImpl {
}
extensionsString += MG_Util::ConvertGLExtToString(ext);
}
for (const char* extra : ClientSideExtensions()) {
if (const char* extra = ClientSideExtension()) {
if (!extensionsString.empty()) extensionsString += " ";
extensionsString += extra;
}
@@ -773,9 +688,8 @@ namespace MobileGL::MG_Impl::GLImpl {
const auto& rendererInfo = activeBackendObject->GetRendererInfo();
const auto& exts = rendererInfo.RendererGLInfo.Extensions;
if (index >= exts.size()) {
const auto& extras = ClientSideExtensions();
if (index - exts.size() < extras.size()) return (const GLubyte*)extras[index - exts.size()];
if (index == exts.size()) {
if (const char* extra = ClientSideExtension()) return (const GLubyte*)extra;
}
if (index >= exts.size()) {
return nullptr;
@@ -1761,20 +1675,8 @@ namespace MobileGL::MG_Impl::GLImpl {
return;
case GL_CONTEXT_FLAGS: {
*params = MG_State::pEGLContext ? MG_State::pEGLContext->GetCurrentContextFlags() : 0;
if (CurrentContextHasRobustAccess()) *params |= GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT;
return;
}
case GL_CONTEXT_ROBUST_ACCESS:
// GL ES 3.2 / KHR_robustness: true only where it was asked for AND is provided.
*params = CurrentContextHasRobustAccess() ? GL_TRUE : GL_FALSE;
return;
case GL_RESET_NOTIFICATION_STRATEGY:
// The EGL reset notification behavior the context was created with.
*params = MG_State::pEGLContext && MG_State::pEGLContext->GetCurrentContextResetNotificationStrategy() ==
EGL_LOSE_CONTEXT_ON_RESET
? GL_LOSE_CONTEXT_ON_RESET
: GL_NO_RESET_NOTIFICATION;
return;
case GL_CULL_FACE:
*params = MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::CullFace) ? GL_TRUE : GL_FALSE;
return;
@@ -2620,7 +2522,7 @@ namespace MobileGL::MG_Impl::GLImpl {
GetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 2, &params[2]);
break;
case GL_MAJOR_VERSION:
*params = EsIdentityActive() ? 3 : rendererInfo.RendererGLInfo.TargetGLVersion.Major;
*params = rendererInfo.RendererGLInfo.TargetGLVersion.Major;
break;
case GL_MAX_3D_TEXTURE_SIZE:
*params = dynamicParameters.Max3DTextureSize;
@@ -2907,10 +2809,11 @@ namespace MobileGL::MG_Impl::GLImpl {
*params = static_cast<GLint>(RenderStateParameters::MAX_VIEWPORTS);
break;
case GL_MINOR_VERSION:
*params = EsIdentityActive() ? 2 : rendererInfo.RendererGLInfo.TargetGLVersion.Minor;
*params = rendererInfo.RendererGLInfo.TargetGLVersion.Minor;
break;
case GL_NUM_EXTENSIONS:
*params = static_cast<Int>(rendererInfo.RendererGLInfo.Extensions.size() + ClientSideExtensions().size());
*params = static_cast<Int>(rendererInfo.RendererGLInfo.Extensions.size()) +
(ClientSideExtension() != nullptr ? 1 : 0);
break;
case GL_POINT_SIZE_GRANULARITY:
*params = static_cast<GLint>(dynamicParameters.PointSizeGranularity);
@@ -2975,18 +2878,6 @@ namespace MobileGL::MG_Impl::GLImpl {
}
GLenum GetError() {
#if MOBILEGL_BUILD_DISAGGREGATED
// KHR_robustness: a lost context's commands generate GL_CONTEXT_LOST. Reported ONCE per
// context and ahead of whatever else is queued, so an application that learns of the loss
// from glGetError (Chromium's decoder does) learns of it, and one that drains errors in a
// loop until GL_NO_ERROR still terminates.
// Only where the reset is notified at all (ResetIsNotified: not on a NO_RESET_NOTIFICATION
// explicit core-profile context).
if (MG_Remote::Client::ClientSession::DeviceLost() && MG_State::pGLContext && ResetIsNotified() &&
MG_State::pGLContext->TakeContextLostReport()) {
return GL_CONTEXT_LOST;
}
#endif
auto error = MG_State::pGLContext->PopGLError();
if (!error || !error->get()) {
return GL_NO_ERROR;
@@ -3006,35 +2897,13 @@ namespace MobileGL::MG_Impl::GLImpl {
//
// GL_UNKNOWN_CONTEXT_RESET, not GUILTY or INNOCENT. Those two assign BLAME - guilty
// means this context's commands caused the reset, innocent means another context's did -
// and neither is knowable here:
// * a session ends for a fault the server names by FAMILY only (BackendDeviceLost, a
// protocol fault, ...) or by hanging up; nothing it sends attributes the fault to a
// context, and a hangup is a server death, not a GPU reset at all;
// * a GPU device loss is not attributable either: Vulkan's device loss carries no
// culprit, and the host GL driver's own GUILTY/INNOCENT (which Espryt reads when it
// latches) is about whichever backend context the server had current, while the
// session ends as a whole - every context of it is lost with that one;
// * INNOCENT would mean another context's fault reset this one, but a loss ends exactly
// the session that faulted (every other session keeps running), so the contexts that
// see it are all in the faulting session.
// UNKNOWN is the spec's answer for exactly that, and it is the one that does not lie. The
// cause - the latch's words, with the fault family where the server named one - is
// logged once per context, the first time its reset is reported.
//
// The status does not go back to GL_NO_ERROR: the context stays lost (KHR_robustness
// allows a reset status to be returned repeatedly while the reset "is in progress", and
// this one never completes - the context has to be recreated, which puts it on a fresh
// session).
// and neither is knowable here: the server died for a reason that never crossed the
// wire, and it could as easily have been a driver fault as this client's draw. UNKNOWN is
// the spec's answer for exactly that, and it is the one that does not lie.
//
// WHOLLY INSIDE THE GUARD, including the include above. In a pull build this function is
// byte-for-byte what it was, which is what G1 measures.
if (MG_Remote::Client::ClientSession::DeviceLost()) {
if (!ResetIsNotified()) return GL_NO_ERROR;
if (MG_State::pGLContext && MG_State::pGLContext->TakeResetStatusReport()) {
const String reason = MG_Remote::Client::ClientSession::LastLossReason();
MGLOG_W("glGetGraphicsResetStatus: GL_UNKNOWN_CONTEXT_RESET for a context of a lost session (%s)",
reason.empty() ? "the session was lost" : reason.c_str());
}
return GL_UNKNOWN_CONTEXT_RESET;
}
#endif
@@ -1380,36 +1380,6 @@ namespace MobileGL::MG_Impl::GLImpl {
GetUniformScalar_State(program, location, params);
}
// glGetnUniform* (GL 4.5 core, KHR_robustness): glGetUniform* bounded by bufSize. The query
// writes one value per component of the uniform at `location` (an opaque uniform's unit is
// one), so the bound is that count times the element size; a destination smaller than that -
// a negative bufSize included - is GL_INVALID_OPERATION and nothing is written. Every other
// error is the unbounded query's, raised by it.
template <typename T>
void GetnUniform_State(GLuint program, GLint location, GLsizei bufSize, T* params) {
auto& programObject = TryToGetProgramObject(program);
if (!programObject) return;
if (programObject->GetLinkStatus() && programObject->IsValidUniformLocation(location)) {
SizeT components = 1;
if (!programObject->IsUniformOpaqueAtLocation(location)) {
const auto& type = programObject->GetUniformTypeFacts(location);
components = type.isMatrix ? static_cast<SizeT>(type.matrixCols) * static_cast<SizeT>(type.matrixRows)
: type.isVector ? static_cast<SizeT>(type.vectorSize)
: 1;
}
if (bufSize < 0 || components * sizeof(T) > static_cast<SizeT>(bufSize)) {
MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation,
MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
"the uniform's " + std::to_string(components) +
" component(s) do not fit in bufSize " + std::to_string(bufSize) +
"."));
return;
}
}
GetUniformScalar_State(program, location, params);
}
GLboolean IsProgram_State(GLuint program) {
// Deletion-flagged names stay valid while the object is still GL-visible (program in
// use, shader attached), so name validity is exactly the Is* answer.
@@ -2583,22 +2553,6 @@ namespace MobileGL::MG_Impl::GLImpl {
GetUniformuiv_State(program, location, params);
}
void GetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat* params) {
GetnUniform_State(program, location, bufSize, params);
}
void GetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint* params) {
GetnUniform_State(program, location, bufSize, params);
}
void GetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint* params) {
GetnUniform_State(program, location, bufSize, params);
}
void GetnUniformdv(GLuint program, GLint location, GLsizei bufSize, GLdouble* params) {
GetnUniform_State(program, location, bufSize, params);
}
GLboolean IsProgram(GLuint program) {
return IsProgram_State(program);
}
@@ -46,11 +46,6 @@ namespace MobileGL::MG_Impl::GLImpl {
void GetUniformfv(GLuint program, GLint location, GLfloat* params);
void GetUniformiv(GLuint program, GLint location, GLint* params);
void GetUniformuiv(GLuint program, GLint location, GLuint* params);
// GL 4.5 / KHR_robustness: the queries above, bounded by bufSize.
void GetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat* params);
void GetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint* params);
void GetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint* params);
void GetnUniformdv(GLuint program, GLint location, GLsizei bufSize, GLdouble* params);
GLboolean IsProgram(GLuint program);
GLboolean IsShader(GLuint shader);
void LinkProgram(GLuint program);
@@ -7178,9 +7178,7 @@ namespace MobileGL::MG_Impl::GLImpl {
MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation,
MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "the image could not be bound."));
return;
}
MG_Impl::EGLImpl::NoteSharedImageBoundToTexture();
}
void TexImage1D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format,
+9 -169
View File
@@ -12,11 +12,8 @@
#include "../EGLImpl/EGLImpl.h"
#include "../EGLImpl/WaylandWindow.h"
#include "../GetProcAddress.h"
#include "X11Present.h"
#include "X11PresentXcb.h"
#include <Init.h>
#include <Config.h>
#include <MG_Backend/BackendObjects.h>
namespace MobileGL::MG_Impl::GLXImpl {
namespace {
@@ -75,8 +72,6 @@ namespace MobileGL::MG_Impl::GLXImpl {
// GLX_EXT_swap_control
constexpr int GLX_SWAP_INTERVAL_EXT = 0x20F1;
constexpr int GLX_MAX_SWAP_INTERVAL_EXT = 0x20F2;
// GLX_EXT_buffer_age
constexpr int GLX_BACK_BUFFER_AGE_EXT = 0x20F4;
// GLX_ARB_create_context / _profile / _no_error
constexpr int GLX_CONTEXT_MAJOR_VERSION_ARB = 0x2091;
constexpr int GLX_CONTEXT_MINOR_VERSION_ARB = 0x2092;
@@ -91,15 +86,6 @@ namespace MobileGL::MG_Impl::GLXImpl {
constexpr const char* kGLXExtensions =
"GLX_ARB_create_context GLX_ARB_create_context_no_error GLX_ARB_create_context_profile "
"GLX_ARB_get_proc_address GLX_EXT_swap_control GLX_MESA_swap_control GLX_SGI_swap_control";
// The server answers its surfaces' buffer age (EGL_EXT_buffer_age) when it has shared images.
constexpr const char* kGLXExtensionsWithBufferAge =
"GLX_ARB_create_context GLX_ARB_create_context_no_error GLX_ARB_create_context_profile "
"GLX_ARB_get_proc_address GLX_EXT_swap_control GLX_MESA_swap_control GLX_SGI_swap_control "
"GLX_EXT_buffer_age";
const char* GLXExtensions() {
return EGLImpl::SharedImagesAvailable() ? kGLXExtensionsWithBufferAge : kGLXExtensions;
}
// ---- Xlib access (dlopen'd at runtime, same convention as the backends;
// libX11 is never a link-time dependency of libMobileGL) ----
@@ -244,33 +230,6 @@ namespace MobileGL::MG_Impl::GLXImpl {
const FBConfigInfo* FBConfig = nullptr;
};
// The server's shared images, as X11Present's chain uses them (the GL stream's verbs: the
// caller holds the stream lock, as every GLX entry point does).
class BackendImageSource final : public X11Present::ImageSource {
public:
Bool Allocate(Uint32 width, Uint32 height, Uint32 fourcc, X11Present::Image* out) override {
auto* backend = MG_Backend::pActiveBackendObject.get();
MG_Backend::SharedImageExport image;
if (backend == nullptr || !backend->AllocateSharedImage(width, height, fourcc, &image)) return false;
out->Id = image.Id;
out->Fd = image.Fd;
out->Width = image.Width;
out->Height = image.Height;
out->Stride = image.Stride;
out->Offset = image.Offset;
out->Fourcc = image.Fourcc;
out->Modifier = image.Modifier;
return true;
}
void Release(Uint64 id) override {
if (auto* backend = MG_Backend::pActiveBackendObject.get()) (void)backend->ReleaseSharedImage(id);
}
Bool CopyFrame(Uint64 id, const MG_Util::Damage::Region& region) override {
auto* backend = MG_Backend::pActiveBackendObject.get();
return backend != nullptr && backend->PresentToSharedImage(id, region);
}
};
struct DrawableSurface {
EGLDisplay Display = EGL_NO_DISPLAY;
EGLSurface Surface = EGL_NO_SURFACE;
@@ -285,14 +244,6 @@ namespace MobileGL::MG_Impl::GLXImpl {
Uint32 Gc = 0;
Vector<Uint8> Scratch;
Vector<Uint8> Image;
// How its frames reach the window (chosen at the first swap, X11Present::SelectPath):
// DRI3+Present shared images, or the readback put with MIT-SHM or plain PutImage.
Bool PathChosen = false;
X11Present::Path Path = X11Present::Path::PutImage;
UniquePtr<X11Present::Connection> PresentConnection;
UniquePtr<BackendImageSource> Images;
UniquePtr<X11Present::Chain> Chain;
UniquePtr<X11Present::ShmPresenter> Shm;
};
std::recursive_mutex& RegistryMutex() {
@@ -328,18 +279,8 @@ namespace MobileGL::MG_Impl::GLXImpl {
};
thread_local ThreadCurrent t_current;
// vblank_mode=0 (the benchmark convention X11 GL drivers honour) never waits for the
// display, whatever the application asks; anything else leaves the interval to it.
Bool VblankForcedOff() {
static const Bool off = [] {
const char* mode = std::getenv("vblank_mode");
return mode != nullptr && std::strcmp(mode, "0") == 0;
}();
return off;
}
Int& SwapIntervalShadow() {
static auto* interval = new Int(VblankForcedOff() ? 0 : 1);
static auto* interval = new Int(1);
return *interval;
}
@@ -393,62 +334,10 @@ namespace MobileGL::MG_Impl::GLXImpl {
return true;
}
Int& SwapIntervalShadow();
Int64 SteadyNowMs() {
return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count();
}
// Which way this drawable's frames go, decided once (X11Present::SelectPath), with the
// DRI3 chain set up when that is the way. A chain that cannot be set up falls through to
// the readback paths.
void ChoosePresentPath(GLXDrawableHandle drawable, DrawableSurface& surface, void* connection) {
surface.PathChosen = true;
X11Present::ConnectionCaps caps = X11Present::QueryConnectionCaps(connection);
caps.SharedImages = EGLImpl::SharedImagesAvailable();
const char* override = std::getenv("MOBILEGL_GLX_PRESENT");
surface.Path = X11Present::SelectPath(caps, surface.Depth, override);
if (surface.Path == X11Present::Path::Dri3Present) {
surface.PresentConnection =
X11Present::CreateXcbConnection(connection, static_cast<Uint32>(drawable), caps);
if (surface.PresentConnection) {
surface.Images = MakeUnique<BackendImageSource>();
surface.Chain = MakeUnique<X11Present::Chain>(
*surface.PresentConnection, *surface.Images, surface.Depth, static_cast<Int32>(surface.Width),
static_cast<Int32>(surface.Height), &SteadyNowMs);
} else {
caps.Dri3Major = 0;
surface.Path = X11Present::SelectPath(caps, surface.Depth, override);
}
}
if (surface.Path == X11Present::Path::ShmPutImage) {
surface.Shm = X11Present::CreateShmPresenter(connection);
if (!surface.Shm) surface.Path = X11Present::Path::PutImage;
}
MGLOG_I("glx: window 0x%lx (%ux%u, depth %u) presented through %s (DRI3 %u.%u, Present %u.%u, MIT-SHM "
"%u.%u, %s connection, shared images %s)",
drawable, surface.Width, surface.Height, surface.Depth, X11Present::PathName(surface.Path),
caps.Dri3Major, caps.Dri3Minor, caps.PresentMajor, caps.PresentMinor, caps.ShmMajor, caps.ShmMinor,
caps.LocalConnection ? "local" : "remote", caps.SharedImages ? "yes" : "no");
}
// The chain's resources go (pixmaps freed, images released); the drawable keeps whatever
// readback path is left.
void DropChain(DrawableSurface& surface) {
surface.Chain.reset();
surface.PresentConnection.reset();
surface.Images.reset();
}
// A REMOTE DRAWABLE IS A PBUFFER, AND NOTHING OF IT REACHES THE X WINDOW BY ITSELF: the
// backend draws in another process (another OS), where an XID means nothing. So at every
// swap the frame goes to the window one of three ways (X11Present.h): copied GPU-side into
// a shared image the X server has as a DRI3 pixmap and presented with PresentPixmap - no
// CPU copy at all; or read back and put with MIT-SHM; or read back and put with PutImage,
// the same contract as the Wayland windows' wl_shm presentation. Called with the drawable
// current.
// swap the frame is read back and put on the window with PutImage - the same contract as
// the Wayland windows' wl_shm presentation. Called with the drawable current.
void PresentRemoteDrawable(GLXDrawableHandle drawable, DrawableSurface& surface) {
const EGLImpl::GLStreamScope stream; // the readback is GL records of this thread's context
const auto& xcb = Xcb();
@@ -459,20 +348,6 @@ namespace MobileGL::MG_Impl::GLXImpl {
}
void* connection = xcb.GetXCBConnection(surface.XDisplay);
if (!connection) return;
if (!surface.PathChosen) ChoosePresentPath(drawable, surface, connection);
if (surface.Chain) {
if (surface.Chain->Present(MG_Util::Damage::Region::Full(), SwapIntervalShadow())) return;
if (!surface.Chain->Broken()) return; // the frame is dropped; the chain goes on
MGLOG_I("glx: window 0x%lx leaves DRI3+Present: %s; its frames are read back from now on", drawable,
surface.Chain->BrokenReason());
DropChain(surface);
X11Present::ConnectionCaps caps = X11Present::QueryConnectionCaps(connection);
surface.Path = X11Present::SelectPath(caps, surface.Depth, "readback");
if (surface.Path == X11Present::Path::ShmPutImage) {
surface.Shm = X11Present::CreateShmPresenter(connection);
if (!surface.Shm) surface.Path = X11Present::Path::PutImage;
}
}
if (surface.Gc == 0) {
surface.Gc = xcb.GenerateId(connection);
(void)xcb.CreateGC(connection, surface.Gc, static_cast<Uint32>(drawable), 0, nullptr);
@@ -480,15 +355,6 @@ namespace MobileGL::MG_Impl::GLXImpl {
const EGLint width = static_cast<EGLint>(surface.Width);
const EGLint height = static_cast<EGLint>(surface.Height);
const SizeT rowBytes = static_cast<SizeT>(width) * 4;
if (surface.Shm) {
const Bool put = surface.Shm->Put(
static_cast<Uint32>(drawable), surface.Gc, surface.Depth, width, height,
[&](Uint8* rows, SizeT stride) { EGLImpl::ReadBackFrameBGRA(width, height, surface.Scratch, rows, stride); });
if (put) return;
MGLOG_I("glx: window 0x%lx: MIT-SHM put failed; PutImage from now on", drawable);
surface.Shm.reset();
surface.Path = X11Present::Path::PutImage;
}
surface.Image.resize(rowBytes * static_cast<SizeT>(height));
EGLImpl::ReadBackFrameBGRA(width, height, surface.Scratch, surface.Image.data(), rowBytes);
@@ -508,8 +374,6 @@ namespace MobileGL::MG_Impl::GLXImpl {
}
void ReleaseDrawableSurface(DrawableSurface& surface) {
DropChain(surface);
surface.Shm.reset();
if (surface.Gc != 0 && surface.XDisplay) {
const auto& xcb = Xcb();
if (void* connection = xcb.Valid() ? xcb.GetXCBConnection(surface.XDisplay) : nullptr) {
@@ -544,8 +408,6 @@ namespace MobileGL::MG_Impl::GLXImpl {
static_cast<EGLint>(height))) {
surface.Width = width;
surface.Height = height;
// The shared images follow: the next frame goes into ones of the new size.
if (surface.Chain) surface.Chain->Resize(static_cast<Int32>(width), static_cast<Int32>(height));
}
}
@@ -594,7 +456,7 @@ namespace MobileGL::MG_Impl::GLXImpl {
record.XDisplay = dpy;
record.Depth = depth;
record.LastSizePoll = std::chrono::steady_clock::now();
auto [inserted, _] = surfaces.emplace(drawable, std::move(record));
auto [inserted, _] = surfaces.emplace(drawable, record);
return &inserted->second;
}
@@ -808,7 +670,7 @@ namespace MobileGL::MG_Impl::GLXImpl {
}
const char* QueryExtensionsString(Display*, int) {
return GLXExtensions();
return kGLXExtensions;
}
const char* GetClientString(Display*, int name) {
@@ -818,7 +680,7 @@ namespace MobileGL::MG_Impl::GLXImpl {
case GLX_VERSION:
return "1.4";
case GLX_EXTENSIONS:
return GLXExtensions();
return kGLXExtensions;
default:
return nullptr;
}
@@ -1224,15 +1086,8 @@ namespace MobileGL::MG_Impl::GLXImpl {
PresentRemoteDrawable(drawable, it->second);
}
EGLImpl::SwapBuffers(it->second.Display, it->second.Surface);
// A resize takes effect for the next frame: at once when Present reported one, else at the
// next throttled geometry poll.
Int32 configuredWidth = 0;
Int32 configuredHeight = 0;
const Bool configured =
it->second.Chain && it->second.Chain->TakeConfiguredSize(&configuredWidth, &configuredHeight) &&
(static_cast<Uint32>(configuredWidth) != it->second.Width ||
static_cast<Uint32>(configuredHeight) != it->second.Height);
SyncSurfaceSize(dpy, drawable, it->second, configured);
// A resize takes effect for the next frame.
SyncSurfaceSize(dpy, drawable, it->second);
}
GLXDrawableHandle CreateWindow(Display*, GLXFBConfigHandle config, GLXDrawableHandle window,
@@ -1332,21 +1187,6 @@ namespace MobileGL::MG_Impl::GLXImpl {
case GLX_SWAP_INTERVAL_EXT:
*value = static_cast<unsigned int>(SwapIntervalShadow());
return;
case GLX_BACK_BUFFER_AGE_EXT: {
// GLX_EXT_buffer_age: the age of the buffer the drawable's next frame draws into - the
// server's pbuffer, which keeps its content - asked of the EGL surface behind it, which
// answers only while it is the calling thread's draw surface.
*value = 0;
const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
auto& surfaces = DrawableSurfaces();
auto it = surfaces.find(drawable);
if (it == surfaces.end() || t_current.Draw != drawable) return;
EGLint age = 0;
if (EGLImpl::QuerySurface(it->second.Display, it->second.Surface, EGL_BUFFER_AGE_EXT, &age) && age > 0) {
*value = static_cast<unsigned int>(age);
}
return;
}
case GLX_MAX_SWAP_INTERVAL_EXT:
*value = 4;
return;
@@ -1370,7 +1210,7 @@ namespace MobileGL::MG_Impl::GLXImpl {
return;
}
// MobileGL validates 0..4; adaptive vsync (negative) clamps to regular.
interval = VblankForcedOff() ? 0 : std::clamp(interval, 0, 4);
interval = std::clamp(interval, 0, 4);
EGLImpl::SwapInterval(display, interval);
SwapIntervalShadow() = interval;
}
-284
View File
@@ -1,284 +0,0 @@
// MobileGL - MobileGL/MG_Impl/GLXImpl/X11Present.cpp
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#include "X11Present.h"
#include <cstring>
#if !defined(_WIN32)
#include <unistd.h>
#endif
namespace MobileGL::MG_Impl::GLXImpl::X11Present {
namespace {
void CloseDescriptor(int fd) {
#if !defined(_WIN32)
if (fd >= 0) ::close(fd);
#else
(void)fd;
#endif
}
} // namespace
const char* PathName(Path path) {
switch (path) {
case Path::Dri3Present:
return "DRI3+Present shared images";
case Path::ShmPutImage:
return "readback + MIT-SHM PutImage";
case Path::PutImage:
return "readback + PutImage";
}
return "?";
}
Uint32 FourccForDepth(Uint32 depth) {
switch (depth) {
case 24:
return kFourccXrgb8888;
case 32:
return kFourccArgb8888;
default:
return 0;
}
}
Path SelectPath(const ConnectionCaps& caps, Uint32 depth, const char* overrideValue) {
const Bool putImageOnly = overrideValue != nullptr && std::strcmp(overrideValue, "putimage") == 0;
const Bool noDri3 = putImageOnly || (overrideValue != nullptr && (std::strcmp(overrideValue, "readback") == 0 ||
std::strcmp(overrideValue, "shm") == 0));
if (!noDri3 && caps.SharedImages && caps.LocalConnection && FourccForDepth(depth) != 0 &&
caps.Dri3Major >= 1 && caps.PresentMajor >= 1) {
return Path::Dri3Present;
}
// MIT-SHM 1.2 is the first with a client-made segment passed as a descriptor (no SysV
// shared memory, which a container need not share with the X server).
const Bool shmFd = caps.ShmMajor > 1 || (caps.ShmMajor == 1 && caps.ShmMinor >= 2);
if (!putImageOnly && caps.LocalConnection && shmFd) return Path::ShmPutImage;
return Path::PutImage;
}
Chain::Chain(Connection& connection, ImageSource& images, Uint32 depth, Int32 width, Int32 height,
std::function<Int64()> nowMs)
: m_connection(connection), m_images(images), m_depth(depth), m_fourcc(FourccForDepth(depth)),
m_width(width > 0 ? width : 1), m_height(height > 0 ? height : 1), m_nowMs(std::move(nowMs)) {
if (m_fourcc == 0) Break("the window's depth has no shared-image format");
}
Chain::~Chain() {
for (Buffer& buffer : m_buffers) Drop(buffer);
m_connection.Flush();
}
void Chain::Break(const char* reason) {
if (m_broken) return;
m_broken = true;
m_brokenReason = reason;
}
SizeT Chain::AllocatedBuffers() const {
SizeT count = 0;
for (const Buffer& buffer : m_buffers) count += buffer.Pixmap != 0 ? 1 : 0;
return count;
}
SizeT Chain::BusyBuffers() const {
SizeT count = 0;
for (const Buffer& buffer : m_buffers) count += buffer.Pixmap != 0 && buffer.Busy ? 1 : 0;
return count;
}
void Chain::Drop(Buffer& buffer) {
// The X server keeps a pixmap a pending present still names alive past FreePixmap, and the
// X server's own import of the image holds the image on the MobileGL server: both may go.
if (buffer.Pixmap != 0) m_connection.FreePixmap(buffer.Pixmap);
if (buffer.Storage.Id != 0) m_images.Release(buffer.Storage.Id);
CloseDescriptor(buffer.Storage.Fd);
m_damage.Invalidate(static_cast<SizeT>(&buffer - m_buffers));
buffer = Buffer{};
}
Bool Chain::Allocate(Buffer& buffer) {
Drop(buffer);
Image image;
if (!m_images.Allocate(static_cast<Uint32>(m_width), static_cast<Uint32>(m_height), m_fourcc, &image) ||
image.Id == 0) {
CloseDescriptor(image.Fd);
Break("the server allocated no shared image for the window");
return false;
}
if (image.Fd < 0 || image.Width != static_cast<Uint32>(m_width) || image.Height != static_cast<Uint32>(m_height)) {
CloseDescriptor(image.Fd);
m_images.Release(image.Id);
Break("a shared image came back without a descriptor or at another size");
return false;
}
const Uint32 pixmap = m_connection.ImportPixmap(image, m_depth);
// The pixmap holds the memory now (and the X server's own import, the image).
CloseDescriptor(image.Fd);
image.Fd = -1;
if (pixmap == 0) {
m_images.Release(image.Id);
Break("the X server refused the shared image as a DRI3 pixmap");
return false;
}
buffer.Storage = image;
buffer.Pixmap = pixmap;
buffer.Busy = false;
buffer.Serial = 0;
m_damage.Invalidate(static_cast<SizeT>(&buffer - m_buffers));
return true;
}
void Chain::Handle(const Event& event) {
switch (event.Type) {
case Event::Kind::Idle:
for (Buffer& buffer : m_buffers) {
if (buffer.Pixmap != 0 && buffer.Pixmap == event.Pixmap) buffer.Busy = false;
}
break;
case Event::Kind::Complete:
if (event.Msc != 0) m_lastMsc = event.Msc;
if (m_throttle.Outstanding() && event.Serial == m_awaitedSerial) m_throttle.Done();
break;
case Event::Kind::Configure:
if (event.WindowDestroyed) {
Break("the window was destroyed");
break;
}
if (event.Width > 0 && event.Height > 0) {
m_configured = true;
m_configuredWidth = event.Width;
m_configuredHeight = event.Height;
}
break;
case Event::Kind::None:
break;
}
}
void Chain::DrainEvents() {
Event event;
while (m_connection.PollEvent(&event)) Handle(event);
}
void Chain::WaitForPacing(Int swapInterval) {
const Int64 budget = m_throttle.WaitBudgetMs(swapInterval, m_nowMs());
if (budget == 0) return;
const Int64 limit = budget == EGLImpl::Wayland::FrameThrottle::kForever ? kCompleteGiveUpMs : budget;
const Int64 deadline = m_nowMs() + limit;
Event event;
while (m_throttle.Outstanding() && !m_broken) {
const Int64 remaining = deadline - m_nowMs();
if (remaining <= 0) {
// Interval 0's bounded wait simply ends; a paced wait gives the completion up so a
// server that lost it does not stall the application forever.
if (budget == EGLImpl::Wayland::FrameThrottle::kForever) m_throttle.Done();
return;
}
if (m_connection.WaitEvent(&event, remaining)) Handle(event);
}
}
Chain::Buffer* Chain::NextFree() {
const Int64 deadline = m_nowMs() + kIdleWaitMs;
for (;;) {
if (m_broken) return nullptr;
// The free buffer presented longest ago, so the images take turns.
Buffer* best = nullptr;
for (Buffer& buffer : m_buffers) {
if (buffer.Pixmap == 0 || buffer.Busy) continue;
if (best == nullptr || buffer.Serial < best->Serial) best = &buffer;
}
if (best != nullptr) {
const Bool sized = best->Storage.Width == static_cast<Uint32>(m_width) &&
best->Storage.Height == static_cast<Uint32>(m_height);
if (sized || Allocate(*best)) return best;
return nullptr;
}
SizeT allocated = AllocatedBuffers();
if (allocated < kBuffers) {
for (Buffer& buffer : m_buffers) {
if (buffer.Pixmap == 0) return Allocate(buffer) ? &buffer : nullptr;
}
}
// Every buffer is with the X server: wait for one to come back.
const Int64 remaining = deadline - m_nowMs();
Event event;
if (remaining > 0 && m_connection.WaitEvent(&event, remaining)) {
Handle(event);
continue;
}
// None came back in time: one more buffer, up to the limit; past it the frame is
// dropped (the chain is not broken: the server may just be slow).
if (allocated < kMaxBuffers) {
for (Buffer& buffer : m_buffers) {
if (buffer.Pixmap == 0) return Allocate(buffer) ? &buffer : nullptr;
}
}
return nullptr;
}
}
Bool Chain::Present(const MG_Util::Damage::Region& damage, Int swapInterval) {
if (m_broken) return false;
DrainEvents();
if (m_connection.PresentFailed()) Break("the X server refused a PresentPixmap");
if (m_broken) return false;
WaitForPacing(swapInterval);
if (m_broken) return false;
Buffer* buffer = NextFree();
if (buffer == nullptr) return false;
const SizeT index = static_cast<SizeT>(buffer - m_buffers);
const MG_Util::Damage::Region copy = m_damage.TakeForWrite(index, damage, m_width, m_height);
if (!m_images.CopyFrame(buffer->Storage.Id, copy)) {
Break("the frame could not be copied into a shared image");
return false;
}
const Uint32 serial = ++m_serial;
const Uint32 options = swapInterval > 0 ? 0u : kPresentOptionAsync;
const Uint64 targetMsc = swapInterval > 0 && m_lastMsc != 0 ? m_lastMsc + static_cast<Uint64>(swapInterval) : 0;
MG_Util::Damage::Region update = MG_Util::Damage::Region::Full();
if (!damage.IsFull()) update = damage.FlippedY(m_height);
if (!m_connection.PresentPixmap(buffer->Pixmap, serial, options, targetMsc, update)) {
Break("PresentPixmap could not be sent");
return false;
}
buffer->Busy = true;
buffer->Serial = serial;
if (m_throttle.WantsFrameRequest()) {
m_throttle.Requested(m_nowMs());
m_awaitedSerial = serial;
}
m_connection.Flush();
++m_framesPresented;
return true;
}
void Chain::Resize(Int32 width, Int32 height) {
if (width <= 0 || height <= 0 || (width == m_width && height == m_height)) return;
m_width = width;
m_height = height;
// Old-size buffers the X server is not holding go now; the rest as they come back
// (NextFree reallocates a free buffer of the wrong size).
for (Buffer& buffer : m_buffers) {
if (buffer.Pixmap != 0 && !buffer.Busy) Drop(buffer);
}
m_damage.InvalidateAll();
}
Bool Chain::TakeConfiguredSize(Int32* width, Int32* height) {
if (!m_configured) return false;
m_configured = false;
*width = m_configuredWidth;
*height = m_configuredHeight;
return true;
}
} // namespace MobileGL::MG_Impl::GLXImpl::X11Present
-199
View File
@@ -1,199 +0,0 @@
// MobileGL - MobileGL/MG_Impl/GLXImpl/X11Present.h
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#pragma once
// GLX WINDOWS PRESENTED THROUGH DRI3 + PRESENT (docs/Disaggregated/notes/anland/plan-x11-gpu.md).
//
// A GLX window's frames are drawn by the server into a pbuffer. Instead of reading each frame back
// and putting it on the window, the frame is copied GPU-side into one of a few server-allocated
// shared images, each imported into the X server once as a pixmap (DRI3 PixmapFromBuffer(s), the
// image's dma-buf), and presented with Present PresentPixmap. An X server drawing with MobileGL
// (Xwayland's glamor) then shows the very same image - attached to its window as a linux-dmabuf
// buffer, or copied on its GPU - and no frame crosses the CPU.
//
// The logic is here, behind two narrow interfaces: Connection (the X side of one window: the DRI3
// import, PresentPixmap, the Present events of a special-event queue) and ImageSource (the server's
// shared images and the GPU copy). X11PresentXcb.cpp implements Connection over libxcb; the host
// tests drive Chain with fakes of both.
//
// Buffers. Up to kBuffers images of the window's size (kMaxBuffers when the X server has held
// every one past kIdleWaitMs); a buffer is busy from its PresentPixmap to its IdleNotify. A
// resize drops each old-size buffer as it comes back idle.
// Pacing. FrameThrottle's rules (EGLImpl/FrameThrottle.h) on CompleteNotify: interval >= 1 waits
// for the previous frame's completion and targets last_msc + interval; interval 0 presents
// PresentOptionAsync, unpaced while completions come, slowed to about one frame a second once
// one is overdue (the X server shows nothing of the window).
// Errors. A refused import, a failed PresentPixmap, a failed copy or the window's destruction
// break the chain for good; its owner falls back to the readback path.
#include <Includes.h>
#include <MG_Util/Damage/Damage.h>
#include "../EGLImpl/FrameThrottle.h"
#include <functional>
namespace MobileGL::MG_Impl::GLXImpl::X11Present {
inline constexpr Uint64 kModifierInvalid = 0x00ffffffffffffffull;
// DRM fourccs: what an X server drawing through GBM imports a depth-24/32 pixmap as.
inline constexpr Uint32 kFourccXrgb8888 = 0x34325258u; // 'XR24'
inline constexpr Uint32 kFourccArgb8888 = 0x34325241u; // 'AR24'
// Present option bits (presentproto).
inline constexpr Uint32 kPresentOptionAsync = 1u;
// ---- which path a window's frames take -------------------------------------------------------
enum class Path { Dri3Present, ShmPutImage, PutImage };
const char* PathName(Path path);
struct ConnectionCaps {
Bool SharedImages = false; // the backend allocates shared images (a split client)
Bool LocalConnection = false; // a unix socket: descriptors can be passed
Uint32 Dri3Major = 0, Dri3Minor = 0;
Uint32 PresentMajor = 0, PresentMinor = 0;
Uint32 ShmMajor = 0, ShmMinor = 0;
};
// The fourcc a window of `depth` is presented in; 0 for a depth this cannot present.
Uint32 FourccForDepth(Uint32 depth);
// DRI3+Present when the connection has both, descriptors can travel, the backend has shared
// images and the depth is 24/32; otherwise MIT-SHM >= 1.2 (fd attach) when local; otherwise
// PutImage. `overrideValue` (MOBILEGL_GLX_PRESENT): "readback" never takes DRI3, "putimage"
// takes neither DRI3 nor MIT-SHM; anything else is automatic.
Path SelectPath(const ConnectionCaps& caps, Uint32 depth, const char* overrideValue);
// ---- the two sides -------------------------------------------------------------------------
struct Image {
Uint64 Id = 0;
int Fd = -1;
Uint32 Width = 0;
Uint32 Height = 0;
Uint32 Stride = 0;
Uint32 Offset = 0;
Uint32 Fourcc = 0;
Uint64 Modifier = kModifierInvalid;
};
class ImageSource {
public:
virtual ~ImageSource() = default;
// A new image; `out->Fd` is the caller's.
virtual Bool Allocate(Uint32 width, Uint32 height, Uint32 fourcc, Image* out) = 0;
virtual void Release(Uint64 id) = 0;
// The current frame into the image, top row first; `region` in GL window coordinates (Full
// = all). True once the copy is submitted and its fence published.
virtual Bool CopyFrame(Uint64 id, const MG_Util::Damage::Region& region) = 0;
};
struct Event {
enum class Kind { None, Idle, Complete, Configure };
Kind Type = Kind::None;
Uint32 Serial = 0;
Uint32 Pixmap = 0;
Uint64 Msc = 0;
Uint8 Mode = 0;
Int32 Width = 0;
Int32 Height = 0;
Bool WindowDestroyed = false;
};
class Connection {
public:
virtual ~Connection() = default;
// A pixmap of `depth` whose storage is the image (its descriptor is duplicated for the
// request; the caller keeps its own). 0 = the X server refused it.
virtual Uint32 ImportPixmap(const Image& image, Uint32 depth) = 0;
virtual void FreePixmap(Uint32 pixmap) = 0;
// Queues a PresentPixmap. `update` is in X coordinates (top-left origin); Full = all of it.
// False when it could not even be sent.
virtual Bool PresentPixmap(Uint32 pixmap, Uint32 serial, Uint32 options, Uint64 targetMsc,
const MG_Util::Damage::Region& update) = 0;
// Whether a PresentPixmap sent earlier is now known to have failed (an X error).
virtual Bool PresentFailed() = 0;
virtual Bool PollEvent(Event* out) = 0;
// Waits up to `timeoutMs` for an event. False: none came (or the connection broke).
virtual Bool WaitEvent(Event* out, Int64 timeoutMs) = 0;
virtual void Flush() = 0;
};
// ---- one window's swap chain ----------------------------------------------------------------
class Chain {
public:
static constexpr SizeT kBuffers = 3;
static constexpr SizeT kMaxBuffers = 4;
static constexpr Int64 kIdleWaitMs = 1000;
// Longest a swap waits for a completion before it stops pacing on it (a server that lost it).
static constexpr Int64 kCompleteGiveUpMs = 5000;
// `nowMs`: a monotonic clock in milliseconds (injected for the tests).
Chain(Connection& connection, ImageSource& images, Uint32 depth, Int32 width, Int32 height,
std::function<Int64()> nowMs);
~Chain();
Chain(const Chain&) = delete;
Chain& operator=(const Chain&) = delete;
// Presents the current frame. `damage` is what it changed (GL window coordinates; Full = all).
// False: the frame was not shown this way - Broken() says whether that is for good.
Bool Present(const MG_Util::Damage::Region& damage, Int swapInterval);
// The window has a new size: the next frame goes into images of that size.
void Resize(Int32 width, Int32 height);
// A size the X server reported (ConfigureNotify) that the owner has not taken yet.
Bool TakeConfiguredSize(Int32* width, Int32* height);
Bool Broken() const { return m_broken; }
const char* BrokenReason() const { return m_brokenReason; }
// For the tests and the log.
SizeT AllocatedBuffers() const;
SizeT BusyBuffers() const;
Uint64 FramesPresented() const { return m_framesPresented; }
Int32 Width() const { return m_width; }
Int32 Height() const { return m_height; }
private:
struct Buffer {
Image Storage;
Uint32 Pixmap = 0;
Bool Busy = false;
Uint32 Serial = 0;
};
void Break(const char* reason);
void Handle(const Event& event);
void DrainEvents();
void WaitForPacing(Int swapInterval);
Buffer* NextFree();
Bool Allocate(Buffer& buffer);
void Drop(Buffer& buffer);
Connection& m_connection;
ImageSource& m_images;
Uint32 m_depth = 24;
Uint32 m_fourcc = kFourccXrgb8888;
Int32 m_width = 0;
Int32 m_height = 0;
std::function<Int64()> m_nowMs;
Buffer m_buffers[kMaxBuffers];
MG_Util::Damage::BufferDamageTracker m_damage{kMaxBuffers};
EGLImpl::Wayland::FrameThrottle m_throttle;
Uint32 m_awaitedSerial = 0;
Uint32 m_serial = 0;
Uint64 m_lastMsc = 0;
Uint64 m_framesPresented = 0;
Bool m_configured = false;
Int32 m_configuredWidth = 0;
Int32 m_configuredHeight = 0;
Bool m_broken = false;
const char* m_brokenReason = "";
};
} // namespace MobileGL::MG_Impl::GLXImpl::X11Present
-522
View File
@@ -1,522 +0,0 @@
// MobileGL - MobileGL/MG_Impl/GLXImpl/X11PresentXcb.cpp
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#include "X11PresentXcb.h"
#if MOBILEGL_GLX_XCB_PRESENT
#include <MG_Util/Debug/Log.h>
#include <xcb/dri3.h>
#include <xcb/present.h>
#include <xcb/shm.h>
#include <xcb/xcb.h>
#include <xcb/xcbext.h>
#include <xcb/xfixes.h>
#include <cerrno>
#include <chrono>
#include <cstdlib>
#include <cstring>
#include <mutex>
#include <dlfcn.h>
#include <fcntl.h>
#include <poll.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <unistd.h>
namespace MobileGL::MG_Impl::GLXImpl::X11Present {
namespace {
// presentproto: ConfigureNotify's pixmap_flags when the window is gone (Present 1.2+).
constexpr uint32_t kPresentWindowDestroyed = 1u << 0;
#define MGL_XCB_FN(name) decltype(&::name) name = nullptr
struct XcbApi {
Bool core = false, dri3 = false, present = false, xfixes = false, shm = false;
// libxcb
MGL_XCB_FN(xcb_generate_id);
MGL_XCB_FN(xcb_flush);
MGL_XCB_FN(xcb_get_extension_data);
MGL_XCB_FN(xcb_request_check);
MGL_XCB_FN(xcb_poll_for_reply);
MGL_XCB_FN(xcb_discard_reply);
MGL_XCB_FN(xcb_get_file_descriptor);
MGL_XCB_FN(xcb_connection_has_error);
MGL_XCB_FN(xcb_register_for_special_xge);
MGL_XCB_FN(xcb_unregister_for_special_event);
MGL_XCB_FN(xcb_poll_for_special_event);
MGL_XCB_FN(xcb_free_pixmap_checked);
MGL_XCB_FN(xcb_get_input_focus);
MGL_XCB_FN(xcb_get_input_focus_reply);
// libxcb-dri3
xcb_extension_t* dri3Id = nullptr;
MGL_XCB_FN(xcb_dri3_query_version);
MGL_XCB_FN(xcb_dri3_query_version_reply);
MGL_XCB_FN(xcb_dri3_pixmap_from_buffer_checked);
MGL_XCB_FN(xcb_dri3_pixmap_from_buffers_checked);
// libxcb-present
xcb_extension_t* presentId = nullptr;
MGL_XCB_FN(xcb_present_query_version);
MGL_XCB_FN(xcb_present_query_version_reply);
MGL_XCB_FN(xcb_present_select_input_checked);
MGL_XCB_FN(xcb_present_pixmap_checked);
// libxcb-xfixes
xcb_extension_t* xfixesId = nullptr;
MGL_XCB_FN(xcb_xfixes_query_version);
MGL_XCB_FN(xcb_xfixes_query_version_reply);
MGL_XCB_FN(xcb_xfixes_create_region);
MGL_XCB_FN(xcb_xfixes_destroy_region);
// libxcb-shm
xcb_extension_t* shmId = nullptr;
MGL_XCB_FN(xcb_shm_query_version);
MGL_XCB_FN(xcb_shm_query_version_reply);
MGL_XCB_FN(xcb_shm_attach_fd_checked);
MGL_XCB_FN(xcb_shm_detach);
MGL_XCB_FN(xcb_shm_put_image);
};
#undef MGL_XCB_FN
void* OpenLibrary(const char* name) {
void* lib = dlopen(name, RTLD_NOW | RTLD_NOLOAD);
return lib != nullptr ? lib : dlopen(name, RTLD_NOW | RTLD_LOCAL);
}
template <typename Fn>
Bool Resolve(void* lib, const char* name, Fn& out) {
out = lib != nullptr ? reinterpret_cast<Fn>(dlsym(lib, name)) : nullptr;
return out != nullptr;
}
const XcbApi& Api() {
static const XcbApi* api = [] {
auto* a = new XcbApi();
void* xcb = OpenLibrary("libxcb.so.1");
#define R(lib, fn) Resolve(lib, #fn, a->fn)
a->core = R(xcb, xcb_generate_id) & R(xcb, xcb_flush) & R(xcb, xcb_get_extension_data) &
R(xcb, xcb_request_check) & R(xcb, xcb_poll_for_reply) & R(xcb, xcb_discard_reply) &
R(xcb, xcb_get_file_descriptor) & R(xcb, xcb_connection_has_error) &
R(xcb, xcb_register_for_special_xge) & R(xcb, xcb_unregister_for_special_event) &
R(xcb, xcb_poll_for_special_event) & R(xcb, xcb_free_pixmap_checked) &
R(xcb, xcb_get_input_focus) & R(xcb, xcb_get_input_focus_reply);
if (a->core) {
void* dri3 = OpenLibrary("libxcb-dri3.so.0");
a->dri3Id = dri3 != nullptr ? static_cast<xcb_extension_t*>(dlsym(dri3, "xcb_dri3_id")) : nullptr;
a->dri3 = a->dri3Id != nullptr && R(dri3, xcb_dri3_query_version) &
R(dri3, xcb_dri3_query_version_reply) &
R(dri3, xcb_dri3_pixmap_from_buffer_checked);
// 1.2's multi-plane request is optional: an older libxcb-dri3 has only 1.0's.
(void)R(dri3, xcb_dri3_pixmap_from_buffers_checked);
void* present = OpenLibrary("libxcb-present.so.0");
a->presentId =
present != nullptr ? static_cast<xcb_extension_t*>(dlsym(present, "xcb_present_id")) : nullptr;
a->present = a->presentId != nullptr && R(present, xcb_present_query_version) &
R(present, xcb_present_query_version_reply) &
R(present, xcb_present_select_input_checked) &
R(present, xcb_present_pixmap_checked);
void* xfixes = OpenLibrary("libxcb-xfixes.so.0");
a->xfixesId =
xfixes != nullptr ? static_cast<xcb_extension_t*>(dlsym(xfixes, "xcb_xfixes_id")) : nullptr;
a->xfixes = a->xfixesId != nullptr && R(xfixes, xcb_xfixes_query_version) &
R(xfixes, xcb_xfixes_query_version_reply) &
R(xfixes, xcb_xfixes_create_region) &
R(xfixes, xcb_xfixes_destroy_region);
void* shm = OpenLibrary("libxcb-shm.so.0");
a->shmId = shm != nullptr ? static_cast<xcb_extension_t*>(dlsym(shm, "xcb_shm_id")) : nullptr;
a->shm = a->shmId != nullptr && R(shm, xcb_shm_query_version) &
R(shm, xcb_shm_query_version_reply) &
R(shm, xcb_shm_attach_fd_checked) & R(shm, xcb_shm_detach) &
R(shm, xcb_shm_put_image);
}
#undef R
return a;
}();
return *api;
}
xcb_connection_t* Xcb(void* connection) { return static_cast<xcb_connection_t*>(connection); }
Bool ExtensionPresent(xcb_connection_t* c, xcb_extension_t* id) {
const XcbApi& api = Api();
if (id == nullptr) return false;
const xcb_query_extension_reply_t* data = api.xcb_get_extension_data(c, id);
return data != nullptr && data->present != 0;
}
struct CachedCaps {
void* Connection = nullptr;
ConnectionCaps Caps;
Bool XFixes = false;
};
std::mutex& CapsMutex() {
static auto* mutex = new std::mutex();
return *mutex;
}
Vector<CachedCaps>& CapsCache() {
static auto* cache = new Vector<CachedCaps>();
return *cache;
}
CachedCaps Query(void* connection) {
const std::lock_guard<std::mutex> lock(CapsMutex());
for (const CachedCaps& cached : CapsCache()) {
if (cached.Connection == connection) return cached;
}
CachedCaps result;
result.Connection = connection;
const XcbApi& api = Api();
xcb_connection_t* c = Xcb(connection);
if (!api.core || c == nullptr || api.xcb_connection_has_error(c)) return result;
sockaddr_storage address{};
socklen_t length = sizeof(address);
if (::getsockname(api.xcb_get_file_descriptor(c), reinterpret_cast<sockaddr*>(&address), &length) == 0)
result.Caps.LocalConnection = address.ss_family == AF_UNIX;
if (api.dri3 && ExtensionPresent(c, api.dri3Id)) {
if (auto* reply = api.xcb_dri3_query_version_reply(c, api.xcb_dri3_query_version(c, 1, 2), nullptr)) {
result.Caps.Dri3Major = reply->major_version;
result.Caps.Dri3Minor = reply->minor_version;
std::free(reply);
}
}
if (api.present && ExtensionPresent(c, api.presentId)) {
if (auto* reply =
api.xcb_present_query_version_reply(c, api.xcb_present_query_version(c, 1, 2), nullptr)) {
result.Caps.PresentMajor = reply->major_version;
result.Caps.PresentMinor = reply->minor_version;
std::free(reply);
}
}
// XFixes demands its version be asked before any other request of it.
if (api.xfixes && ExtensionPresent(c, api.xfixesId)) {
if (auto* reply = api.xcb_xfixes_query_version_reply(c, api.xcb_xfixes_query_version(c, 5, 0), nullptr)) {
result.XFixes = reply->major_version >= 2;
std::free(reply);
}
}
if (api.shm && ExtensionPresent(c, api.shmId)) {
if (auto* reply = api.xcb_shm_query_version_reply(c, api.xcb_shm_query_version(c), nullptr)) {
result.Caps.ShmMajor = reply->major_version;
result.Caps.ShmMinor = reply->minor_version;
std::free(reply);
}
}
CapsCache().push_back(result);
return result;
}
Int64 NowMs() {
return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count();
}
Bool Translate(const xcb_generic_event_t* raw, Event* out) {
const auto* generic = reinterpret_cast<const xcb_present_generic_event_t*>(raw);
*out = Event{};
switch (generic->evtype) {
case XCB_PRESENT_EVENT_IDLE_NOTIFY: {
const auto* idle = reinterpret_cast<const xcb_present_idle_notify_event_t*>(raw);
out->Type = Event::Kind::Idle;
out->Serial = idle->serial;
out->Pixmap = idle->pixmap;
return true;
}
case XCB_PRESENT_EVENT_COMPLETE_NOTIFY: {
const auto* complete = reinterpret_cast<const xcb_present_complete_notify_event_t*>(raw);
if (complete->kind != XCB_PRESENT_COMPLETE_KIND_PIXMAP) return false;
out->Type = Event::Kind::Complete;
out->Serial = complete->serial;
out->Msc = complete->msc;
out->Mode = complete->mode;
return true;
}
case XCB_PRESENT_EVENT_CONFIGURE_NOTIFY: {
const auto* configure = reinterpret_cast<const xcb_present_configure_notify_event_t*>(raw);
out->Type = Event::Kind::Configure;
out->Width = configure->width;
out->Height = configure->height;
out->WindowDestroyed = (configure->pixmap_flags & kPresentWindowDestroyed) != 0;
return true;
}
default:
return false;
}
}
class XcbConnection final : public Connection {
public:
XcbConnection(xcb_connection_t* c, Uint32 window, Bool buffers12, Bool xfixes)
: m_c(c), m_window(window), m_buffers12(buffers12), m_xfixes(xfixes) {}
Bool Init() {
const XcbApi& api = Api();
m_eid = api.xcb_generate_id(m_c);
m_special = api.xcb_register_for_special_xge(m_c, Api().presentId, m_eid, &m_stamp);
if (m_special == nullptr) return false;
const xcb_void_cookie_t cookie = api.xcb_present_select_input_checked(
m_c, m_eid, m_window,
XCB_PRESENT_EVENT_MASK_CONFIGURE_NOTIFY | XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY |
XCB_PRESENT_EVENT_MASK_IDLE_NOTIFY);
if (xcb_generic_error_t* error = api.xcb_request_check(m_c, cookie)) {
std::free(error);
return false;
}
return true;
}
~XcbConnection() override {
const XcbApi& api = Api();
if (m_hasPendingPresent) api.xcb_discard_reply(m_c, m_pendingPresent);
if (m_special != nullptr) {
const xcb_void_cookie_t cookie =
api.xcb_present_select_input_checked(m_c, m_eid, m_window, XCB_PRESENT_EVENT_MASK_NO_EVENT);
// The window may be gone already: an error here is expected and dropped.
api.xcb_discard_reply(m_c, cookie.sequence);
api.xcb_unregister_for_special_event(m_c, m_special);
}
api.xcb_flush(m_c);
}
Uint32 ImportPixmap(const Image& image, Uint32 depth) override {
const XcbApi& api = Api();
// libxcb closes the descriptor it sends.
const int fd = ::fcntl(image.Fd, F_DUPFD_CLOEXEC, 0);
if (fd < 0) return 0;
const Uint32 pixmap = api.xcb_generate_id(m_c);
xcb_void_cookie_t cookie{};
if (m_buffers12 && api.xcb_dri3_pixmap_from_buffers_checked != nullptr) {
int32_t fds[1] = {fd};
cookie = api.xcb_dri3_pixmap_from_buffers_checked(
m_c, pixmap, m_window, 1, static_cast<uint16_t>(image.Width), static_cast<uint16_t>(image.Height),
image.Stride, image.Offset, 0, 0, 0, 0, 0, 0, static_cast<uint8_t>(depth), 32, image.Modifier, fds);
} else {
if (image.Offset != 0 || image.Stride > 0xffffu) {
::close(fd);
return 0;
}
cookie = api.xcb_dri3_pixmap_from_buffer_checked(
m_c, pixmap, m_window, image.Stride * image.Height, static_cast<uint16_t>(image.Width),
static_cast<uint16_t>(image.Height), static_cast<uint16_t>(image.Stride),
static_cast<uint8_t>(depth), 32, fd);
}
if (xcb_generic_error_t* error = api.xcb_request_check(m_c, cookie)) {
MGLOG_I("glx: the X server refused a %ux%u shared image as a pixmap (X error %u, major %u minor %u)",
image.Width, image.Height, error->error_code, error->major_code, error->minor_code);
std::free(error);
return 0;
}
return pixmap;
}
void FreePixmap(Uint32 pixmap) override {
const XcbApi& api = Api();
api.xcb_discard_reply(m_c, api.xcb_free_pixmap_checked(m_c, pixmap).sequence);
}
Bool PresentPixmap(Uint32 pixmap, Uint32 serial, Uint32 options, Uint64 targetMsc,
const MG_Util::Damage::Region& update) override {
const XcbApi& api = Api();
if (api.xcb_connection_has_error(m_c)) return false;
Uint32 region = 0;
if (!update.IsFull() && m_xfixes) {
Vector<xcb_rectangle_t> rects;
for (const MG_Util::Damage::Rect& rect : update.Rects()) {
rects.push_back({static_cast<int16_t>(rect.X), static_cast<int16_t>(rect.Y),
static_cast<uint16_t>(rect.Width), static_cast<uint16_t>(rect.Height)});
}
if (!rects.empty()) {
region = api.xcb_generate_id(m_c);
api.xcb_xfixes_create_region(m_c, region, static_cast<uint32_t>(rects.size()), rects.data());
}
}
// An earlier present whose answer never came is given up on, not left queued.
if (m_hasPendingPresent) api.xcb_discard_reply(m_c, m_pendingPresent);
const xcb_void_cookie_t cookie =
api.xcb_present_pixmap_checked(m_c, m_window, pixmap, serial, 0, region, 0, 0, 0, 0, 0, options,
targetMsc, 0, 0, 0, nullptr);
m_pendingPresent = cookie.sequence;
m_hasPendingPresent = true;
if (region != 0) api.xcb_xfixes_destroy_region(m_c, region);
return true;
}
Bool PresentFailed() override {
const XcbApi& api = Api();
if (m_failed || !m_hasPendingPresent) return m_failed;
void* reply = nullptr;
xcb_generic_error_t* error = nullptr;
// Known once anything later has come back (an event carries the sequence): no round trip.
if (api.xcb_poll_for_reply(m_c, m_pendingPresent, &reply, &error) != 0) {
m_hasPendingPresent = false;
if (error != nullptr) {
MGLOG_I("glx: PresentPixmap failed (X error %u)", error->error_code);
m_failed = true;
}
std::free(reply);
std::free(error);
}
return m_failed;
}
Bool PollEvent(Event* out) override {
const XcbApi& api = Api();
for (;;) {
xcb_generic_event_t* raw = api.xcb_poll_for_special_event(m_c, m_special);
if (raw == nullptr) return false;
const Bool known = Translate(raw, out);
std::free(raw);
if (known) return true;
}
}
// Short poll slices: another thread (the application's event loop) may be the one
// reading the socket, and its read moves our events into the special queue.
Bool WaitEvent(Event* out, Int64 timeoutMs) override {
const XcbApi& api = Api();
api.xcb_flush(m_c);
const Int64 deadline = NowMs() + timeoutMs;
for (;;) {
if (PollEvent(out)) return true;
if (api.xcb_connection_has_error(m_c)) return false;
const Int64 remaining = deadline - NowMs();
if (remaining <= 0) return false;
pollfd p{api.xcb_get_file_descriptor(m_c), POLLIN, 0};
(void)::poll(&p, 1, static_cast<int>(std::min<Int64>(remaining, 4)));
}
}
void Flush() override { Api().xcb_flush(m_c); }
private:
xcb_connection_t* m_c = nullptr;
Uint32 m_window = 0;
Bool m_buffers12 = false;
Bool m_xfixes = false;
Uint32 m_eid = 0;
uint32_t m_stamp = 0;
xcb_special_event_t* m_special = nullptr;
unsigned int m_pendingPresent = 0;
Bool m_hasPendingPresent = false;
Bool m_failed = false;
};
class XcbShmPresenter final : public ShmPresenter {
public:
explicit XcbShmPresenter(xcb_connection_t* c) : m_c(c) {}
~XcbShmPresenter() override {
for (Segment& segment : m_segments) Release(segment);
Api().xcb_flush(m_c);
}
Bool Put(Uint32 drawable, Uint32 gc, Uint32 depth, Int32 width, Int32 height,
const std::function<void(Uint8*, SizeT)>& fill) override {
const XcbApi& api = Api();
if (width <= 0 || height <= 0 || width > 0xffff || height > 0xffff) return false;
Segment& segment = m_segments[m_next];
m_next = (m_next + 1) % 2;
// The X server may still be reading this segment's last frame: the round trip queued
// behind that put coming back says it is done with it.
if (segment.HasSync) {
std::free(api.xcb_get_input_focus_reply(m_c, segment.Sync, nullptr));
segment.HasSync = false;
}
const SizeT stride = static_cast<SizeT>(width) * 4;
const SizeT size = stride * static_cast<SizeT>(height);
if (segment.Size < size && !Make(segment, size)) return false;
fill(static_cast<Uint8*>(segment.Map), stride);
api.xcb_shm_put_image(m_c, drawable, gc, static_cast<uint16_t>(width), static_cast<uint16_t>(height), 0,
0, static_cast<uint16_t>(width), static_cast<uint16_t>(height), 0, 0,
static_cast<uint8_t>(depth), XCB_IMAGE_FORMAT_Z_PIXMAP, 0, segment.Seg, 0);
segment.Sync = api.xcb_get_input_focus(m_c);
segment.HasSync = true;
api.xcb_flush(m_c);
return true;
}
private:
struct Segment {
Uint32 Seg = 0;
void* Map = nullptr;
SizeT Size = 0;
xcb_get_input_focus_cookie_t Sync{};
Bool HasSync = false;
};
void Release(Segment& segment) {
const XcbApi& api = Api();
if (segment.HasSync) std::free(api.xcb_get_input_focus_reply(m_c, segment.Sync, nullptr));
if (segment.Seg != 0) api.xcb_shm_detach(m_c, segment.Seg);
if (segment.Map != nullptr) ::munmap(segment.Map, segment.Size);
segment = Segment{};
}
Bool Make(Segment& segment, SizeT size) {
const XcbApi& api = Api();
Release(segment);
const int fd = ::memfd_create("mobilegl-glx-shm", MFD_CLOEXEC);
if (fd < 0) return false;
if (::ftruncate(fd, static_cast<off_t>(size)) != 0) {
::close(fd);
return false;
}
void* map = ::mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (map == MAP_FAILED) {
::close(fd);
return false;
}
const Uint32 seg = api.xcb_generate_id(m_c);
// libxcb sends, then closes, the descriptor; the mapping stays.
const xcb_void_cookie_t cookie = api.xcb_shm_attach_fd_checked(m_c, seg, fd, 1);
if (xcb_generic_error_t* error = api.xcb_request_check(m_c, cookie)) {
std::free(error);
::munmap(map, size);
return false;
}
segment.Seg = seg;
segment.Map = map;
segment.Size = size;
return true;
}
xcb_connection_t* m_c = nullptr;
Segment m_segments[2];
SizeT m_next = 0;
};
} // namespace
ConnectionCaps QueryConnectionCaps(void* xcbConnection) { return Query(xcbConnection).Caps; }
UniquePtr<Connection> CreateXcbConnection(void* xcbConnection, Uint32 window, const ConnectionCaps& caps) {
const XcbApi& api = Api();
if (!api.core || !api.dri3 || !api.present || caps.Dri3Major < 1 || caps.PresentMajor < 1) return nullptr;
const CachedCaps cached = Query(xcbConnection);
const Bool buffers12 = caps.Dri3Major > 1 || (caps.Dri3Major == 1 && caps.Dri3Minor >= 2);
auto connection = MakeUnique<XcbConnection>(Xcb(xcbConnection), window, buffers12, cached.XFixes);
if (!connection->Init()) return nullptr;
return connection;
}
UniquePtr<ShmPresenter> CreateShmPresenter(void* xcbConnection) {
const XcbApi& api = Api();
if (!api.core || !api.shm || xcbConnection == nullptr) return nullptr;
return MakeUnique<XcbShmPresenter>(Xcb(xcbConnection));
}
} // namespace MobileGL::MG_Impl::GLXImpl::X11Present
#else // !MOBILEGL_GLX_XCB_PRESENT
namespace MobileGL::MG_Impl::GLXImpl::X11Present {
ConnectionCaps QueryConnectionCaps(void*) { return {}; }
UniquePtr<Connection> CreateXcbConnection(void*, Uint32, const ConnectionCaps&) { return nullptr; }
UniquePtr<ShmPresenter> CreateShmPresenter(void*) { return nullptr; }
} // namespace MobileGL::MG_Impl::GLXImpl::X11Present
#endif
-48
View File
@@ -1,48 +0,0 @@
// MobileGL - MobileGL/MG_Impl/GLXImpl/X11PresentXcb.h
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#pragma once
// The X side of X11Present over libxcb: DRI3, Present, XFixes and MIT-SHM on the application's own
// connection (XGetXCBConnection of its Display - this library never opens one). Every libxcb entry
// point is resolved at run time, like the rest of the GLX layer, so nothing links libxcb; the
// protocol headers are only needed at build time, and a build without them has no DRI3 path
// (MOBILEGL_GLX_XCB_PRESENT is 0 and every window takes the readback path).
#include "X11Present.h"
#if defined(__linux__) && !defined(__ANDROID__) && __has_include(<xcb/dri3.h>) && __has_include(<xcb/present.h>) && \
__has_include(<xcb/xfixes.h>) && __has_include(<xcb/shm.h>)
#define MOBILEGL_GLX_XCB_PRESENT 1
#else
#define MOBILEGL_GLX_XCB_PRESENT 0
#endif
namespace MobileGL::MG_Impl::GLXImpl::X11Present {
// What the connection offers (queried once per connection). SharedImages is left false: that
// one is the backend's to answer.
ConnectionCaps QueryConnectionCaps(void* xcbConnection);
// A window's Present events on a special-event queue of their own, its DRI3 imports and its
// PresentPixmaps. Null when the connection lacks DRI3/Present or the queue cannot be set up.
UniquePtr<Connection> CreateXcbConnection(void* xcbConnection, Uint32 window, const ConnectionCaps& caps);
// THE MIT-SHM FALLBACK: frames read back into a shared segment (a memfd passed with
// ShmAttachFd, so no SysV memory has to be shared with the X server) and put with ShmPutImage -
// the pixels reach the X server without travelling down its socket. Two segments, alternating;
// a segment is written again only after a round trip queued behind its last put has come back.
class ShmPresenter {
public:
virtual ~ShmPresenter() = default;
// `fill(rows, stride)` writes a width x height top-down 32bpp frame; then it is put on
// `drawable` with `gc` at (0,0). False: not shown (the segment could not be made).
virtual Bool Put(Uint32 drawable, Uint32 gc, Uint32 depth, Int32 width, Int32 height,
const std::function<void(Uint8*, SizeT)>& fill) = 0;
};
UniquePtr<ShmPresenter> CreateShmPresenter(void* xcbConnection);
} // namespace MobileGL::MG_Impl::GLXImpl::X11Present
-35
View File
@@ -29,26 +29,6 @@ extern "C" EGLBoolean eglQueryDmaBufModifiersEXT(EGLDisplay dpy, EGLint format,
khronos_uint64_t* modifiers, EGLBoolean* external_only,
EGLint* num_modifiers);
extern "C" void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image);
// EGL_KHR_fence_sync / EGL_KHR_wait_sync / EGL_ANDROID_native_fence_sync (Definitions.cpp).
extern "C" EGLSync eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint* attrib_list);
extern "C" EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSync sync);
extern "C" EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
extern "C" EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLint* value);
extern "C" EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSync sync, EGLint flags);
extern "C" EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSync sync);
// KHR_robustness / EXT_robustness suffixed names (Definitions.cpp); the desktop headers declare
// only the unsuffixed and ARB ones.
extern "C" GLenum glGetGraphicsResetStatusKHR(void);
extern "C" GLenum glGetGraphicsResetStatusEXT(void);
extern "C" void glReadnPixelsKHR(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
GLsizei bufSize, void* data);
extern "C" void glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
GLsizei bufSize, void* data);
extern "C" void glGetnUniformfvKHR(GLuint program, GLint location, GLsizei bufSize, GLfloat* params);
extern "C" void glGetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, GLfloat* params);
extern "C" void glGetnUniformivKHR(GLuint program, GLint location, GLsizei bufSize, GLint* params);
extern "C" void glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint* params);
extern "C" void glGetnUniformuivKHR(GLuint program, GLint location, GLsizei bufSize, GLuint* params);
#define GETPROC(name, var) \
if (strcmp(#name, var) == 0) { \
@@ -96,12 +76,6 @@ namespace MobileGL::MG_Impl {
GETPROC(eglDestroySync, name);
GETPROC(eglClientWaitSync, name);
GETPROC(eglGetSyncAttrib, name);
GETPROC(eglCreateSyncKHR, name);
GETPROC(eglDestroySyncKHR, name);
GETPROC(eglClientWaitSyncKHR, name);
GETPROC(eglGetSyncAttribKHR, name);
GETPROC(eglWaitSyncKHR, name);
GETPROC(eglDupNativeFenceFDANDROID, name);
GETPROC(eglCreateImage, name);
GETPROC(eglDestroyImage, name);
GETPROC(eglCreateImageKHR, name);
@@ -902,15 +876,6 @@ namespace MobileGL::MG_Impl {
GETPROC(glGetnUniformivARB, name);
GETPROC(glGetnUniformuivARB, name);
GETPROC(glGetnUniformdvARB, name);
GETPROC(glGetGraphicsResetStatusKHR, name);
GETPROC(glGetGraphicsResetStatusEXT, name);
GETPROC(glReadnPixelsKHR, name);
GETPROC(glReadnPixelsEXT, name);
GETPROC(glGetnUniformfvKHR, name);
GETPROC(glGetnUniformfvEXT, name);
GETPROC(glGetnUniformivKHR, name);
GETPROC(glGetnUniformivEXT, name);
GETPROC(glGetnUniformuivKHR, name);
GETPROC(glFramebufferSampleLocationsfvARB, name);
GETPROC(glNamedFramebufferSampleLocationsfvARB, name);
GETPROC(glEvaluateDepthValuesARB, name);
+3 -7
View File
@@ -7,7 +7,6 @@
// End of Source File Header
#include <Includes.h>
#include <Init.h>
#include "GLImpl/Texture/ProxyTexture.h"
#include "GLImpl/Framebuffer/GL_Framebuffer.h"
@@ -23,13 +22,7 @@ namespace MobileGL::MG_Impl {
void Init() {
MGLOG_D("Initializing MobileGL Implementation...");
GLImpl::TextureImpl::pProxyTextureManager = MakeUnique<GLImpl::TextureImpl::ProxyTextureManager>();
BuildDefaultFramebuffer();
#if defined(__APPLE__) && !defined(MOBILEGL_IOS)
NSOpenGLImpl::InstallHooks();
#endif
}
void BuildDefaultFramebuffer() {
// TODO: get real info in EGL
auto& fbo0 = MG_State::pGLContext->CreateFramebufferObject(0);
auto colorTex = MakeShared<MG_State::GLState::TextureObject2D>(0);
@@ -59,5 +52,8 @@ namespace MobileGL::MG_Impl {
// framebuffer, so a context the application creates after this one is not left with an
// unbound framebuffer 0.
MG_State::SetDefaultFramebuffer(fbo0);
#if defined(__APPLE__) && !defined(MOBILEGL_IOS)
NSOpenGLImpl::InstallHooks();
#endif
}
} // namespace MobileGL::MG_Impl
+10 -16
View File
@@ -524,28 +524,22 @@ namespace MobileGL::MG_Pipe {
out.Target = static_cast<Uint8>(target);
out.IsDefault = fbo.IsDefaultFramebuffer() ? 1 : 0;
// THE SURFACES - and a DEFAULT framebuffer's record names none. Its storage on the
// server is the surface the context is current on (the native window or pbuffer,
// Magma's swapchain); both servers answer every default-framebuffer question from
// IsDefault and never resolve a surface of this record. The frontend's attachments
// are placeholders: one process-wide set of textures every context's framebuffer 0
// shares, created once, so their records live in the ONE share group that was
// bound when they were born. Naming them here sent every other group a handle it
// holds no record for ("texture {12, 0} has no applier resource record" on each of
// its draws) and marked bind bits on them under whichever context drew next.
// Publishing them into every group instead would build a driver texture per group
// for storage nothing reads. The extent still comes from them (FillGeometry), and
// the draw-buffer indices below still map BackLeft to slot 0.
if (out.IsDefault == 0) {
// THE COLOUR POINTS. A default framebuffer keeps its one colour surface under
// BackLeft rather than under Color0, and the record has exactly one place to put
// it: Color[0], which is also the index MGPipeDrawBufferIndex maps that token to,
// so the array and the draw-buffer indices agree by construction.
if (out.IsDefault != 0) {
out.Color[0] = SurfaceOf(fbo, FramebufferAttachmentType::BackLeft);
} else {
for (SizeT i = 0; i < kMGPipeMaxColorAttachments; ++i) {
out.Color[i] = SurfaceOf(fbo, static_cast<FramebufferAttachmentType>(
static_cast<Int>(FramebufferAttachmentType::Color0) +
static_cast<Int>(i)));
}
out.Depth = SurfaceOf(fbo, FramebufferAttachmentType::Depth);
out.Stencil = SurfaceOf(fbo, FramebufferAttachmentType::Stencil);
out.ReadSurface = SurfaceOf(fbo, fbo.GetReadBuffer());
}
out.Depth = SurfaceOf(fbo, FramebufferAttachmentType::Depth);
out.Stencil = SurfaceOf(fbo, FramebufferAttachmentType::Stencil);
out.ReadSurface = SurfaceOf(fbo, fbo.GetReadBuffer());
const auto& drawBuffers = fbo.GetDrawBuffers();
for (SizeT i = 0; i < kMGPipeMaxColorAttachments; ++i) {
-56
View File
@@ -1828,12 +1828,6 @@ namespace MobileGL::MG_Pipe {
*entry = Entry{};
}
// A fresh server holds no record at all (MGPipeForgetEndedSession).
void ForgetAll() {
for (Vector<Entry>& table : m_kinds) table.clear();
m_band.clear();
}
private:
struct Entry {
Uint32 Gen = 0;
@@ -1948,13 +1942,6 @@ namespace MobileGL::MG_Pipe {
void MGPipeNoteTextureLevelDirty(ITextureObject& storageOwner, Uint32 uploadTarget, Uint32 level) {
if (!FamilyIsLive(kMGPipeSubsystemTextureResources, kMGPipeWiredTextureSubsystem)) return;
#if MOBILEGL_BUILD_DISAGGREGATED
// AN UPLOAD ON A LOST CONTEXT IS OWED TO NOBODY. The drain list is process-wide and the
// next verb of ANY context drains it; queued from a thread still on a lost context (or
// while the session is lost), it would be carried to a fresh session that never created
// the texture. The level stays dirty on the object, which no live context can reach.
if (MG_Remote::Client::ClientSession::DeviceLost()) return;
#endif
ForwardWhenWired<kMGPipeWiredTextureSubsystem>(
MGPipeTextureEmitterInstance(),
[&](auto& emitter) { emitter.NoteLevelDirty(storageOwner, uploadTarget, level); });
@@ -3986,47 +3973,4 @@ namespace MobileGL::MG_Pipe {
EntryCompare(inputs, mask);
#endif
}
void MGPipeClientDrainTextureUploads() {
if (MG_Config::Transport == MG_Config::TransportMode::Monolith) return;
if (MG_Remote::Client::RunsAsTheServerRole()) return;
auto* ctx = LiveContext();
if (ctx == nullptr) return;
const Uint64 pushMask = MG_Config::Features.PipePush;
if ((pushMask & kMGPipeSubsystemTextureResources) != 0 &&
(kMGPipeWiredSubsystems & kMGPipeSubsystemTextureResources) != 0 &&
P4aFamilyHasItsConsumer(kMGPipeSubsystemTextureResources) &&
P4aFamilyDependenciesAreSet(kMGPipeSubsystemTextureResources, pushMask)) {
(void)MGPipeTextureEmitterInstance().DrainTextureSubData(*ctx);
}
}
#if MOBILEGL_BUILD_DISAGGREGATED
// Declared in PipeMutation.h, where the list is argued. THE ORDER: the latch goes first, so
// everything after it - a pin's last owner dying, a deferred destroy replayed, an evicted
// cache entry - finds its handle unpublished and puts nothing on the new wire; then the
// references the emitters hold into the caches go back, then the caches themselves.
void MGPipeForgetEndedSession() {
PublicationLatch().ForgetAll();
MGPipeResourceTrackerInstance().ForgetPublication();
MGPipeReleaseResidualFillPins();
MGPipeDrainDeferredDestroys();
MGPipeTrackerInstance().Reset();
// The texture emitter's records and its owed uploads belong to the ended server; its
// sampler references go back to the cache before the cache is emptied.
MGPipeTextureEmitterInstance().ResetForTest();
MGPipeSamplerEmitterInstance().Reset();
MGPipeSamplerCsoCacheInstance().ResetForTest();
MGPipeCsoCacheInstance().Reset();
MGPipeSetHashSuppressorInstance().InvalidateAll();
MGPipeVertexInputEmitterInstance().Reset();
MGPipeFramebufferEmitterInstance().ResetForTest();
MGPipeImageEmitterInstance().Reset();
MGPipeProgramEmitterInstance().Reset();
MGPipeShaderBufferEmitterInstance().Reset();
g_residualDue = true;
g_attribDefaultLastHeader = MGPVertexAttribDefaults{};
g_lastFillWasBarriered = true;
}
#endif
} // namespace MobileGL::MG_Pipe
-6
View File
@@ -340,12 +340,6 @@ namespace MobileGL::MG_Pipe {
const SizeT slot = handle.Slot;
return slot < m_bySlot.size() && m_bySlot[slot].Published;
}
// A session that replaces an ended one has no record for any buffer the ended one was
// told about: a live buffer of the ended session's contexts dies with no destroy on the
// new wire, and the inverse entries stay so the handles still resolve locally.
void ForgetPublication() {
for (Entry& entry : m_bySlot) entry.Published = false;
}
// The sticky everBoundAs mask. Sticky exactly as MGPResourceDesc::ImageBindableHint's
// everImageBound is: ORed, never cleared, so a buffer that was an element array once
+7 -8
View File
@@ -373,8 +373,7 @@ namespace MobileGL::MG_Pipe {
return false;
}
// A unit test's fixture, and a session that replaced an ended one (MGPipeForgetEndedSession:
// the fresh server holds none of these records). NOT called from the validate point's
// A unit test's fixture, and nothing else. NOT called from the validate point's
// FreshlyPrimed arm: MGPipeApplierReset is a make-current and does NOT drop object
// records, so a sampler CSO the applier holds outlives a context switch. Dropping the
// cache there would leak the applier's record and re-mint a value it already has.
@@ -576,12 +575,12 @@ namespace MobileGL::MG_Pipe {
// here - a content-addressed CSO has no frontend object whose death is being
// announced, which is precisely why this eviction is the only death path it has.
//
// THE DELETE ENDS THE HANDLE IN EVERY SHARE GROUP IT WAS PUBLISHED TO, not only the
// bound one: the applier drops a sampler CSO from every group of its session
// (MGPipeApplyDeleteSamplerState), because the handle this frees is one identity for
// the whole session. So it is sent whenever ANY group was sent the create - and not
// at all for an entry no group holds, which the applier would count as a refusal.
if (m_entries[index].PublishedGroupCount != 0) {
// THE DELETE REACHES THE BOUND SHARE GROUP ONLY, so it is sent only when that group
// holds the record; a group that was never sent the create would count
// it as a refused object call. Other groups keep an unreferenced record at this slot
// (nothing may name it: the count is 0) until a create for the slot's next
// generation is published there and starts it over, or the group is torn down.
if (IsPublishedIn(m_entries[index], MGPipeCurrentShareGroupToken())) {
MGPipeRouteDeleteSamplerState(handle);
}
// AND THE LATCH GOES WITH THE DELETE. This is the "an emitter that drops a record
+2 -26
View File
@@ -1166,10 +1166,7 @@ namespace MobileGL::MG_Pipe {
if (present == key) return;
}
entry.DrainKeys.push_back(key);
// The share group the texels are owed to: the one the stream is bound to while the
// GL call that wrote them runs (GLStreamScope binds it to the writing thread's
// context, whose group the texture is in). See DrainTextureSubData.
m_drain.push_back(DrainEntry{handle, key, MGPipeCurrentShareGroupToken()});
m_drain.push_back(DrainEntry{handle, key});
}
// The DRAIN, at the validate point: one resource_subdata per dirty (storage owner,
@@ -1192,19 +1189,7 @@ namespace MobileGL::MG_Pipe {
m_draining = true;
Uint64 bytes = 0;
Vector<DrainEntry> retry;
// ONLY THE BOUND SHARE GROUP'S TEXELS. The list is the process's, and the validate
// point that drains it belongs to whichever thread draws next - in a client whose
// threads draw with contexts of different share groups, often not the group that
// wrote the texels. Its records would land in the drawing context's group, where the
// texture has no record, and the level's dirty flag would be cleared all the same:
// the texture's own context then sampled a texture that never got its texels. A
// level owed to another group waits for a verb of that group.
const Uint64 group = MGPipeCurrentShareGroupToken();
for (const DrainEntry& pending : m_drain) {
if (pending.Group != group) {
retry.push_back(pending);
continue;
}
if (EmitOneLevel(pending, bytes)) continue;
retry.push_back(pending);
}
@@ -1259,13 +1244,6 @@ namespace MobileGL::MG_Pipe {
return entry.Gen == handle.Gen ? entry.BuiltinSampler : kMGPipeNullHandle;
}
SizeT DrainListSize() const { return m_drain.size(); }
// Whether a level of `handle` is still owed to the server (on the drain list).
Bool OwesUpload(MGPipeHandle handle) const {
for (const DrainEntry& pending : m_drain) {
if (pending.Handle == handle) return true;
}
return false;
}
// A fresh context: what the server has is no longer what this emitter last sent. Only
// LATCHES reset here - the applier's object records survive a make-current and
@@ -1285,8 +1263,7 @@ namespace MobileGL::MG_Pipe {
m_deadResolves = 0;
}
// A unit fixture's per-case reset, and the reset of a session that replaced an ended one
// (MGPipeForgetEndedSession: the fresh server holds none of these records). See
// A unit fixture's per-case reset; the library never calls it. See
// MGPipeResourceTracker::ResetForTest for the rule this restates: a texture handle and
// the applier record it names are SHARE-GROUP OBJECT STATE, so nothing here is
// per-context and no re-publication path exists or may exist.
@@ -1334,7 +1311,6 @@ namespace MobileGL::MG_Pipe {
struct DrainEntry {
MGPipeHandle Handle;
Uint32 Key;
Uint64 Group; // MGPipeCurrentShareGroupToken() when the level went dirty
};
static constexpr Uint32 PackLevelKey(MobileGL::TextureUploadTarget uploadTarget, Uint level) {
-13
View File
@@ -2013,16 +2013,6 @@ namespace MobileGL::MG_Pipe {
// (EGL_KHR_partial_update) before it draws.
// SetDamageRegion eglSetDamageRegionKHR for the current draw surface: Damage is the region
// the frame is about to draw (GL window coordinates; 0 rectangles = all of it).
// Flush glFlush/glFinish of a session that renders INTO images (an X server's glamor):
// every image the session used since its last boundary is published as written
// and read by the flush's fence (implicit sync); answered once published.
// NativeFence EGL_ANDROID_native_fence_sync's fence command: a sync_file that signals
// once everything the session submitted so far has completed (and, in a session
// that writes images, what Flush does)
// reaches the client on the aux socket BEFORE the reply is posted, with the reply's
// Format = kMGPNativeFenceFdFollows. Format = 0: the server has no descriptor to give
// (it cannot export fences, and none it gave before can stand in), and the work has
// completed by the time the reply is posted.
//
// A Present carries the region of the frame to copy (DamageCount rectangles of Damage, GL
// window coordinates, origin bottom-left; 0 = all of it): the client keeps per image what the
@@ -2038,11 +2028,8 @@ namespace MobileGL::MG_Pipe {
kMGPSharedImageAttach = 5,
kMGPSharedImageQueryBufferAge = 6,
kMGPSharedImageSetDamageRegion = 7,
kMGPSharedImageFlush = 8,
kMGPSharedImageNativeFence = 9,
};
inline constexpr Uint32 kMGPBufferAgeDamageRegionFollows = 1u;
inline constexpr Uint32 kMGPNativeFenceFdFollows = 1u;
struct MGPSharedImageOp {
Uint32 Op;
+2 -108
View File
@@ -54,7 +54,6 @@
#include <algorithm>
#include <atomic>
#include <chrono>
#include <cmath>
#include <cstdarg>
#include <cstdio>
@@ -187,22 +186,9 @@ namespace MobileGL::MG_Pipe {
}
}
#endif
static std::atomic<long> armedAt{0};
if (at <= 0) return false;
static std::atomic<long> seen{0};
static std::atomic<bool> fired{false};
if (at <= 0) {
// Unset (or 0) disarms: the same value set again counts afresh.
if (armedAt.load(std::memory_order_relaxed) != 0) armedAt.store(0, std::memory_order_relaxed);
return false;
}
// A NEW VALUE RE-ARMS. One server process outlives many sessions, so a second loss is
// injected by setting the knob again (another value, or 0 and then a value): the count
// restarts from the checks made after it was seen.
if (long previous = armedAt.load(std::memory_order_acquire);
previous != at && armedAt.compare_exchange_strong(previous, at, std::memory_order_acq_rel)) {
seen.store(0, std::memory_order_release);
fired.store(false, std::memory_order_release);
}
if (fired.load(std::memory_order_acquire)) return false;
if (seen.fetch_add(1, std::memory_order_acq_rel) + 1 < at) return false;
if (fired.exchange(true, std::memory_order_acq_rel)) return false;
@@ -210,47 +196,6 @@ namespace MobileGL::MG_Pipe {
return true;
}
bool MGPipeDebugSessionLossDue(unsigned clientPid) {
if (clientPid == 0) return false;
// The first call on a thread only starts the clock, so a session is first asked 100 ms
// after it started rendering - never in the middle of its first make-current.
thread_local auto lastAsked = std::chrono::steady_clock::time_point{};
const auto now = std::chrono::steady_clock::now();
if (lastAsked == std::chrono::steady_clock::time_point{}) {
lastAsked = now;
return false;
}
if (now - lastAsked < std::chrono::milliseconds(100)) return false;
lastAsked = now;
long target = 0;
if (const char* value = std::getenv("MOBILEGL_DEBUG_INJECT_DEVICE_LOST_PID")) {
target = std::strtol(value, nullptr, 10);
}
#if defined(__ANDROID__)
else {
char property[PROP_VALUE_MAX] = {};
if (__system_property_get("debug.mobilegl.inject_device_lost_pid", property) > 0) {
target = std::strtol(property, nullptr, 10);
}
}
#endif
// Once per value: the session it hit is over, and a later session of the same process (the
// recovery's) must not be lost again by the same setting. Another pid - or unset/0 and
// then the same one - re-arms it.
static std::atomic<long> firedFor{0};
if (target <= 0) {
if (firedFor.load(std::memory_order_relaxed) != 0) firedFor.store(0, std::memory_order_relaxed);
return false;
}
if (static_cast<unsigned long>(target) != clientPid) return false;
long previous = firedFor.load(std::memory_order_acquire);
if (previous == target || !firedFor.compare_exchange_strong(previous, target, std::memory_order_acq_rel)) {
return false;
}
MGLOG_E("MGPipe: debug knob inject_device_lost_pid=%ld - this session's device is reported LOST", target);
return true;
}
bool MGPipeSessionLatch(MGPipeFatalFamily family, const char* fmt, ...) {
char line[512];
va_list args;
@@ -663,37 +608,12 @@ namespace MobileGL::MG_Pipe {
return raw;
}
// Every share group's object records in the session the calling thread's records are
// applied for, or nothing on a thread that serves no session (the process-wide applier is
// then the only one). The pointers stay valid after the lock is dropped: a group's records
// are held by UniquePtr, and only this session's own apply thread adds or drops its groups.
Vector<MGPipeObjectRecords*> BoundSessionGroups() {
Vector<MGPipeObjectRecords*> groups;
const MGPipeApplierKeyResolver resolve = g_applierKeyResolver;
MGPipeApplierKey key;
if (resolve == nullptr || !resolve(&key)) return groups;
std::lock_guard<std::mutex> guard(g_applierSessionsMutex);
const auto session = g_applierSessions.find(key.SessionKey);
if (session == g_applierSessions.end()) return groups;
for (auto& [groupKey, records] : session->second.Groups) {
(void)groupKey;
if (records) groups.push_back(records.get());
}
return groups;
}
thread_local MGPipeApplierState* t_applierCached = nullptr;
thread_local Uint64 t_applierCachedSession = 0;
thread_local Uint64 t_applierCachedContext = 0;
thread_local Uint64 t_applierCachedGeneration = 0;
} // namespace
Uint64 MGPipeNextApplierSerialBase() {
// Constant-initialized, so the default applier's static construction may already use it.
static std::atomic<Uint64> appliers{0};
return (appliers.fetch_add(1, std::memory_order_relaxed) + 1) << 40;
}
MGPipeApplierState& MGPipeApplier() {
const MGPipeApplierKeyResolver resolve = g_applierKeyResolver;
if (resolve == nullptr) return g_defaultApplier;
@@ -2438,12 +2358,7 @@ namespace MobileGL::MG_Pipe {
// the mask arrives - and by construction only the non-storage fields differ.
record->Desc = desc;
// A shared image is the storage this call replaces - unless the call replaces none.
if ((level != nullptr || !metadataOnly) && record->SharedImageId != 0) {
MGLOG_D("MGPipe: texture %u leaves shared image %llu: a respecify (%s) redefined its storage",
desc.GlNameForDiag, static_cast<unsigned long long>(record->SharedImageId),
level != nullptr ? "one level" : "whole resource");
record->SharedImageId = 0;
}
if (level != nullptr || !metadataOnly) record->SharedImageId = 0;
#if MOBILEGL_BUILD_DISAGGREGATED
if (level != nullptr && desc.Target != static_cast<Uint8>(MGPipeResourceTarget::TexBuffer)) {
// Scope and BufOffset/BufSize are transient respecify carriers, not resource state.
@@ -3305,27 +3220,6 @@ namespace MobileGL::MG_Pipe {
void MGPipeApplyDeleteSamplerState(const MGPHandleOnly& handle) {
MOBILEGL_ASSERT(handle.Kind == static_cast<Uint32>(MGPipeKind::SamplerCso),
"delete_sampler_state on kind %u", handle.Kind);
// A SAMPLER CSO IS ONE VALUE FOR THE WHOLE SESSION, and its delete drops it from every
// share group that holds it. The client's cache is content-addressed and process-wide:
// one handle names one canonical value, published into each group that uses it (a
// record per group, all of them copies), and the cache's eviction frees the handle -
// which ends it in every group at once, whichever context happens to be bound. Dropping
// only the bound group's copy left every other group a record at a slot the client hands
// out again. The handle space is the client's, so no other object can hold this slot at
// this generation in any of the session's groups.
if (const Vector<MGPipeObjectRecords*> groups = BoundSessionGroups(); !groups.empty()) {
Bool dropped = false;
for (MGPipeObjectRecords* group : groups) {
MGPipeSamplerCsoRecord* held = FindIn(group->SamplerCsos, handle.Handle);
if (held == nullptr) continue;
const Uint32 gen = held->Gen;
*held = MGPipeSamplerCsoRecord{};
held->Gen = gen;
dropped = true;
}
if (!dropped) (void)ResolveObject(MGPipeApplier().SamplerCsos, "delete_sampler_state", handle.Handle);
return;
}
MGPipeSamplerCsoRecord* record =
ResolveObject(MGPipeApplier().SamplerCsos, "delete_sampler_state", handle.Handle);
if (record == nullptr) return;
+1 -15
View File
@@ -938,15 +938,6 @@ namespace MobileGL::MG_Pipe {
};
// P14: where a new applier's working-state serials start. Each applier (one per served context)
// gets a range of its own, 2^40 values wide, so no two appliers ever answer with the same serial:
// the backends key process-wide memos on these serials (a texture sync list on ContextSerial and
// SamplerViewsSerial, the synced framebuffer binding on FramebufferSerial, ...), and one apply
// thread serves every context of its session. With every applier counting from 0, two contexts
// at the same point of their lives answered the same keys, and a draw in one replayed the memo
// the other had built - its own textures went unsynced and it sampled them empty.
Uint64 MGPipeNextApplierSerialBase();
// =====================================================================================
// P14 S5: ONE CONTEXT'S APPLIER = ITS OWN WORKING STATE + ITS SHARE GROUP'S RECORDS.
// =====================================================================================
@@ -990,12 +981,7 @@ namespace MobileGL::MG_Pipe {
TextureResources(objects.TextureResources), RenderbufferResources(objects.RenderbufferResources),
SamplerCsos(objects.SamplerCsos), SamplerViewCsos(objects.SamplerViewCsos),
ShaderCsos(objects.ShaderCsos), CompositeShaderCsos(objects.CompositeShaderCsos),
FramebufferRecords(objects.FramebufferRecords) {
const Uint64 base = MGPipeNextApplierSerialBase();
VertexBuffersSerial = IndexBufferSerial = FramebufferSerial = SamplerViewsSerial = base;
SamplerStatesSerial = ShaderImagesSerial = ProgramBindingSerial = ShaderBuffersSerial = base;
TextureShutterSerial = ContextSerial = base;
}
FramebufferRecords(objects.FramebufferRecords) {}
// ---- THE THREE FRAMEBUFFER ACCESSORS (ID-19(b)/(d)). They are functions rather than
// members because the storage moved under them and their callers must not have to know
-16
View File
@@ -266,22 +266,6 @@ namespace MobileGL::MG_Pipe {
void MGPipeClientFinish();
// Submit a stream link's published prefix; never wait for appliedSeq.
void MGPipeClientFlush();
// The texture sub-data drain of a validate point, outside one: a shared-image producer's
// glFlush (an X server's PutImage into a window pixmap is followed by no draw of its own)
// has to get its uploads to the server before the flush publishes the images. Gated as the
// validate point's drain is; a no-op on a monolith and on the server role.
void MGPipeClientDrainTextureUploads();
// A FRESH SESSION REPLACES AN ENDED ONE (a device loss recovered, or an eglTerminate /
// eglInitialize): every client-side answer to "what does the server hold" describes the
// ended session's server, and the new one holds nothing. The publication latch, the
// content-addressed caches (render-state and sampler CSOs, their slots freed), the
// resource tracker's published bits, the texture emitter's records and owed uploads, every
// emitter's per-context latches, the dirty tracker, the deferred destroys and the residual
// fill's pins all start over. Emits nothing; ClientSession::FinishStartup calls it before
// the new session serves its first record. Objects of the ended session that are still
// alive find themselves unpublished, so their deaths put nothing on the new wire.
void MGPipeForgetEndedSession();
#endif
void MGPipeEmitResourceCreate(MG_State::GLState::BufferObject& buffer);
+2 -13
View File
@@ -119,20 +119,9 @@ namespace MobileGL::MG_Pipe {
// A DEBUG KNOB THAT MAKES ONE DEVICE CHECK REPORT A LOSS, so the containment above can be
// driven without a GPU that faults on demand. MOBILEGL_DEBUG_INJECT_DEVICE_LOST_AT=N (or, on
// Android, the property debug.mobilegl.inject_device_lost_at) makes the N-th device check the
// backends make after the knob was first seen nonzero answer "lost", once per value: setting
// another value (or 0 and then a value again) re-arms it, so one server process can lose
// several sessions in turn. The backends ask at their frame boundaries and readbacks; unset
// (the default) it is one getenv.
// backends make after the knob was first seen nonzero answer "lost", once per process. The
// backends ask at their frame boundaries and readbacks; unset (the default) it is one getenv.
bool MGPipeDebugDeviceLossDue();
// THE SAME KNOB, AIMED AT ONE CLIENT. MOBILEGL_DEBUG_INJECT_DEVICE_LOST_PID=P (Android: the
// property debug.mobilegl.inject_device_lost_pid) loses the session whose client named pid P in
// its Hello (its own pid, as it sees it - a container's own pid namespace included), once per
// value, whatever the backend and whether or not that client ever presents or reads back: the
// server's apply thread asks after every drain. It is how one application among several is
// made to lose its device - a browser's GPU process, which renders into dma-bufs and never
// presents, included. Asked only for a session with a context bound; asks the environment /
// property at most every 100 ms per thread.
bool MGPipeDebugSessionLossDue(unsigned clientPid);
#endif
} // namespace MobileGL::MG_Pipe
@@ -227,24 +227,11 @@ namespace MobileGL::MG_Remote::Client {
// depth24+stencil8 surface, and every buffer allocated from that answer is
// blit-incompatible with the real thing).
if (ClientSession* session = ClientSession::Active()) session->DrainPublishedEvents();
if (!MG_Backend::BackendObject::CreateEGLWindowSurface(surface, handle)) return false;
NoteHomed(surface);
return true;
return MG_Backend::BackendObject::CreateEGLWindowSurface(surface, handle);
}
Bool BackendObject_Remote::ResizeEGLWindowSurface(EGLSurface surface, Uint32 width, Uint32 height) {
WaitForApplyBeforeEglForwarder("ResizeEGLWindowSurface");
// A surface with no server side on this session (its session was lost) takes the size
// into its registration only; it is re-created at that size when it is next used.
{
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
if (GetRegisteredEGLSurface(surface) != nullptr && m_homedSurfaces.count(surface) == 0) {
// A server-owned one asks the fresh session's window for this size, as a resize would.
if (ClientSession::IsServerOwnedWindowSurface(surface))
m_serverOwnedRequests[surface] = {width, height};
return MG_Backend::BackendObject::ResizeEGLWindowSurface(surface, width, height);
}
}
// P12 review fix: a surface on the SERVER's window is resized by resizing that window. The
// server asks its display for the size and answers with the extent the window really took,
// and that - not the size asked for, which EGLImpl already wrote into the EGL state - is what
@@ -258,7 +245,6 @@ namespace MobileGL::MG_Remote::Client {
width, height, static_cast<int>(reply.transport), Server::SurfaceRefusalCodeName(reply.refusal));
return false;
}
NoteServerOwnedRequest(surface, width, height);
const Uint32 realWidth = reply.width != 0 ? reply.width : width;
const Uint32 realHeight = reply.height != 0 ? reply.height : height;
if (MG_State::pEGLContext) {
@@ -294,21 +280,9 @@ namespace MobileGL::MG_Remote::Client {
}
Bool BackendObject_Remote::CreateEGLPbufferSurface(EGLSurface surface, EGLint width, EGLint height) {
return CreatePbufferOnServer(surface, width, height, /*standIn=*/false);
}
Bool BackendObject_Remote::CreateEGLSurfacelessStandIn(EGLSurface surface, EGLint width, EGLint height) {
if (!CreatePbufferOnServer(surface, width, height, /*standIn=*/true)) return false;
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
m_standInSurfaces.insert(surface);
return true;
}
Bool BackendObject_Remote::CreatePbufferOnServer(EGLSurface surface, EGLint width, EGLint height, Bool standIn) {
WaitForApplyBeforeEglForwarder("CreateEGLPbufferSurface");
Server::SurfaceRefusalCode refusal = Server::SurfaceRefusalCode::None;
if (!Server::ServerCreateEGLPbufferSurface(surface, width, height, &refusal,
standIn ? Server::kPbufferFlagSurfacelessStandIn : 0u)) {
if (!Server::ServerCreateEGLPbufferSurface(surface, width, height, &refusal)) {
if (refusal == Server::SurfaceRefusalCode::SurfaceModeMismatch) {
// P12 (D4), named on THIS side too: the server logged its half.
MGLOG_E("MG_Remote client: SurfaceModeMismatch - eglCreatePbufferSurface (%dx%d) in a session "
@@ -322,9 +296,7 @@ namespace MobileGL::MG_Remote::Client {
// Same drain as the window surface: InitPbufferSurface publishes the default
// framebuffer's depth/stencil format on SEG_EVENT from inside this very RPC.
if (ClientSession* session = ClientSession::Active()) session->DrainPublishedEvents();
if (!MG_Backend::BackendObject::CreateEGLPbufferSurface(surface, width, height)) return false;
NoteHomed(surface);
return true;
return MG_Backend::BackendObject::CreateEGLPbufferSurface(surface, width, height);
}
namespace {
@@ -396,10 +368,7 @@ namespace MobileGL::MG_Remote::Client {
if (local.Handle == nullptr) local.Handle = &g_serverOwnedWindowPlaceholder;
local.Width = reply.width;
local.Height = reply.height;
if (!MG_Backend::BackendObject::CreateEGLWindowSurface(surface, local)) return false;
NoteServerOwnedRequest(surface, handle.Width, handle.Height);
NoteHomed(surface);
return true;
return MG_Backend::BackendObject::CreateEGLWindowSurface(surface, local);
}
Bool BackendObject_Remote::MakeEGLCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
@@ -409,15 +378,6 @@ namespace MobileGL::MG_Remote::Client {
// InitCapabilities' answer comes from a snapshot the server can only publish once its
// own InitCapabilities has run - and ServerMakeEGLCurrent is what publishes it.
WaitForApplyBeforeEglForwarder("MakeEGLCurrent");
const Bool release = draw == EGL_NO_SURFACE && read == EGL_NO_SURFACE && ctx == EGL_NO_CONTEXT;
// A RELEASE ALWAYS SUCCEEDS ON A LOST SESSION. Its server has nothing left to unbind, and
// an application releasing a lost context before it destroys it - the order EGL asks for -
// must not be told EGL_BAD_ACCESS and left with the lost context still current.
if (release && ClientSession::SessionLatchedLost()) {
return MG_Backend::BackendObject::MakeEGLCurrent(dpy, draw, read, ctx);
}
// A surface a lost session had gets its server side back before anything is bound to it.
if (!release && (!EnsureSurfaceHomed(draw) || (read != draw && !EnsureSurfaceHomed(read)))) return false;
// The frame carries the context's CLIENT TOKEN rather than its handle (the server's
// MakeCurrent arm binds the session to it before the native bind). Identity is all the
// server reads from the field otherwise, and a token is as unique as a handle.
@@ -459,7 +419,6 @@ namespace MobileGL::MG_Remote::Client {
// on the server directly and put no record on the wire, which is the shape every gate
// in this phase exists to catch. The forwarder exists for a spawned P6 client whose
// Present record cannot carry the swap; in P5 it has no caller and that is deliberate.
if (!EnsureSurfaceHomed(draw)) return false;
return MG_Backend::BackendObject::SwapEGLBuffers(dpy, draw);
}
@@ -481,101 +440,18 @@ namespace MobileGL::MG_Remote::Client {
void BackendObject_Remote::ReleaseEGLSurface(EGLSurface surface) {
// P12: a released server-owned surface stops taking the server window's geometry.
if (ClientSession* session = ClientSession::Active()) session->ForgetServerOwnedWindowSurface(surface);
// Only a surface the current session's server has: one a lost session had is gone with it.
Bool homed = false;
{
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
homed = m_homedSurfaces.erase(surface) != 0;
m_standInSurfaces.erase(surface);
m_serverOwnedRequests.erase(surface);
}
if (homed && !ClientSession::SessionLatchedLost()) Server::ServerReleaseEGLSurface(surface);
Server::ServerReleaseEGLSurface(surface);
MG_Backend::BackendObject::ReleaseEGLSurface(surface);
}
void BackendObject_Remote::ReleaseEGLResources() {
// BLOCKING BY CONTRACT (ServerLoop.h's header note): MobileGL::Destroy()
// (MobileGL/Init.cpp:68) walks on the moment this returns, and the server still holds
// the context until the apply thread has run it. A lost session's server holds nothing.
if (!ClientSession::SessionLatchedLost()) Server::ServerReleaseEGLResources();
{
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
m_homedSurfaces.clear();
m_standInSurfaces.clear();
}
// the context until the apply thread has run it.
Server::ServerReleaseEGLResources();
MG_Backend::BackendObject::ReleaseEGLResources();
}
void BackendObject_Remote::OnSessionReplaced() {
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
ResetEGLRuntimeState();
m_homedSurfaces.clear();
for (const auto& [id, references] : m_sessionSharedImages) m_lostSessionSharedImages.insert(id);
m_sessionSharedImages.clear();
// The display the application initialized is initialized on the new server too: its
// surfaces and contexts are created against it from here on.
if (m_eglDisplayInitialized) {
EGLint major = 0;
EGLint minor = 0;
if (!Server::ServerInitializeEGLDisplay(m_eglDisplay, &major, &minor)) {
MGLOG_E("MG_Remote client: the fresh session's server did not initialize the display; "
"surfaces and contexts on it will fail");
}
}
if (ClientSession* session = ClientSession::Active()) session->PumpControlPlane();
RefreshFormatCapabilities();
}
Bool BackendObject_Remote::EnsureSurfaceHomed(EGLSurface surface) {
if (surface == EGL_NO_SURFACE) return true;
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
if (m_homedSurfaces.count(surface) != 0) return true;
const EGLSurfaceState* registered = GetRegisteredEGLSurface(surface);
// Unknown to this object: the base class's own checks answer for it.
if (registered == nullptr) return true;
const EGLSurfaceState state = *registered;
Bool recreated = false;
const char* kind = "pbuffer";
if (state.Kind == SurfaceKind::Pbuffer) {
const Uint32 flags = m_standInSurfaces.count(surface) != 0 ? Server::kPbufferFlagSurfacelessStandIn : 0u;
recreated = Server::ServerCreateEGLPbufferSurface(surface, state.Width, state.Height, nullptr, flags);
} else if (ClientSession::IsServerOwnedWindowSurface(surface)) {
kind = "server-owned window";
// The window is asked for what the application asked for (its own size for a surface
// created without one), not for the extent it had: that would fix its size for good.
const auto requested = m_serverOwnedRequests.find(surface);
const Uint32 wantWidth = requested != m_serverOwnedRequests.end() ? requested->second.first : 0u;
const Uint32 wantHeight = requested != m_serverOwnedRequests.end() ? requested->second.second : 0u;
const Server::ServerOwnedWindowReply reply =
Server::ServerCreateServerOwnedWindowSurface(surface, wantWidth, wantHeight);
recreated = reply.ok;
if (recreated && reply.width != 0 && reply.height != 0) {
if (MG_State::pEGLContext) {
(void)MG_State::pEGLContext->SetSurfaceExtent(surface, static_cast<EGLint>(reply.width),
static_cast<EGLint>(reply.height));
}
if (ClientSession* session = ClientSession::Active())
session->NoteServerOwnedWindowSurface(surface, reply.width, reply.height);
}
} else {
kind = "window";
Server::ServerSetWindowHandle(state.Window);
recreated = Server::ServerCreateEGLWindowSurface(surface, state.Window);
}
if (!recreated) {
MGLOG_E("MG_Remote client: the %s surface %p (%dx%d) of a lost session could not be re-created on "
"the fresh one",
kind, static_cast<void*>(surface), state.Width, state.Height);
return false;
}
if (ClientSession* session = ClientSession::Active()) session->DrainPublishedEvents();
m_homedSurfaces.insert(surface);
MGLOG_I("MG_Remote client: the %s surface %p (%dx%d) of a lost session is re-created on the fresh one "
"(EGL keeps surfaces across a context loss; their contents are undefined)",
kind, static_cast<void*>(surface), state.Width, state.Height);
return true;
}
// ---- shared images ----------------------------------------------------------------------
//
// One shared_image record each (ClientSession::EmitSharedImage). Allocate/Import/Release are
@@ -585,9 +461,6 @@ namespace MobileGL::MG_Remote::Client {
MG_Backend::SharedImageExport* out) {
ClientSession* session = ClientSession::Active();
if (session == nullptr || out == nullptr) return false;
// A table operation, not a draw: the calling thread's GL state (a lost context, or none) has
// no say in whether the server allocates.
const ClientSession::ScopedCurrentSessionWork tableOp;
MG_Pipe::MGPSharedImageOp op{};
op.Op = MG_Pipe::kMGPSharedImageAllocate;
op.Format = fourcc;
@@ -604,17 +477,12 @@ namespace MobileGL::MG_Remote::Client {
out->Stride = reply.Stride;
out->Offset = reply.Offset;
out->Modifier = reply.Modifier;
{
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
++m_sessionSharedImages[reply.ImageId];
}
return true;
}
Bool BackendObject_Remote::ImportSharedImage(int fd, Uint32 width, Uint32 height, Uint32 fourcc, Uint64* outId) {
ClientSession* session = ClientSession::Active();
if (session == nullptr || fd < 0) return false;
const ClientSession::ScopedCurrentSessionWork tableOp;
MG_Pipe::MGPSharedImageOp op{};
op.Op = MG_Pipe::kMGPSharedImageImport;
op.Format = fourcc;
@@ -623,26 +491,12 @@ namespace MobileGL::MG_Remote::Client {
MG_Pipe::MGPSharedImageReply reply{};
if (!session->EmitSharedImage(op, fd, &reply, nullptr)) return false;
if (outId != nullptr) *outId = reply.ImageId;
{
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
++m_sessionSharedImages[reply.ImageId];
}
return true;
}
Bool BackendObject_Remote::ReleaseSharedImage(Uint64 id) {
ClientSession* session = ClientSession::Active();
if (session == nullptr || !session->Started()) return false;
// An image of a lost session is gone with its server; the fresh one never issued its id.
{
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
const auto held = m_sessionSharedImages.find(id);
// Nothing to release on the new server, and nothing that failed: the reference died with
// its session.
if (held == m_sessionSharedImages.end()) return m_lostSessionSharedImages.erase(id) != 0;
if (--held->second == 0) m_sessionSharedImages.erase(held);
}
const ClientSession::ScopedCurrentSessionWork tableOp;
MG_Pipe::MGPSharedImageOp op{};
op.Op = MG_Pipe::kMGPSharedImageRelease;
op.ImageId = id;
@@ -652,7 +506,6 @@ namespace MobileGL::MG_Remote::Client {
Bool BackendObject_Remote::PresentToSharedImage(Uint64 id, const MG_Util::Damage::Region& region) {
ClientSession* session = ClientSession::Active();
if (session == nullptr) return false;
if (!HoldsSharedImage(id)) return false; // a lost session's image: gone with its server
MG_Pipe::MGPSharedImageOp op{};
op.Op = MG_Pipe::kMGPSharedImagePresent;
op.ImageId = id;
@@ -686,7 +539,6 @@ namespace MobileGL::MG_Remote::Client {
Bool BackendObject_Remote::AttachSharedImageToTexture(Uint64 textureLifetimeId, Uint64 id) {
ClientSession* session = ClientSession::Active();
if (session == nullptr) return false;
if (!HoldsSharedImage(id)) return false; // an EGLImage of a lost session: its image is gone
MG_Pipe::MGPSharedImageOp op{};
op.Op = MG_Pipe::kMGPSharedImageAttach;
op.ImageId = id;
@@ -696,30 +548,6 @@ namespace MobileGL::MG_Remote::Client {
return session->EmitSharedImage(op, -1, nullptr, nullptr);
}
Bool BackendObject_Remote::FlushSharedImageAccesses() {
ClientSession* session = ClientSession::Active();
if (session == nullptr || !session->Started()) return false;
if (m_sharedImageFlushedAt != 0 && session->LastPublishedSeq() == m_sharedImageFlushedAt) return true;
MG_Pipe::MGPSharedImageOp op{};
op.Op = MG_Pipe::kMGPSharedImageFlush;
const Bool published = session->EmitSharedImage(op, -1, nullptr, nullptr);
m_sharedImageFlushedAt = session->LastPublishedSeq();
return published;
}
Bool BackendObject_Remote::CreateNativeFence(int* fence) {
*fence = -1;
ClientSession* session = ClientSession::Active();
if (session == nullptr || !session->Started()) return false;
MG_Pipe::MGPSharedImageOp op{};
op.Op = MG_Pipe::kMGPSharedImageNativeFence;
MG_Pipe::MGPSharedImageReply reply{};
if (!session->EmitSharedImage(op, -1, &reply, fence)) return false;
// It published what a flush would: a flush right after it has nothing new to say.
m_sharedImageFlushedAt = session->LastPublishedSeq();
return true;
}
// NO strong CreateRemoteBackendObject() lives here, and the reason is a link fact, not an
// oversight. v1's Init.cpp calls MG_Remote::Client::CreateRemoteBackendObject() and ships a
// __attribute__((weak)) placeholder for it beside ServerLoop that aborts by name; its comment
@@ -51,10 +51,6 @@
#include <MG_Backend/BackendObject.h>
#include <unordered_map>
#include <unordered_set>
#include <utility>
namespace MobileGL::MG_Remote::Client {
class BackendObject_Remote final : public MG_Backend::BackendObject {
@@ -95,27 +91,12 @@ namespace MobileGL::MG_Remote::Client {
Bool QueryBufferAge(Bool damageRegionFollows, EGLint* age) override;
Bool SetDamageRegion(const MG_Util::Damage::Region& region) override;
Bool AttachSharedImageToTexture(Uint64 textureLifetimeId, Uint64 id) override;
Bool FlushSharedImageAccesses() override;
Bool CreateNativeFence(int* fence) override;
// Copies the caps mirror's FormatCapabilityCache into the base class's
// m_formatCapabilities. Public because CapsMirror's adoption hook is a free function
// and this is what it calls; it is the whole of trap 2's answer.
void RefreshFormatCapabilities();
// A FRESH SESSION REPLACED A LOST ONE (ClientSession::RecoverAfterDeviceLoss). The
// initialized display is initialized on the new server; every surface keeps its client
// registration (EGL keeps surfaces across a context loss, only their contents go) but
// has no server side yet, and is re-created there the next time it is made current,
// swapped or resized; no thread is current any more; the shared images of the lost
// session are forgotten without a release (their server is gone).
void OnSessionReplaced();
// EGL_KHR_surfaceless_context's hidden pbuffer (EGLImpl's SurfacelessStandIn): an ordinary
// pbuffer on this side, created on the server with kPbufferFlagSurfacelessStandIn so it
// takes no surface mode there, and re-created the same way on a fresh session.
Bool CreateEGLSurfacelessStandIn(EGLSurface surface, EGLint width, EGLint height);
protected:
Bool InitPbufferSurface(EGLint width, EGLint height) override;
@@ -125,48 +106,10 @@ namespace MobileGL::MG_Remote::Client {
// geometry adopted before it returns, and every refusal named in this process's log.
Bool CreateServerOwnedWindowSurface(EGLSurface surface, const MG_Backend::WindowHandle& handle);
// The stream position right after the last shared-image Flush record: a flush with nothing
// published since has nothing new to fence and costs no round trip.
Uint64 m_sharedImageFlushedAt = 0;
// The generation of the snapshot m_formatCapabilities was filled from. Exposed only
// through the log line on a refresh: a cache that silently stopped tracking the mirror
// is exactly the shape trap 2 exists to prevent.
Uint64 m_formatsGeneration = 0;
// The server side of `surface` on the CURRENT session: re-created from its client
// registration when the session that had it was replaced. True when it exists now.
Bool EnsureSurfaceHomed(EGLSurface surface);
Bool CreatePbufferOnServer(EGLSurface surface, EGLint width, EGLint height, Bool standIn);
void NoteHomed(EGLSurface surface) {
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
m_homedSurfaces.insert(surface);
}
Bool HoldsSharedImage(Uint64 id) const {
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
return m_sessionSharedImages.count(id) != 0;
}
// The surfaces and shared images the CURRENT session's server holds. A surface missing
// from the first is one a lost session had (EnsureSurfaceHomed); an image id missing from
// the second (counted per reference taken) is a lost session's, and is neither released
// nor presented to nor attached on the new server, which never issued it. Guarded by the
// base's m_eglStateMutex.
std::unordered_set<EGLSurface> m_homedSurfaces;
// The surfaceless stand-ins among this object's pbuffers. Guarded by m_eglStateMutex.
std::unordered_set<EGLSurface> m_standInSurfaces;
std::unordered_map<Uint64, Uint32> m_sessionSharedImages; // id -> references taken
// The ids a replaced session held: releasing one is a success with nothing sent.
std::unordered_set<Uint64> m_lostSessionSharedImages;
// The size each server-owned window surface ASKED for (0x0: the window's own), which is what a
// fresh session is asked for again when the surface is re-created there - not the extent the
// window happened to have, which would fix the window's size for good. Guarded by
// m_eglStateMutex.
std::unordered_map<EGLSurface, std::pair<Uint32, Uint32>> m_serverOwnedRequests;
void NoteServerOwnedRequest(EGLSurface surface, Uint32 width, Uint32 height) {
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
m_serverOwnedRequests[surface] = {width, height};
}
};
} // namespace MobileGL::MG_Remote::Client
+8 -180
View File
@@ -24,15 +24,12 @@
#include "../Transport/InProcessTransport.h"
#include "WireTables.h"
#include "EmitTables.h"
#include "PersistentMapTracker.h"
#include "ServerProbe.h"
#include <MGGitHash.h>
#include <MG_Backend/MGPipe/PipeInputs.h>
#include <MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h>
#include <MG_Impl/Pipe/ResourceTracker.h>
#include <MG_Pipe/MGPipeCallbacks.h>
#include <MG_Pipe/PipeMutation.h>
#include <MG_State/EGLState/Core.h>
#include <MG_State/GLState/Core.h>
#include <MG_State/GLState/ErrorState/ErrorInfo.h>
@@ -97,34 +94,6 @@ namespace MobileGL::MG_Remote::Client {
ClientSession* g_active = nullptr;
// THE RECOVERY'S THREE PIECES OF PROCESS STATE (ClientSession.h). The two scopes are
// per thread and nest; the count is how many sessions with a remote server this process
// has started, so the second and later know there is an ended one to forget.
thread_local Uint32 tl_wireMute = 0;
thread_local Uint32 tl_currentSessionWork = 0;
std::atomic<Uint64> g_remoteSessionsStarted{0};
// ClientSession::LastLossReason(). Leaked on purpose: read from GL entry points that may
// run during process exit.
std::mutex& LossReasonMutex() {
static auto* mutex = new std::mutex();
return *mutex;
}
String& LossReason() {
static auto* reason = new String();
return *reason;
}
// The latch's words for a session the server ended on a named fault: what happened, and
// the fault family the server named (BackendDeviceLost for a GPU device loss).
String FaultReason(const ::MobileGL::Wire::CtrlEnvelope* envelope, const char* what) {
String reason = what;
if (const auto* fatal = envelope->msg_as_Fatal(); fatal != nullptr && fatal->family() != nullptr) {
reason += " (Fatal family ";
reason += fatal->family()->c_str();
reason += ")";
}
return reason;
}
// The same bounded handshake deadline the server uses. Bounded, not kWaitForever: a
// bring-up that never answers has to be a red lane rather than a wedged CI job.
constexpr Uint32 kHandshakeTimeoutMs = 5000;
@@ -624,36 +593,10 @@ namespace MobileGL::MG_Remote::Client {
ClientSession* ClientSession::Active() { return g_active; }
Bool ClientSession::DeviceLost() {
if (tl_wireMute != 0) return true;
const ClientSession* session = Active();
if (session == nullptr) return false;
if (session->m_deviceLost.load(std::memory_order_acquire)) return true;
if (tl_currentSessionWork != 0) return false;
// A thread that released a lost context and has bound none since (MG_State's marker).
if (MG_State::tThreadReleasedLostContext) return true;
// A thread still on a context from before a recovered loss: lost for good, whatever the
// session it would now be writing into.
const SharedPtr<MG_State::GLState::GLContext>& context = MG_State::pGLContext;
return context != nullptr && context->IsFromEndedWireSession();
}
String ClientSession::LastLossReason() {
const std::lock_guard<std::mutex> lock(LossReasonMutex());
return LossReason();
}
Bool ClientSession::SessionLatchedLost() {
const ClientSession* session = Active();
return session != nullptr && session->m_deviceLost.load(std::memory_order_acquire);
}
ClientSession::ScopedWireMute::ScopedWireMute() { ++tl_wireMute; }
ClientSession::ScopedWireMute::~ScopedWireMute() { --tl_wireMute; }
ClientSession::ScopedCurrentSessionWork::ScopedCurrentSessionWork() { ++tl_currentSessionWork; }
ClientSession::ScopedCurrentSessionWork::~ScopedCurrentSessionWork() { --tl_currentSessionWork; }
Uint64 ClientSession::SessionsStarted() { return g_remoteSessionsStarted.load(std::memory_order_acquire); }
void ClientSession::LatchDeviceLost(const char* why) {
// exchange, so the log line is written EXACTLY once however many waits notice the same
// hangup at the same moment - and there will be several: the barrier, the control wait
@@ -661,95 +604,13 @@ namespace MobileGL::MG_Remote::Client {
if (m_deviceLost.exchange(true, std::memory_order_acq_rel)) {
return;
}
{
const std::lock_guard<std::mutex> lock(LossReasonMutex());
LossReason() = why == nullptr ? "the peer hung up" : why;
}
MGLOG_E("MGPipe: DEVICE LOST - %s. This session's server side is gone; every verb from here "
"is DECLINED and glGetGraphicsResetStatus reports GL_UNKNOWN_CONTEXT_RESET. This is "
"latched from the peer's HANGUP (or its named SessionFault) and not from any "
"deadline (CONTRACT-P6 5.4): a server one frame behind is P5e's intended steady "
"state and must never read as a dead one. The contexts of this session stay lost; "
"the application's next eglCreateContext / eglCreate*Surface / eglInitialize brings "
"a fresh session up (MOBILEGL_IPC_RECOVER=%u).",
why == nullptr ? "the peer hung up" : why, MG_Config::Ipc.RecoverAfterLoss);
}
Bool ClientSession::ConfirmLossAfterDecline(Uint32 waitMs) {
const auto deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(waitMs);
for (;;) {
if (m_deviceLost.load(std::memory_order_acquire)) return true;
PumpControlPlane();
if (const Transport::Doorbell* bell = m_producer.SelfDoorbell(); bell != nullptr && bell->PeerHungUp()) {
LatchDeviceLost("a readback was declined and the peer had hung up");
}
if (m_link && m_link->PeerHungUp()) LatchDeviceLost("a readback was declined and the link had hung up");
if (m_deviceLost.load(std::memory_order_acquire)) return true;
if (std::chrono::steady_clock::now() >= deadline) return false;
std::this_thread::sleep_for(std::chrono::milliseconds(2));
}
}
namespace {
// A LOST SESSION'S T0 STORES STAY MAPPED. A buffer of a lost context may still hold the
// pointer of the store it was adopted into (the application has not destroyed it yet, and
// may write through its persistent mapping), so the recovery's Stop must not unmap it.
// Bounded by what the lost session had adopted; never touched again.
Vector<Transport::AdoptT0::HeldStore>& LostSessionT0Stores() {
static auto* stores = new Vector<Transport::AdoptT0::HeldStore>();
return *stores;
}
} // namespace
MobileGLResult ClientSession::RecoverAfterDeviceLoss() {
if (!m_started || !m_deviceLost.load(std::memory_order_acquire)) return MOBILEGL_OK;
if (MG_Config::Ipc.RecoverAfterLoss == 0) {
MGLOG_E_ONCE("MG_Remote client: Refuse{Recover} the session is lost and MOBILEGL_IPC_RECOVER=0 - "
"no fresh session is dialed; every context of this process stays lost");
return MOBILEGL_ERR_UNSUPPORTED;
}
const std::string control(MG_Config::Ipc.Control.c_str());
if (MG_Config::Transport != MG_Config::TransportMode::Spawn || control.compare(0, 3, "fd:") == 0) {
MGLOG_E_ONCE("MG_Remote client: Refuse{Recover} the session is lost and this transport cannot "
"reach its server again (%s): an in-process server is this process, and a "
"pre-connected fd: pair was handed over once. Every context stays lost",
control.empty() ? "inproc" : control.c_str());
return MOBILEGL_ERR_UNSUPPORTED;
}
// THE SERVER FIRST, THEN THE TEARDOWN. A session that is stopped and cannot be replaced
// leaves no session at all, and a GL call then has nowhere honest to go; a latched session
// that is kept declines every verb, which is the answer the application already has.
if (ProbeConfiguredServer() == ServerProbeResult::Unreachable) {
MGLOG_E("MG_Remote client: the session is lost and no server answers at %s; it stays lost "
"(the next create will ask again)",
control.c_str());
return MOBILEGL_ERR_TRANSPORT_CLOSED;
}
const Uint32 lostServerPid = m_peerServerPid;
for (auto& [key, store] : m_t0Stores) LostSessionT0Stores().push_back(store);
m_t0Stores.clear();
Stop();
const MobileGLResult started = StartSpawned();
if (started != MOBILEGL_OK) {
MGLOG_E("MG_Remote client: the fresh session after a device loss did not come up (rc=%d); "
"there is no session now, and the next create will try again",
static_cast<int>(started));
return started;
}
MGLOG_I("MG_Remote client: RECOVERED - a fresh session (#%llu of this process) replaces the one "
"lost on server pid %u; it is served by pid %u. Contexts created before stay lost",
static_cast<unsigned long long>(SessionsStarted()), lostServerPid, m_peerServerPid);
return MOBILEGL_OK;
}
void ClientSession::ForgetEndedSession() {
MGLOG_I("MG_Remote client: session #%llu follows an ended one - the client's caches of that "
"session's objects (publication, CSOs, samplers, emitter latches, the create window, "
"the reset serial, persistent maps) start over",
static_cast<unsigned long long>(SessionsStarted()));
ForgetWireTablesOfEndedSession();
PersistentMapTracker::Instance().ForgetEndedSession();
MG_Pipe::MGPipeForgetEndedSession();
MGLOG_E("MGPipe: DEVICE LOST - %s. The server process is gone; every verb from here is "
"DECLINED and glGetGraphicsResetStatus reports GL_UNKNOWN_CONTEXT_RESET. This is "
"latched from the peer's HANGUP and not from any deadline (CONTRACT-P6 5.4): a "
"server one frame behind is P5e's intended steady state and must never read as a "
"dead one. There is no recovery - MOBILEGL_IPC_RESPAWN is the stage that would "
"add one and it is refused by name until then.",
why == nullptr ? "the peer hung up" : why);
}
ClientSession& ClientSessionInstance() {
@@ -1677,7 +1538,7 @@ namespace MobileGL::MG_Remote::Client {
MGLOG_E("MG_Remote client: the server published a SessionFault before dying - "
"Fatal family %s: %s", fam, msg);
}
LatchDeviceLost(FaultReason(envelope, "the server published a SessionFault and then aborted").c_str());
LatchDeviceLost("the server published a SessionFault and then aborted");
frame.ok = false;
return MOBILEGL_ERR_TRANSPORT_CLOSED;
}
@@ -1829,17 +1690,6 @@ namespace MobileGL::MG_Remote::Client {
PumpControlPlane();
}
// A SESSION WITH A REMOTE SERVER STARTS FROM A CLEAN CLIENT. Every client-side cache that
// describes what a server holds (published handles, CSO and sampler caches, emitter
// latches, the create window, the applier-reset serial, tracked persistent maps) describes
// the PREVIOUS session's server once this one replaces it - after a device loss, or an
// eglTerminate/eglInitialize - and a fresh server holds none of it. And the wire epoch
// moves, which is what makes every GLContext built against the previous session lost.
// Inproc is left as it was: its server role is this process, and it never recovers.
if (!startApplyThreadHere) {
if (g_remoteSessionsStarted.fetch_add(1, std::memory_order_acq_rel) != 0) ForgetEndedSession();
MG_State::AdvanceWireEpoch();
}
// BOTH, AND m_started FIRST. `Active()` is what the integration lane's skip reads and
// `m_started` is what `EmitAndWait` reads, and c1's round-1 rewrite of this function
// set only the second of the two - so a fully-handshaken session with an apply thread
@@ -2029,12 +1879,6 @@ namespace MobileGL::MG_Remote::Client {
// The cold-start window is the next server's, not this one's (RunRemoteSurfaceControlFrame).
m_serverBackendWarm = false;
m_presentsSent = 0;
// And so are the latch and the control seq space: the next session's server counts its
// ops from 1 and has lost nothing. (The latch is read through Active(), which is null
// from here until a next session is started.)
m_deviceLost.store(false, std::memory_order_release);
m_remoteControlSeq = 0;
m_logFlushSeq = 0;
if (g_active == this) {
g_active = nullptr;
// Mirror order, and the probe goes with it: a dangling function pointer into a
@@ -2764,19 +2608,6 @@ namespace MobileGL::MG_Remote::Client {
static_cast<unsigned long long>(frame.size()));
continue;
}
if (envelope->msg_type() == ::MobileGL::Wire::CtrlMsg::Fatal) {
// The server latched this session on a named fault (a lost GPU device among them)
// and said so before declining the rest: the session is lost, from the server's
// own mouth rather than from the hangup that follows.
if (const auto* fatal = envelope->msg_as_Fatal()) {
MGLOG_E("MG_Remote client: the server ended this session on a named fault - Fatal "
"family %s: %s",
fatal->family() ? fatal->family()->c_str() : "<none>",
fatal->message() ? fatal->message()->c_str() : "");
}
LatchDeviceLost(FaultReason(envelope, "the server published a SessionFault for this session").c_str());
continue;
}
if (envelope->msg_type() != ::MobileGL::Wire::CtrlMsg::CapsSnapshot) {
// SurfaceOp / SurfaceReply / ResyncRequest / AuxRequest / LogLine are P6's and
// P7's. Named rather than ignored, so a phase that starts sending one does not
@@ -3067,9 +2898,6 @@ namespace MobileGL::MG_Remote::Client {
if (status != Wire::ReplySink::kStatusOk || returned != sizeof(answer)) return false;
if (reply != nullptr) *reply = answer;
if (receivedFd == nullptr) return true;
// A native fence's answer says whether a descriptor follows (none: the work completed).
if (op.Op == MG_Pipe::kMGPSharedImageNativeFence && answer.Format != MG_Pipe::kMGPNativeFenceFdFollows)
return true;
#if defined(_WIN32)
return false;
#else
+7 -60
View File
@@ -74,72 +74,22 @@ namespace MobileGL::MG_Remote::Client {
static ClientSession* Active();
// P6 `dl` (CONTRACT-P6 5.3). THE DEVICE-LOST LATCH, and the two words that matter are
// SESSION-SCOPED and LATCH: it is set at most once per session and never cleared while
// that session lives. What recovers is the PROCESS, not the session: the application's
// next eglCreateContext / eglCreate*Surface / eglInitialize ends the lost session and
// dials a fresh one (RecoverAfterDeviceLoss), and every context built before stays lost.
// SESSION-SCOPED and LATCH: it is set at most once per session and never cleared, because
// a session whose server died has nothing left to recover into. MOBILEGL_IPC_RESPAWN is
// where the recovery would go and it is a named refusal until some stage writes it.
//
// SET FROM Doorbell::PeerHungUp() OR THE SERVER'S OWN SessionFault, NEVER FROM A
// TIMEOUT. 5.4's whole point is that slow and dead are different states and must be told
// apart without a threshold: under P5e run-ahead a server one frame behind is the
// INTENDED steady state, so a latch armed by a deadline would fire on a healthy session
// under load. The descriptor (or the server, naming its fault) answers instead.
//
// WHAT THE CALLING THREAD SEES, which is more than the latch: the thread's GL state may
// belong to a session that has already been replaced (a context from before a recovered
// loss, still current on some thread), and for that thread the device is lost for good -
// nothing it does may reach the new session. ScopedWireMute below answers true as well;
// ScopedCurrentSessionWork lifts the thread's own staleness (not the latch).
// SET FROM Doorbell::PeerHungUp(), NEVER FROM A TIMEOUT. 5.4's whole point is that slow
// and dead are different states and must be told apart without a threshold: under P5e
// run-ahead a server one frame behind is the INTENDED steady state, so a latch armed by a
// deadline would fire on a healthy session under load. The descriptor answers instead.
//
// The static form answers false whenever no session is active, so monolith and the pull
// build get the honest answer with no branch of their own.
static Bool DeviceLost();
// The latch alone: is the ACTIVE session lost. What the EGL layer asks before recovering.
static Bool SessionLatchedLost();
// Arms the latch and says why, once. Safe to call repeatedly and from any thread; only
// the first call logs.
void LatchDeviceLost(const char* why);
// Why the most recent session of this process was lost, in the latch's words (empty
// before any loss). Kept past the recovery, because the contexts of the lost session
// outlive it: glGetGraphicsResetStatus names it when it first reports a context's reset.
static String LastLossReason();
// A reply-owning record came back DECLINED where only a latched server declines (a
// readback). The server publishes its SessionFault on the control plane BEFORE it declines,
// so the frame - or the hangup that follows it - is what tells "lost" from a refusal. Pumps
// the control plane and asks the bell for up to `waitMs`; true when the session is lost.
Bool ConfirmLossAfterDecline(Uint32 waitMs);
// THE RECOVERY. Ends this lost session (Stop) and dials the configured server for a fresh
// one (StartSpawned); the new session forgets every client-side cache of the old one and
// advances MG_State's wire epoch, which is what makes every older GLContext lost. The
// caller (EGLImpl) holds the EGL operation lock, which every GL entry point also takes, so
// nothing else is emitting. Refused by name - and the session stays latched - under
// MOBILEGL_IPC_RECOVER=0, for a transport whose server cannot be dialed again (inproc,
// fd:), and when the server does not answer a probe. OK when a fresh session is up.
MobileGLResult RecoverAfterDeviceLoss();
// Sessions brought up in this process so far (the recovery's arm proof for a test).
static Uint64 SessionsStarted();
// While one is open on a thread, that thread's emissions are DECLINED as on a lost
// device: the lost contexts' objects die under it, and their deaths must not reach the
// fresh session.
struct ScopedWireMute {
ScopedWireMute();
~ScopedWireMute();
ScopedWireMute(const ScopedWireMute&) = delete;
ScopedWireMute& operator=(const ScopedWireMute&) = delete;
};
// While one is open on a thread, the thread's own GL state does not make it "lost": EGL
// work that targets the current session on behalf of a thread whose current context is
// a lost one (it creates the replacement context, re-creates a surface).
struct ScopedCurrentSessionWork {
ScopedCurrentSessionWork();
~ScopedCurrentSessionWork();
ScopedCurrentSessionWork(const ScopedCurrentSessionWork&) = delete;
ScopedCurrentSessionWork& operator=(const ScopedCurrentSessionWork&) = delete;
};
// The bell this session parks on, for the `dl` red-once ONLY. A test cannot otherwise
// ask the question the latch turns on - "did the peer hang up" is a fact about a
@@ -682,9 +632,6 @@ namespace MobileGL::MG_Remote::Client {
Uint64 m_t0Fallbacks = 0;
std::function<void(Uint64)> m_prePublish;
void ResetT0(Bool releaseStores);
// Every client-side cache keyed to the session that just ended, dropped before the next
// one serves a record (FinishStartup, on every start after the first).
void ForgetEndedSession();
};
// One per process in P5, because P5 serves one context, and LEAKED AT EXIT like every other
+1 -27
View File
@@ -897,11 +897,6 @@ namespace MobileGL::MG_Remote::Client {
// control, so R-16's "drive the production predicate" holds rather than a second copy of
// the rule in the test.
// How long a declined readback waits for the control plane or the bell to say "lost"
// before it is judged a refusal. The SessionFault is sent before the decline is posted,
// so this is only ever spent on a server that refused for real.
constexpr Uint32 kDeclineVerdictMs = 1000;
// The same predicate at the call site, with the named Fatal each failure mode owns.
// status > expected cannot reach here: EmitAndWait already aborts Fatal{ReplyTooLarge} on
// an oversize reply, so the only failures left are a wrong status or a SHORT one.
@@ -914,17 +909,6 @@ namespace MobileGL::MG_Remote::Client {
// the caller leaves the destination untouched and returns.
Bool RequireReadbackReplyComplete(Int32 status, Uint64 replySize, Uint64 expected) {
if (status != Wire::ReplySink::kStatusOk && ClientSession::DeviceLost()) return false;
// THE DECLINE CAN OUTRUN THE NEWS. A server whose device was lost inside THIS readback
// latches the session - publishing its SessionFault on the control plane - and then
// declines the record; the client can read the declined answer before it has looked at
// the control plane or seen the hangup that follows. So a decline asks once more,
// briefly, before it is taken for a server without GL.ReadPixels.
if (status == Wire::ReplySink::kStatusDeclined) {
if (ClientSession* session = ClientSession::Active();
session != nullptr && session->ConfirmLossAfterDecline(kDeclineVerdictMs)) {
return false;
}
}
if (status == Wire::ReplySink::kStatusError) {
SessionFail(MGFatalFamily::ReplyError, "MGPipe: Fatal{ReplyError, \"ReadPixels\"} - the readback answered ERROR; "
"the destination is left untouched rather than filled with stale bytes");
@@ -1624,11 +1608,6 @@ namespace MobileGL::MG_Remote::Client {
MG_Pipe::MGPipeHandle Handle;
// P10: zero-timeout polls answered "not yet" in a row since the last escalation.
Uint32 Unanswered = 0;
// The session the fence was created on. A fence of an ENDED session (a recovered
// device loss) names nothing on the current server: it is answered as the no-op a
// lost device gives (signaled), and deleting it puts nothing on the wire.
Uint64 Epoch = MG_State::CurrentWireEpoch();
Bool FromEndedSession() const { return Epoch != MG_State::CurrentWireEpoch(); }
};
std::mutex g_fenceMutex;
UnorderedMap<MG_Backend::BackendSyncHandle, UniquePtr<RemoteFenceProxy>> g_fenceProxies;
@@ -1775,7 +1754,6 @@ namespace MobileGL::MG_Remote::Client {
ClientSession& session = RequireSession("ClientWaitSync");
const std::lock_guard<std::mutex> lock(g_fenceMutex);
RemoteFenceProxy& fence = FenceProxy(proxy);
if (fence.FromEndedSession()) return GL_ALREADY_SIGNALED;
switch (AnswerFencePollLocally(session, fence, /*mayWait=*/timeout != 0)) {
case FencePollAnswer::Signaled: return GL_ALREADY_SIGNALED;
case FencePollAnswer::NotYet: return GL_TIMEOUT_EXPIRED;
@@ -1792,7 +1770,6 @@ namespace MobileGL::MG_Remote::Client {
ClientSession& session = RequireSession("GetSyncStatus");
const std::lock_guard<std::mutex> lock(g_fenceMutex);
RemoteFenceProxy& fence = FenceProxy(proxy);
if (fence.FromEndedSession()) return true;
switch (AnswerFencePollLocally(session, fence, /*mayWait=*/false)) {
case FencePollAnswer::Signaled: return true;
case FencePollAnswer::NotYet: return false;
@@ -1809,7 +1786,6 @@ namespace MobileGL::MG_Remote::Client {
void EmitWaitSync(MG_Backend::BackendSyncHandle proxy, GLbitfield flags, GLuint64 timeout) {
ClientSession& session = RequireSession("WaitSync");
const std::lock_guard<std::mutex> lock(g_fenceMutex);
if (FenceProxy(proxy).FromEndedSession()) return;
const MG_Pipe::MGPFenceWait request{FenceHandle(proxy), timeout, flags, 0};
session.EmitAndWait(MG_Pipe::MGPWireOp::FenceWaitServer, &request, sizeof(request),
nullptr, 0, nullptr, 0, nullptr);
@@ -1820,9 +1796,7 @@ namespace MobileGL::MG_Remote::Client {
const auto handle = FenceHandle(proxy);
// MobileGL::Destroy stops the server BEFORE DestroyAllSyncObjects. Detach already
// released those native objects on the apply thread; only the local proxy remains.
// A fence of an ended session likewise: its server is gone.
if (auto* session = ClientSession::Active();
session != nullptr && session->Started() && !FenceProxy(proxy).FromEndedSession()) {
if (auto* session = ClientSession::Active(); session != nullptr && session->Started()) {
const MG_Pipe::MGPHandleOnly desc{handle, static_cast<Uint32>(MG_Pipe::MGPipeKind::Fence), 0};
session->EmitAndWait(MG_Pipe::MGPWireOp::FenceDestroy, &desc, sizeof(desc),
nullptr, 0, nullptr, 0, nullptr);
@@ -7,7 +7,6 @@
// End of Source File Header
#include "PersistentMapTracker.h"
#include "ClientSession.h"
#include <MG_Remote/FatalFunnel.h>
#include <MG_Remote/Transport/AdoptTier.h>
@@ -752,10 +751,7 @@ namespace MobileGL::MG_Remote::Client {
// member that was never large-untracked.
m_untrackedMembers.erase(key);
m_edgedMembers.erase(key);
// A buffer mapped on a LOST context (a thread still on one, or a session that is lost)
// never becomes a member: the push before every verb would carry its bytes to whichever
// session is current, and a fresh one never created the buffer.
if (IsLivePersistentMap(buffer) && !ClientSession::DeviceLost()) {
if (IsLivePersistentMap(buffer)) {
const auto range = buffer.GetMappedRange();
// The mprotect arm registers beside the hash arm: tracked buffers are pushed
// from the fault bitmap, everything else keeps the content scan. A failed
@@ -788,21 +784,13 @@ namespace MobileGL::MG_Remote::Client {
UntrackWriteMap(key);
}
void PersistentMapTracker::ForgetEndedSession() {
// Every member is a buffer of the ended session: its bytes have nowhere to go, and a push
// before the next verb would name a handle the fresh server never created. The write
// tracking goes with them (pages unprotected); a member that is unmapped or destroyed
// later finds nothing here, which Forget already tolerates.
void PersistentMapTracker::ClearForTest() {
m_livePersistentMaps.clear();
m_blockHashes.clear();
m_untrackedMembers.clear();
m_edgedMembers.clear();
UntrackAllWriteMaps();
m_lastFaultEpoch = 0;
}
void PersistentMapTracker::ClearForTest() {
ForgetEndedSession();
ResetCountersForTest();
}
@@ -158,8 +158,6 @@ namespace MobileGL::MG_Remote::Client {
// Unit tests only: clears the membership, the hash cache and the mprotect tracked
// slots (restoring every tracked page writable first), and resets the counters.
void ClearForTest();
// A fresh session replaces an ended one: drop every member (ClientSession).
void ForgetEndedSession();
// Unit tests only: the mprotect arm's white-box surface, for the alignment cases
// (SplitBufferTest) that the public GL surface cannot see - which pages a map
// protected is not observable through any push count. MprotectArmAvailableForTest
+2 -16
View File
@@ -1,19 +1,8 @@
// Opaque local proxies carry only {slot, generation, target} across the wire.
// Epoch: the session the query was created on. A query of an ENDED session (a recovered
// device loss) names nothing on the current server: it answers "no result yet", and its
// end and delete put nothing on the wire.
struct RemoteQueryProxy {
MG_Pipe::MGPQueryDesc Desc{};
Uint64 Epoch = MG_State::CurrentWireEpoch();
};
struct RemoteQueryProxy { MG_Pipe::MGPQueryDesc Desc{}; };
std::mutex g_queryProxyMutex;
UnorderedMap<MG_Backend::BackendQueryHandle, UniquePtr<RemoteQueryProxy>> g_queryProxies;
Bool QueryFromEndedSession(MG_Backend::BackendQueryHandle handle) {
const auto found = g_queryProxies.find(handle);
return found != g_queryProxies.end() && found->second->Epoch != MG_State::CurrentWireEpoch();
}
const MG_Pipe::MGPQueryDesc& QueryDesc(MG_Backend::BackendQueryHandle handle) {
const auto found = g_queryProxies.find(handle);
if (found == g_queryProxies.end())
@@ -80,7 +69,6 @@
void EmitEndQuery(MG_Backend::BackendQueryHandle handle) {
auto& session = RequireSession("QueryEnd");
const std::lock_guard<std::mutex> lock(g_queryProxyMutex);
if (QueryFromEndedSession(handle)) return;
const auto& desc = QueryDesc(handle);
BeforeReadOnlyVerb();
session.EmitAndWait(MG_Pipe::MGPWireOp::QueryEnd, &desc, sizeof(desc), nullptr, 0, nullptr, 0, nullptr);
@@ -88,7 +76,6 @@
Bool EmitIsQueryResultAvailable(MG_Backend::BackendQueryHandle handle) {
auto& session = RequireSession("IsQueryResultAvailable");
const std::lock_guard<std::mutex> lock(g_queryProxyMutex);
if (QueryFromEndedSession(handle)) return false;
const MG_Pipe::MGPHandleOnly request{QueryDesc(handle).Query, static_cast<Uint32>(MG_Pipe::MGPipeKind::Query), 0};
const auto result = ReadQueryReply<Uint32>(session, MG_Pipe::MGPWireOp::QueryAvailable, &request, sizeof(request));
if (result > 1) Wire::WireProtocolFatal("QueryAvailable.reply", "availability is not boolean");
@@ -97,7 +84,6 @@
Bool EmitGetQueryResult64(MG_Backend::BackendQueryHandle handle, Bool wait, Uint64* value) {
auto& session = RequireSession("GetQueryResult64");
const std::lock_guard<std::mutex> lock(g_queryProxyMutex);
if (QueryFromEndedSession(handle)) return false;
MG_Pipe::MGPQueryResultRequest request{};
request.Query = QueryDesc(handle).Query;
request.Wait = wait ? 1 : 0;
@@ -112,7 +98,7 @@
void EmitDeleteBackendQuery(MG_Backend::BackendQueryHandle handle) {
const std::lock_guard<std::mutex> lock(g_queryProxyMutex);
const auto query = QueryDesc(handle).Query;
if (auto* session = ClientSession::Active(); session && session->Started() && !QueryFromEndedSession(handle)) {
if (auto* session = ClientSession::Active(); session && session->Started()) {
const MG_Pipe::MGPHandleOnly request{query, static_cast<Uint32>(MG_Pipe::MGPipeKind::Query), 0};
session->EmitAndWait(MG_Pipe::MGPWireOp::QueryDestroy, &request, sizeof(request),
nullptr, 0, nullptr, 0, nullptr);
+6 -24
View File
@@ -1160,13 +1160,10 @@ namespace MobileGL::MG_Remote::Client {
if (g_clientTablesUninstalled.load(std::memory_order_acquire)) return false;
MG_Pipe::MGPBindContext record{};
record.ClientContextToken = clientContextToken;
const Uint64 seq = session->EmitAndWait(MGPWireOp::BindContext, &record, sizeof(record), nullptr, 0,
nullptr, 0, nullptr);
session->EmitAndWait(MGPWireOp::BindContext, &record, sizeof(record), nullptr, 0, nullptr, 0,
nullptr);
++g_emitted;
// A DECLINED binding moved nothing on the server (a lost session, or a thread whose
// context is from an ended one), so the caller must not believe the session is bound to
// it: the next thread that writes re-binds its own context.
return seq != Wire::kInvalidSeq;
return true;
}
Bool EmitApplierResetRecord() {
@@ -1180,28 +1177,13 @@ namespace MobileGL::MG_Remote::Client {
if (session == nullptr || !session->Started()) return false;
if (g_clientTablesUninstalled.load(std::memory_order_acquire)) return false;
MG_Pipe::MGPApplierReset record{};
record.ContextSerial = g_applierResetContextSerial;
const Uint64 seq = session->EmitAndWait(MGPWireOp::ApplierReset, &record, sizeof(record), nullptr, 0,
nullptr, 0, nullptr);
// THE SERIAL COUNTS RESETS THE SERVER WAS SENT, not resets this client primed: a declined
// record (a lost session, a thread on an ended session's context) never reached the
// server's count, and moving ours past it would latch the next session that hears one.
if (seq != Wire::kInvalidSeq) ++g_applierResetContextSerial;
record.ContextSerial = g_applierResetContextSerial++;
session->EmitAndWait(MGPWireOp::ApplierReset, &record, sizeof(record), nullptr, 0, nullptr,
0, nullptr);
++g_emitted;
return true;
}
void ForgetWireTablesOfEndedSession() {
// The ended session's deferred create answers are not coming: their seqs name a ring
// that is gone, and a drain on the new session would wait for them (or read another
// record's answer). The objects behind them are the ended session's too.
g_createWindowHead = 0;
g_createWindowCount = 0;
g_createSuspects.clear();
// A fresh session's server counts applier resets from 0.
g_applierResetContextSerial = 0;
}
// P5c (rv), CONTRACT-P5C.md §5.3. Whether set_context_values can cross RIGHT NOW: a live,
// started session whose tables are not being torn down. PipeFill.cpp gates BOTH halves of
// the row on this - the emission and the residual-fill skip - so a configured-but-wireless
-5
View File
@@ -125,11 +125,6 @@ namespace MobileGL::MG_Remote::Client {
// caller then makes the direct call the record replaced.
Bool EmitApplierResetRecord();
// A fresh session replaces an ended one: the create window's deferred answers, its suspect
// list and the applier-reset serial all belonged to the ended session (ClientSession's
// ForgetEndedSession).
void ForgetWireTablesOfEndedSession();
// ---- P14 S1: the EGL context lifecycle's control-plane half -----------------------------
//
// NOT ring records and NOT routed rows: eglCreateContext/eglDestroyContext are the EGL
-10
View File
@@ -30,18 +30,12 @@ namespace MobileGL::MG_Remote {
// that forks a child and reads it back sees the increment even though the child is gone -
// it reads its OWN process's counter for the funnel it drove, not the child's.
std::atomic<std::uint64_t> g_sessionFaultCount{0};
// SetSessionLatchObserver's; read once per latched session.
std::atomic<SessionLatchObserver> g_sessionLatchObserver{nullptr};
} // namespace
std::uint64_t SessionFaultCount() {
return g_sessionFaultCount.load(std::memory_order_relaxed);
}
void SetSessionLatchObserver(SessionLatchObserver observer) {
g_sessionLatchObserver.store(observer, std::memory_order_release);
}
namespace {
// THE PROJECTION FROM MG_Pipe's TWO-WORD BOUNDARY ENUM ONTO THE .def's VOCABULARY, as a
// switch with a named default rather than a cast. MGPipeFatalFamily is deliberately not
@@ -247,10 +241,6 @@ namespace MobileGL::MG_Remote {
"closes (exit %d) for the supervisor to serve the next connection (PH-1, "
"ID-P7-1)",
FatalFamilyName(family), kSessionLatchedExitCode);
// Before the peer hears of it: what the observer records must already hold when the client
// reacts (a lost compositor re-creates its window surface on a fresh session at once).
if (const SessionLatchObserver observer = g_sessionLatchObserver.load(std::memory_order_acquire))
observer();
PublishSessionFault(family, line);
return false;
}
-8
View File
@@ -140,14 +140,6 @@ namespace MobileGL::MG_Remote {
#endif
SessionLatch(MGFatalFamily family, const char* fmt, ...);
// THE FIRST LATCHED FAULT OF A SESSION, OBSERVED. Called on the latching thread (its latch
// domain bound) once the latch is raised and BEFORE the SessionFault frame goes to the peer, so
// what it records about the session is in place before the client can act on the loss. One
// process-wide observer, replaced by the next install; it must not block. ServerLoop's marks the
// session's lease on the server window as ending (ServerDisplay::MarkLeaseEnding).
using SessionLatchObserver = void (*)();
void SetSessionLatchObserver(SessionLatchObserver observer);
// P7 wave 0. Points MG_Pipe's MGPipeSessionFail seam (MG_Pipe/PipeSessionFail.h) at
// SessionFail, which is what makes the three Magma wire funnels in MG_Backend's renderer
// publish a SessionFault, bump SessionFaultCount() and appear in the census like every other
+1 -54
View File
@@ -1480,20 +1480,6 @@ namespace MobileGL::MG_Remote::Server {
return true;
}
ServerVerbSink::OwnedFd& ServerVerbSink::OwnedFd::operator=(OwnedFd&& other) noexcept {
if (this != &other) Reset(std::exchange(other.fd, -1));
return *this;
}
ServerVerbSink::OwnedFd::~OwnedFd() { Reset(-1); }
void ServerVerbSink::OwnedFd::Reset(int next) {
#if !defined(_WIN32)
if (fd >= 0) ::close(fd);
#endif
fd = next;
}
// P14 S1. THE RING'S DOOR INTO THE SESSION'S CONTEXT TABLE.
//
// The record carries the client's current context token and this is where a session's
@@ -1553,7 +1539,7 @@ namespace MobileGL::MG_Remote::Server {
static_cast<unsigned long long>(seq), why.c_str());
return false;
}
SI::ImageRef image = SI::Identify(fd, why);
SI::ImageRef image = SI::Identify(fd, op.Width, op.Height, op.Format, why);
#if !defined(_WIN32)
::close(fd);
#endif
@@ -1600,45 +1586,6 @@ namespace MobileGL::MG_Remote::Server {
if (backend == nullptr) return false;
return backend->SetCurrentDamageRegion(DamageOfRecord(op.DamageCount, op.Damage));
}
case MG_Pipe::kMGPSharedImageFlush: {
// The answer is posted after the fence is published: the client commits the buffer to
// its compositor only after this returns, so the compositor's session finds the write.
MG_Backend::BackendObject* backend = ServerLoopInstance().Backend();
if (backend == nullptr) return false;
return backend->PublishSharedImageAccesses();
}
case MG_Pipe::kMGPSharedImageNativeFence: {
// A descriptor of the session's work, and an image writer's flush (MGPipeTypes.h). Like
// an Allocate's, the descriptor goes out BEFORE the reply is posted.
MG_Backend::BackendObject* backend = ServerLoopInstance().Backend();
if (backend == nullptr) return false;
int fence = -1;
if (!backend->ExportNativeFence(&fence)) return false;
#if !defined(_WIN32)
if (fence >= 0) {
m_lastNativeFence.Reset(::dup(fence));
} else if (m_lastNativeFence.fd >= 0) {
fence = ::dup(m_lastNativeFence.fd);
}
#endif
reply.Format = 0;
if (fence < 0) return true;
Transport::ITransport* transport = session->ControlTransport();
MG_Pipe::MGPSharedImageFdOffer offer{MG_Pipe::kMGPSharedImageFdMagic, 1, seq, 0, 0};
const MobileGLResult shared = transport != nullptr
? transport->ShareFd(fence, MobileGLByteSpan{&offer, sizeof(offer)})
: MOBILEGL_ERR_NOT_INITIALIZED;
#if !defined(_WIN32)
::close(fence);
#endif
if (shared != MOBILEGL_OK) {
MGLOG_E_ONCE("MG_Remote server: a native fence could not be sent on the aux socket (rc=%d)",
static_cast<int>(shared));
return false;
}
reply.Format = MG_Pipe::kMGPNativeFenceFdFollows;
return true;
}
case MG_Pipe::kMGPSharedImageAttach: {
SI::ImageRef image = holder.Get(op.ImageId);
if (image == nullptr) return false;
-15
View File
@@ -47,7 +47,6 @@
#include "../Wire/PipeWireCodec.h"
#include <deque>
#include <utility>
namespace MobileGL::MG_Remote::Server {
@@ -414,20 +413,6 @@ namespace MobileGL::MG_Remote::Server {
Vector<GLint> m_multiBaseVertices;
LastDrawRecord m_lastDraw{};
Uint64 m_drawRecords = 0;
// The newest native fence (shared_image NativeFence) this session handed out, kept so a
// later fence with nothing left to export still answers with a descriptor: by then this
// one has signaled (the backend waited the work out), and a signaled sync_file stays so.
struct OwnedFd {
int fd = -1;
OwnedFd() = default;
OwnedFd(const OwnedFd&) = delete;
OwnedFd& operator=(const OwnedFd&) = delete;
OwnedFd(OwnedFd&& other) noexcept : fd(std::exchange(other.fd, -1)) {}
OwnedFd& operator=(OwnedFd&& other) noexcept;
~OwnedFd();
void Reset(int next);
};
OwnedFd m_lastNativeFence;
};
class PipeApplier {
+4 -40
View File
@@ -204,8 +204,7 @@ namespace MobileGL::MG_Remote::Server {
{
const std::lock_guard<std::mutex> lock(m_mutex);
if (!m_installed) return ServerWindowAcquire::NoDisplay;
if (m_leaseHolder != nullptr && m_leaseHolder != holder && !m_leaseEnding)
return ServerWindowAcquire::LeasedElsewhere;
if (m_leaseHolder != nullptr && m_leaseHolder != holder) return ServerWindowAcquire::LeasedElsewhere;
hooks = m_hooks;
interrupts = m_interrupts;
previousWidth = m_requestedWidth;
@@ -232,27 +231,14 @@ namespace MobileGL::MG_Remote::Server {
std::unique_lock<std::mutex> lock(m_mutex);
const auto deadline = Clock::now() + std::chrono::milliseconds(timeoutMs);
Bool attachedSeen = false;
Bool waitedForEndingHolder = false;
auto geometryDeadline = deadline;
for (;;) {
if (!m_installed) return ServerWindowAcquire::NoDisplay;
if (m_interrupts != interrupts) return ServerWindowAcquire::Interrupted;
if (cancel != nullptr && cancel(cancelUser)) return ServerWindowAcquire::Cancelled;
// ANOTHER HOLDER: refused at once while its session goes on, waited for while it ends
// (its EndLease wakes this). The window is judged only once the lease is free.
const Bool heldElsewhere = m_leaseHolder != nullptr && m_leaseHolder != holder;
if (heldElsewhere && !m_leaseEnding) return ServerWindowAcquire::LeasedElsewhere;
if (heldElsewhere && !waitedForEndingHolder) {
waitedForEndingHolder = true;
MGLOG_I("MG_Remote server: the server window is still leased by a session that is ending; this "
"session waits for that lease to end (at most %u ms)",
timeoutMs);
}
if (m_leaseHolder != nullptr && m_leaseHolder != holder) return ServerWindowAcquire::LeasedElsewhere;
const auto now = Clock::now();
if (heldElsewhere) {
attachedSeen = false;
geometryDeadline = deadline;
} else if (m_window != nullptr) {
if (m_window != nullptr) {
if (!attachedSeen) {
attachedSeen = true;
geometryDeadline = std::min(deadline, now + std::chrono::milliseconds(kGeometryGraceMs));
@@ -263,7 +249,6 @@ namespace MobileGL::MG_Remote::Server {
m_onLost = onLost;
m_onResized = onResized;
m_lostRequested = false;
m_leaseEnding = false;
// A suspended holder that leased a window again waits for no other.
m_suspended.erase(std::remove_if(m_suspended.begin(), m_suspended.end(),
[holder](const SuspendedHolder& entry) {
@@ -288,18 +273,13 @@ namespace MobileGL::MG_Remote::Server {
"at that size and the client is told so",
m_width, m_height, kGeometryGraceMs);
}
if (waitedForEndingHolder) {
MGLOG_I("MG_Remote server: the ending session's lease ended; the server window is leased to "
"this session");
}
return ServerWindowAcquire::Acquired;
}
} else {
attachedSeen = false;
geometryDeadline = deadline;
}
if (now >= deadline)
return heldElsewhere ? ServerWindowAcquire::LeasedElsewhere : ServerWindowAcquire::NoWindow;
if (now >= deadline) return ServerWindowAcquire::NoWindow;
const auto wake = std::min({deadline, geometryDeadline, now + kCancelPollInterval});
m_cv.wait_until(lock, wake);
}
@@ -311,7 +291,6 @@ namespace MobileGL::MG_Remote::Server {
m_onLost = nullptr;
m_onResized = nullptr;
m_lostRequested = false;
m_leaseEnding = false;
releases->swap(m_releaseAfterLease);
*hooks = m_hooks;
// An Uninstall that ran while this lease still owed releases kept the hooks for them.
@@ -338,16 +317,6 @@ namespace MobileGL::MG_Remote::Server {
ReleaseAfterLease(hooks, releases);
}
void ServerDisplay::MarkLeaseEnding(void* holder) {
{
const std::lock_guard<std::mutex> lock(m_mutex);
if (holder == nullptr || m_leaseHolder != holder || m_leaseEnding) return;
m_leaseEnding = true;
}
// A request already refused is not waiting; one made from here on waits for the EndLease.
m_cv.notify_all();
}
void ServerDisplay::SuspendLease(void* holder, ServerWindowAttachedHook onAttached) {
if (holder == nullptr) return;
std::vector<void*> releases;
@@ -410,11 +379,6 @@ namespace MobileGL::MG_Remote::Server {
return m_leaseHolder != nullptr;
}
Bool ServerDisplay::LeaseEnding() const {
const std::lock_guard<std::mutex> lock(m_mutex);
return m_leaseHolder != nullptr && m_leaseEnding;
}
Uint64 ServerDisplay::Generation() const {
const std::lock_guard<std::mutex> lock(m_mutex);
return m_generation;
+1 -20
View File
@@ -35,14 +35,6 @@
// reference is kept and released when the lease finally ends - and Detach returns TimedOut, by
// name, so the UI thread is never held longer than its bound.
//
// A LEASE THAT IS ENDING IS WAITED FOR, NOT REFUSED. A holder whose session is over - it latched a
// fault (a device loss among them) or is stopping - says so (MarkLeaseEnding) before its client can
// learn of it; its lease still lasts until its backend has let go of the window. A client that loses
// its session re-creates its window surface on a fresh session at once, typically while the old
// session's apply thread is still tearing its backend down: that request waits for the old lease
// to end, bounded by its own timeout, instead of being refused as LeasedElsewhere. A holder whose
// session goes on keeps the window exclusively, as before.
//
// SUSPEND, NOT END (screen off / lock). A holder whose backend can let go of the window and keep
// everything else - its contexts, objects and device - ends its lease with SuspendLease instead of
// EndLease and names a second hook: the next Attach of a NEW window calls it, so the holder can
@@ -104,9 +96,7 @@ namespace MobileGL::MG_Remote::Server {
Interrupted, // Interrupt() (the in-process server is stopping)
// P14 S2: NOT A BUG ANY MORE. Several sessions share one process and the display's window
// is one window, so a second ON-SCREEN session asking for it is refused by name here
// (ServerLoop logs the holder); offscreen sessions take no lease and are unaffected. A holder
// whose session is ending (MarkLeaseEnding) is waited for instead, and this is the answer
// only when its lease outlasted the wait.
// (ServerLoop logs the holder); offscreen sessions take no lease and are unaffected.
LeasedElsewhere, // another session in this process holds the window: see the note above
};
@@ -166,11 +156,6 @@ namespace MobileGL::MG_Remote::Server {
// whole backend). Wakes a waiting Detach; releases a reference Detach left behind on timeout.
// A holder that holds no lease is a no-op.
void EndLease(void* holder);
// `holder`'s session is ending (it latched, or it is stopping): its lease ends once its
// backend has let go of the window, and another holder's AcquireFor waits for that rather
// than being refused (see the header block). A no-op for a holder that holds no lease; the
// mark ends with the lease.
void MarkLeaseEnding(void* holder);
// EndLease for a holder that only SUSPENDED its use of the window (its backend let go of the
// window and kept everything else). Also registers `onAttached`, which the next Attach of a
// new window calls - at once when a window is already attached. The registration ends when
@@ -184,8 +169,6 @@ namespace MobileGL::MG_Remote::Server {
// Diagnostics, for logs and tests.
Bool Attached() const;
Bool Leased() const;
// The lease is held by a holder whose session is ending (MarkLeaseEnding).
Bool LeaseEnding() const;
Uint64 Generation() const;
// How many holders wait for a window to resume on (SuspendLease).
Uint32 SuspendedHolders() const;
@@ -224,8 +207,6 @@ namespace MobileGL::MG_Remote::Server {
ServerWindowLostHook m_onLost = nullptr;
ServerWindowResizedHook m_onResized = nullptr;
Bool m_lostRequested = false;
// The holder's session is ending (MarkLeaseEnding); cleared with the lease.
Bool m_leaseEnding = false;
// References a timed-out Detach could not release yet; EndLease releases them.
std::vector<void*> m_releaseAfterLease;
// SuspendLease's registrations, told about the next new window.
+28 -150
View File
@@ -12,7 +12,6 @@
#include "ApplyThreadPolicy.h"
#include "SessionRuntime.h"
#include <MG_Remote/FatalFunnel.h>
#include <MG_Pipe/PipeSessionFail.h>
#include <MG_Remote/Transport/LinkMetrics.h>
#include <MG_Backend/MGPipe/PipeInputs.h>
@@ -28,9 +27,6 @@
#include <condition_variable>
#include <cstdlib>
#include <cstdio>
#if defined(__ANDROID__)
#include <sys/system_properties.h>
#endif
#include <cstring>
#include <mutex>
#include <optional>
@@ -82,24 +78,6 @@ namespace MobileGL::MG_Remote::Server {
++m_serving;
m_turn.notify_all();
}
// Gives the turn up however deep the calling thread holds it, for a wait that does no
// backend work; answers the depth Resume restores (0: the thread did not hold it).
Uint32 YieldIfHeld() {
const std::lock_guard<std::mutex> lock(m_mutex);
if (m_owner != std::this_thread::get_id()) return 0;
const Uint32 depth = m_depth;
m_depth = 0;
m_owner = std::thread::id{};
++m_serving;
m_turn.notify_all();
return depth;
}
void Resume(Uint32 depth) {
if (depth == 0) return;
Lock();
const std::lock_guard<std::mutex> lock(m_mutex);
m_depth = depth;
}
private:
std::mutex m_mutex;
@@ -124,31 +102,6 @@ namespace MobileGL::MG_Remote::Server {
ScopedBackendTurn& operator=(const ScopedBackendTurn&) = delete;
};
// A WAIT FOR THE SERVER WINDOW HOLDS NO TURN. It can last seconds - a window that is not up
// yet, or the lease of a session that is ending - and the other sessions' apply threads need
// the turn meanwhile: the ending one to tear its backend down, which is what ends its lease.
// Nothing of the backend is touched while it is given up; it is taken back (a handoff, when
// another thread had it) before the waiter goes on.
class ScopedBackendTurnYield {
public:
ScopedBackendTurnYield() : m_depth(BackendTurn().YieldIfHeld()) {}
~ScopedBackendTurnYield() { BackendTurn().Resume(m_depth); }
ScopedBackendTurnYield(const ScopedBackendTurnYield&) = delete;
ScopedBackendTurnYield& operator=(const ScopedBackendTurnYield&) = delete;
private:
const Uint32 m_depth;
};
// The process-wide test seam (ServerLoop.h).
std::atomic<ServerLoop::ServerOwnedSurfaceHook> g_serverOwnedSurfaceHook{nullptr};
// FatalFunnel's latch observer. The latching thread is one of the session's own (its scope
// resolves ServerLoopInstance to that session's loop): a session that latched is over, and
// its lease on the server window, if it holds one, ends once its apply thread has torn the
// backend down - which a fresh session of the same client waits for (MarkLeaseEnding).
void MarkLatchedSessionsLeaseEnding() { ServerDisplayInstance().MarkLeaseEnding(&ServerLoopInstance()); }
// The bounded join. InProcessTransportTest.cpp:344 uses five seconds for the same
// reason: a lost wakeup must be a RED TEST and not a hung CI job.
constexpr Uint32 kJoinTimeoutMs = 5000;
@@ -222,23 +175,6 @@ namespace MobileGL::MG_Remote::Server {
return text != nullptr && text[0] != '\0';
}
// The per-frame P65ServerFrame line is a measurement aid, not a log: at one line per present
// of every session it floods the device log (and pushes the lines tests grep for out of the
// ring). Opt in with MOBILEGL_SERVER_FRAME_STATS=1, or on Android the property
// debug.mobilegl.server_frame_stats=1; read once.
Bool ServerFrameStatsEnabled() {
static const Bool enabled = [] {
const char* value = std::getenv("MOBILEGL_SERVER_FRAME_STATS");
#if defined(__ANDROID__)
char property[PROP_VALUE_MAX] = {};
if (value == nullptr && __system_property_get("debug.mobilegl.server_frame_stats", property) > 0)
value = property;
#endif
return value != nullptr && value[0] != '' && value[0] != '0';
}();
return enabled;
}
void NameThisThread(const char* name) {
#if defined(__linux__) || defined(__ANDROID__)
pthread_setname_np(pthread_self(), name);
@@ -396,10 +332,6 @@ namespace MobileGL::MG_Remote::Server {
return MOBILEGL_OK;
}
void ServerLoop::SetServerOwnedSurfaceHookForTesting(ServerOwnedSurfaceHook hook) {
g_serverOwnedSurfaceHook.store(hook, std::memory_order_release);
}
// ---------------------------------------------------------------------------------
// Start / the loop / Stop
// ---------------------------------------------------------------------------------
@@ -414,8 +346,6 @@ namespace MobileGL::MG_Remote::Server {
return MOBILEGL_ERR_NOT_INITIALIZED;
}
m_session = &session;
// A session that latches marks its window lease as ending before its client hears of it.
SetSessionLatchObserver(&MarkLatchedSessionsLeaseEnding);
m_stopRequested.store(false, std::memory_order_release);
m_abandonQueue.store(false, std::memory_order_release);
// PH-6 fix round: the session's copy of the request, for ReserveEventOrBlock's wait. Lowered
@@ -701,27 +631,8 @@ namespace MobileGL::MG_Remote::Server {
std::optional<ScopedBackendTurn> turn(std::in_place);
PumpControlRequest();
if (stopOrForfeit()) break;
// A SESSION WHOSE OWN GPU WORK HUNG THE GPU APPLIES NOTHING MORE. A shader that never
// ends stops every process's GPU work until the kernel resets it (MG_Backend/
// GpuHangWatch.h), and the same client's next frame usually carries the same shader. The
// backend's verdict - the driver's GUILTY report on Espryt, the hang watch on Magma - is
// asked HERE, before the drain, so that frame is never applied: the session latches
// (DeviceLost, its client reads a lost context) and leaves below. Cheap by contract.
if (m_backend != nullptr && !SessionLatched()) (void)m_backend->LatchIfGpuFaulted();
if (eventRingHasRoom()) DrainRing();
if (stopOrForfeit()) break;
// The session-targeted device-loss debug knob (PipeSessionFail.h): asked here, after a
// drain, so it reaches a client that never presents or reads back, once the session
// has a context bound (it renders); latched as the backends latch a real loss. Unset
// it is one clock read per iteration.
if (!SessionLatched() && session.CurrentContextToken() != 0 &&
MG_Pipe::MGPipeDebugSessionLossDue(session.ClientPid())) {
(void)MG_Pipe::MGPipeSessionLatch(MG_Pipe::MGPipeFatalFamily::DeviceLost,
"MGPipe: Fatal{BackendDeviceLost, \"injected:pid=%u\"} - the debug "
"knob lost this session's device; the session ends and its client "
"reads a lost context, every other session keeps running",
session.ClientPid());
}
if (eventRingHasRoom() && !SessionLatched()) verbs.ReportSignaledFences(/*flush=*/false);
// PH-1 (3): a latched session applies nothing more, so this thread leaves the loop
// (and does not spin on a ring whose head is still ahead of a tail DrainRing will no
@@ -811,11 +722,6 @@ namespace MobileGL::MG_Remote::Server {
// AND AFTER AbandonQueuedRecords (P12 review fix), for the forfeit's reason: the server is
// stopping under a client that may still be streaming, and draining what it keeps queuing
// is the unbounded hold Stop()'s bounded join turns into an abort.
//
// THE SESSION IS ENDING, whatever ended it: its lease on the server window (if it holds one)
// ends below, once the backend is gone, and a fresh session of the same client that asks for
// the window meanwhile waits for that instead of being refused.
ServerDisplayInstance().MarkLeaseEnding(this);
std::optional<ScopedBackendTurn> exitTurn(std::in_place);
const Bool forfeited = session.ReverseChannelForfeited();
const Bool abandoned = m_abandonQueue.load(std::memory_order_acquire);
@@ -1119,25 +1025,23 @@ namespace MobileGL::MG_Remote::Server {
// reader spent WAITING for bytes, and one that is mostly recv calls with
// little read_ms is a reader that is copying.
const auto read = Transport::LinkMetricsTakeReadStats();
if (ServerFrameStatsEnabled()) {
MGLOG_I("P65ServerFrame frame=%llu records=%llu apply_ms=%.1f wall_ms=%.1f "
"outside_ms=%.1f | read: %llu B in %llu recv(%llu reads) "
"recv_ms=%.1f total_ms=%.1f (%.0f%% blocked, %.1f MB/s)",
static_cast<unsigned long long>(++sFrameIndex),
static_cast<unsigned long long>(sFrameRecords), applyMs, wallMs,
wallMs - applyMs,
static_cast<unsigned long long>(read.bytes),
static_cast<unsigned long long>(read.calls),
static_cast<unsigned long long>(read.reads),
static_cast<double>(read.nsInRecv) / 1e6,
static_cast<double>(read.nsTotal) / 1e6,
read.nsTotal ? 100.0 * static_cast<double>(read.nsInRecv) /
static_cast<double>(read.nsTotal)
: 0.0,
read.nsTotal ? static_cast<double>(read.bytes) /
(static_cast<double>(read.nsTotal) / 1e9) / 1e6
: 0.0);
}
MGLOG_I("P65ServerFrame frame=%llu records=%llu apply_ms=%.1f wall_ms=%.1f "
"outside_ms=%.1f | read: %llu B in %llu recv(%llu reads) "
"recv_ms=%.1f total_ms=%.1f (%.0f%% blocked, %.1f MB/s)",
static_cast<unsigned long long>(++sFrameIndex),
static_cast<unsigned long long>(sFrameRecords), applyMs, wallMs,
wallMs - applyMs,
static_cast<unsigned long long>(read.bytes),
static_cast<unsigned long long>(read.calls),
static_cast<unsigned long long>(read.reads),
static_cast<double>(read.nsInRecv) / 1e6,
static_cast<double>(read.nsTotal) / 1e6,
read.nsTotal ? 100.0 * static_cast<double>(read.nsInRecv) /
static_cast<double>(read.nsTotal)
: 0.0,
read.nsTotal ? static_cast<double>(read.bytes) /
(static_cast<double>(read.nsTotal) / 1e9) / 1e6
: 0.0);
sFrameWallStart = now;
sFrameApplyNs = 0;
sFrameRecords = 0;
@@ -1376,9 +1280,6 @@ namespace MobileGL::MG_Remote::Server {
m_running.store(false, std::memory_order_release);
return;
}
// As on the apply thread's own way out: the window lease ends once the thread has torn the
// backend down, and a fresh session waits for it meanwhile.
ServerDisplayInstance().MarkLeaseEnding(this);
m_stopRequested.store(true, std::memory_order_release);
if (m_session != nullptr) {
// PH-6 fix round: the apply thread may be parked in ReserveEventOrBlock rather than in
@@ -1612,16 +1513,12 @@ namespace MobileGL::MG_Remote::Server {
static_cast<Uint32>(frame.width),
static_cast<Uint32>(frame.height));
return MOBILEGL_OK;
case SurfaceControlOp::CreatePbufferSurface: {
// A surfaceless stand-in (kPbufferFlagSurfacelessStandIn) is no rendering path: it is
// admitted whatever the mode and latches none, so a client that binds surfacelessly
// before it creates its server-owned window still gets that window.
const Bool standIn = (frame.contextFlags & kPbufferFlagSurfacelessStandIn) != 0;
case SurfaceControlOp::CreatePbufferSurface:
// P12 (D4): a pbuffer in a session that went on-screen is the other mode, refused by
// name and not latched - the session and its window surface carry on. P14 S2: the mode
// is the session's own - latched by its first surface, on its own loop - and never
// another session's.
if (!standIn && !SessionSurfaceModeAdmits(m_surfaceMode, /*serverOwnedWindow=*/false)) {
if (!SessionSurfaceModeAdmits(m_surfaceMode, /*serverOwnedWindow=*/false)) {
frame.ok = false;
frame.refusal = static_cast<Uint8>(SurfaceRefusalCode::SurfaceModeMismatch);
MGLOG_E("MG_Remote server: SurfaceModeMismatch - CreatePbufferSurface (seq %llu, %dx%d) in a "
@@ -1638,18 +1535,11 @@ namespace MobileGL::MG_Remote::Server {
// make-current that follows is forwarded and deduped one layer down (ID-54).
if (frame.ok) {
ForgetCurrentTuple();
if (standIn) {
MGLOG_I("MG_Remote server: surface=pbuffer %dx%d (surfaceless stand-in; the session's surface "
"mode stays %s)",
frame.width, frame.height, SessionSurfaceModeName(m_surfaceMode));
return MOBILEGL_OK;
}
if (m_surfaceMode == SessionSurfaceMode::None) m_surfaceMode = SessionSurfaceMode::Offscreen;
// P12: THE ARM PROOF (ID-124), once per surface: which of the two paths ran.
MGLOG_I("MG_Remote server: surface=pbuffer %dx%d", frame.width, frame.height);
}
return MOBILEGL_OK;
}
case SurfaceControlOp::MakeCurrent: {
// C7 / ID-54: the apply thread binds the native context ONCE per context lifetime
// and holds it for life. ApplyMakeCurrent forwards a bind only for a tuple it does
@@ -1906,12 +1796,9 @@ namespace MobileGL::MG_Remote::Server {
ServerDisplay& display = ServerDisplayInstance();
ServerWindowLease local;
ServerWindowLease* const lease = out != nullptr ? out : &local;
ServerWindowAcquire acquired = ServerWindowAcquire::NoDisplay;
{
const ScopedBackendTurnYield yield;
acquired = display.AcquireFor(width, height, timeoutMs, this, &ServerWindowLostThunk,
&ServerWindowWaitCancelled, this, lease, &ServerWindowResizedThunk);
}
const ServerWindowAcquire acquired = display.AcquireFor(width, height, timeoutMs, this, &ServerWindowLostThunk,
&ServerWindowWaitCancelled, this, lease,
&ServerWindowResizedThunk);
switch (acquired) {
case ServerWindowAcquire::Acquired:
m_holdsWindowLease = true;
@@ -1991,10 +1878,7 @@ namespace MobileGL::MG_Remote::Server {
// Review fix: the backend is told which window is the server's own, so its surface init
// reports the extent for this window and for no window a client named (MGPipeServerOwnedWindow).
NoteServerWindowExtent(lease.window, lease.width, lease.height);
const ServerOwnedSurfaceHook surfaceHook = g_serverOwnedSurfaceHook.load(std::memory_order_acquire);
const EGLSurface ownedSurface = HandleFromToken<EGLSurface>(frame.surface);
frame.ok = surfaceHook != nullptr ? surfaceHook(backend, ownedSurface, window)
: backend->CreateEGLWindowSurface(ownedSurface, window);
frame.ok = backend->CreateEGLWindowSurface(HandleFromToken<EGLSurface>(frame.surface), window);
if (!frame.ok) {
MGLOG_E("MG_Remote server: the backend could not create a window surface on the server window %p "
"(%ux%u) for ServerOwned seq %llu",
@@ -2176,14 +2060,10 @@ namespace MobileGL::MG_Remote::Server {
// have survived it). Bounded by the geometry grace: the window IS attached - that is what woke
// this - so only its size is waited for.
ServerWindowLease lease;
ServerWindowAcquire acquired = ServerWindowAcquire::NoDisplay;
{
const ScopedBackendTurnYield yield;
acquired = ServerDisplayInstance().AcquireFor(m_serverWindowWantWidth, m_serverWindowWantHeight,
ServerDisplay::kGeometryGraceMs, this, &ServerWindowLostThunk,
&ServerWindowWaitCancelled, this, &lease,
&ServerWindowResizedThunk);
}
const ServerWindowAcquire acquired =
ServerDisplayInstance().AcquireFor(m_serverWindowWantWidth, m_serverWindowWantHeight,
ServerDisplay::kGeometryGraceMs, this, &ServerWindowLostThunk,
&ServerWindowWaitCancelled, this, &lease, &ServerWindowResizedThunk);
if (acquired != ServerWindowAcquire::Acquired) {
// Still registered: the next new window wakes this again.
MGLOG_I("MG_Remote server: a suspended on-screen session did not get the new server window (%s); it "
@@ -2253,14 +2133,12 @@ namespace MobileGL::MG_Remote::Server {
return rc == MOBILEGL_OK && frame.ok;
}
Bool ServerCreateEGLPbufferSurface(EGLSurface surface, EGLint width, EGLint height, SurfaceRefusalCode* refusal,
Uint32 flags) {
Bool ServerCreateEGLPbufferSurface(EGLSurface surface, EGLint width, EGLint height, SurfaceRefusalCode* refusal) {
SurfaceControlFrame frame;
frame.kind = SurfaceControlOp::CreatePbufferSurface;
frame.surface = TokenFromHandle(surface);
frame.width = width;
frame.height = height;
frame.contextFlags = flags;
const MobileGLResult rc = ServerLoopInstance().RunSurfaceControlFrame(frame);
if (refusal != nullptr) *refusal = static_cast<SurfaceRefusalCode>(frame.refusal);
return rc == MOBILEGL_OK && frame.ok;
+2 -12
View File
@@ -449,15 +449,6 @@ namespace MobileGL::MG_Remote::Server {
// suspend, for the window-loss cases). Before Start(); fails when one is already installed.
MobileGLResult InstallBackendForTesting(UniquePtr<MG_Backend::BackendObject> backend);
// PROCESS-WIDE TEST SEAM for a server forked from a test (every session's loop reads it; null -
// the default - is the production path): the backend surface behind a ServerOwned window
// surface. A host has no window a backend can draw into, so a case that serves a stand-in
// window gives the backend a surface of the window's extent another way (a pbuffer). Called on
// the apply thread with the lease held, in place of CreateEGLWindowSurface.
using ServerOwnedSurfaceHook = Bool (*)(MG_Backend::BackendObject* backend, EGLSurface surface,
const MG_Backend::WindowHandle& window);
static void SetServerOwnedSurfaceHookForTesting(ServerOwnedSurfaceHook hook);
private:
RemoteControlSink m_remoteSink = nullptr;
void* m_remoteSinkUser = nullptr;
@@ -711,10 +702,9 @@ namespace MobileGL::MG_Remote::Server {
Bool ServerCreateEGLWindowSurface(EGLSurface surface, const MG_Backend::WindowHandle& handle);
Bool ServerResizeEGLWindowSurface(EGLSurface surface, Uint32 width, Uint32 height);
// P12: `refusal`, when given, receives the server's named refusal (SurfaceModeMismatch for a
// pbuffer in an on-screen session), None otherwise. `flags`: kPbufferFlagSurfacelessStandIn
// for the hidden pbuffer of a surfaceless make-current, which takes no surface mode.
// pbuffer in an on-screen session), None otherwise.
Bool ServerCreateEGLPbufferSurface(EGLSurface surface, EGLint width, EGLint height,
SurfaceRefusalCode* refusal = nullptr, Uint32 flags = 0);
SurfaceRefusalCode* refusal = nullptr);
// P12 (on-screen server window), D1/D2. CreateWindowSurface on the SERVER's window: one frame,
// WindowKind::ServerOwned with nativeToken 0 on the wire, no SetWindowHandle. `width`/`height`
// is the size the client asked for (0/0 = the server window's own size); the reply carries the
@@ -687,7 +687,6 @@ namespace MobileGL::MG_Remote::Server {
m_peer = hello->dialMode() == ::MobileGL::Wire::DialMode::Connect ? ApplyPeer::Connected
: hello->dialMode() == ::MobileGL::Wire::DialMode::Fork ? ApplyPeer::Forked
: ApplyPeer::InProcess;
m_clientPid = hello->pid();
const MobileGLResult compatible = ValidatePeerHandshake(transport, hello->abiMajor(),
hello->abiMinor(), hello->wireFingerprint(), theirStamp, hello->dialMode());
if (compatible != MOBILEGL_OK) return compatible;
@@ -370,9 +370,6 @@ namespace MobileGL::MG_Remote::Server {
// 0 = no context is bound. Every record the session has applied so far belongs to this
// token; a session that never crossed a bind_context has never bound one.
Uint64 CurrentContextToken() const { return m_currentContextToken.load(std::memory_order_acquire); }
// The pid the client's Hello names (its own, in its own pid namespace; 0 before Accept).
// What the session-targeted device-loss debug knob matches.
Uint32 ClientPid() const { return m_clientPid; }
Bool HasContext(Uint64 token) const { return m_contexts.find(token) != m_contexts.end(); }
Uint64 ContextCount() const { return static_cast<Uint64>(m_contexts.size()); }
Uint64 ContextsCreated() const { return m_contextsCreated; }
@@ -421,7 +418,6 @@ namespace MobileGL::MG_Remote::Server {
// P11 B2 (T0). Set by Accept from the Hello, by SettleAdoptT0AtBind on the apply thread;
// the inbox and the counters are the apply thread's.
Bool m_adoptT0Asked = false;
Uint32 m_clientPid = 0;
Bool m_adoptT0Quiet = false;
Uint8 m_adoptAsk = 2;
Bool m_adoptT0Settled = false;
@@ -15,6 +15,7 @@
#include <cstdio>
#include <cstring>
#include <map>
#include <set>
#include <utility>
#if defined(__ANDROID__)
@@ -43,6 +44,9 @@ namespace MobileGL::MG_Remote::Server::SharedImages {
std::atomic<Uint64> nextId{1};
UnorderedMap<Uint64, std::weak_ptr<const Image>> byId;
std::map<std::pair<Uint64, Uint64>, std::weak_ptr<const Image>> byIdentity;
// Images an ambiguous-identity import has already named, so the next one takes the
// next image the server exported under that identity instead of naming this one twice.
std::set<Uint64> claimedByIdentity;
// Set once two live images were seen with one identity: the kernel shares an inode
// between dma-bufs, so a descriptor can no longer say which image it is.
Bool identityAmbiguous = false;
@@ -226,7 +230,8 @@ namespace MobileGL::MG_Remote::Server::SharedImages {
if (!reg.identityAmbiguous) {
MGLOG_E("MG_Remote server: two live shared images have one dma-buf identity (dev %llu ino %llu); "
"this kernel does not keep dma-buf inodes unique, so a returned descriptor cannot name its "
"image and every shared-image import is refused from here on",
"image. Imports degrade to naming it by extent and format over the images exported under "
"that identity, in allocation order (SharedImages::Identify)",
static_cast<unsigned long long>(key.first), static_cast<unsigned long long>(key.second));
}
reg.identityAmbiguous = true;
@@ -235,9 +240,9 @@ namespace MobileGL::MG_Remote::Server::SharedImages {
return image;
}
ImageRef Identify(int fd, std::string& why) {
ImageRef Identify(int fd, Uint32 width, Uint32 height, Uint32 fourcc, std::string& why) {
#if defined(_WIN32)
(void)fd;
(void)fd, (void)width, (void)height, (void)fourcc;
why = "shared images need POSIX descriptors";
return nullptr;
#else
@@ -248,9 +253,28 @@ namespace MobileGL::MG_Remote::Server::SharedImages {
}
Registry& reg = Reg();
const std::lock_guard<std::mutex> lock(reg.mutex);
// A KERNEL THAT DOES NOT NAME ITS BUFFERS. Every descriptor of every image reports one
// identity here, so the descriptor cannot say which image it is; the import's own extent
// and format do, over the images exported under that identity, oldest first and each
// claimed once - the order the producer allocated and hands them over in.
if (reg.identityAmbiguous) {
why = "dma-buf identities are not unique on this kernel";
return nullptr;
ImageRef chosen;
for (const auto& [id, weak] : reg.byId) {
const ImageRef image = weak.lock();
if (image == nullptr || image->IdentityDev != dev || image->IdentityIno != ino) continue;
if (image->Width != width || image->Height != height || image->Fourcc != fourcc) continue;
if (reg.claimedByIdentity.count(image->Id) != 0) continue;
if (chosen == nullptr || image->Id < chosen->Id) chosen = image;
}
if (chosen == nullptr) {
why = Format("no unclaimed live image of this extent and format was exported under the "
"only identity this kernel reports for descriptors (%llux%llu fourcc %llx)",
static_cast<long long>(width) | (static_cast<long long>(height) << 32),
static_cast<long long>(fourcc), 0);
return nullptr;
}
reg.claimedByIdentity.insert(chosen->Id);
return chosen;
}
const auto it = reg.byIdentity.find(std::make_pair(dev, ino));
ImageRef image = it != reg.byIdentity.end() ? it->second.lock() : nullptr;
@@ -394,15 +418,6 @@ namespace MobileGL::MG_Remote::Server::SharedImages {
m_images.clear();
}
void ReadTracker::PublishFrameAsWrite(int fence) {
for (const auto& [id, image] : m_images) {
PublishWrite(*image, Dup(fence));
PublishRead(*image, Dup(fence));
}
CloseFd(fence);
m_images.clear();
}
void SessionHolder::Hold(const ImageRef& image) {
if (image == nullptr) return;
const std::lock_guard<std::mutex> lock(m_mutex);
@@ -87,9 +87,19 @@ namespace MobileGL::MG_Remote::Server::SharedImages {
// A new image of `width` x `height` `fourcc`, registered. Null with `why` on failure.
ImageRef Allocate(Uint32 width, Uint32 height, Uint32 fourcc, std::string& why);
// The live image `fd` was exported from, or null (`why` says which test failed): a descriptor
// this server never exported, or one whose identity the kernel does not keep unique.
ImageRef Identify(int fd, std::string& why);
// The live image the descriptor was exported from, or null (why says which test failed): a
// descriptor this server never exported, or one no live image matches.
//
// WHICH IDENTITY A DESCRIPTOR CARRIES IS THE KERNEL'S TO SAY. (st_dev, st_ino) is the
// honest answer, and the only one on kernels that give every dma-buf its own inode. Some
// do not: there, every descriptor reports one identity (measured on a 4.14 vendor kernel:
// dev 12, ino 10658, st_size 0, and /proc/self/fdinfo carries nothing else either), so the
// descriptor cannot name its image. The import then names it by what it DOES carry - the
// extent and the format it declares - and the images the server exported under that
// identity are taken in allocation order, each claimable once, which is the order the
// producer hands them over. A kernel whose descriptors are ambiguous degrades to that,
// and says so once.
ImageRef Identify(int fd, Uint32 width, Uint32 height, Uint32 fourcc, std::string& why);
// The live image with this id, or null.
ImageRef Find(Uint64 id);
@@ -134,12 +144,6 @@ namespace MobileGL::MG_Remote::Server::SharedImages {
void NoteRead(const ImageRef& image);
// Takes ownership of `fence` (a sync_file for the frame, -1 if it has completed).
void PublishFrame(int fence);
// IMPLICIT SYNC BY FLUSH: a session that renders into images as well as sampling them, with
// no swap and no explicit write (an X server's glamor) ends its frame at glFlush. Every image
// it used since its last boundary gets `fence` both as a write - the generation moves, so the
// next reader waits for it - and as a read, so the next writer waits for it too. Takes
// ownership of `fence` (-1: the work has completed; the generation still moves).
void PublishFrameAsWrite(int fence);
SizeT Pending() const { return m_images.size(); }
private:
@@ -668,29 +668,6 @@ namespace MobileGL::MG_Remote::Server {
site, static_cast<Uint32>(uploadTarget), static_cast<Uint32>(level));
}
// A box of a level for a replay into storage that is not this store's - a shared image,
// whose level was defined with no data and is written in pieces (an X server uploading a
// client's pixels into a window pixmap). The level image and its row length in texels when
// every row of the box is covered; null otherwise. Unlike RequireLevelBytes a partially
// covered level answers, and nothing is fatal: an uncovered box is the caller's to skip.
const Uint8* CoveredBoxBytes(Uint64 key, Uint16 uploadTarget, Uint16 level, Int x, Int y, Uint32 w, Uint32 h,
SizeT texel, Int* rowTexels) const {
if (!m_copies) return nullptr;
const std::lock_guard<std::mutex> lock(m_mutex);
const LevelShadow* shadow = FindLevel(key, uploadTarget, level);
if (shadow == nullptr || !shadow->Defined || x < 0 || y < 0 || w == 0 || h == 0 ||
x + static_cast<Int>(w) > shadow->Extent.x() || y + static_cast<Int>(h) > shadow->Extent.y())
return nullptr;
for (Uint32 row = 0; row < h; ++row) {
const SizeT begin = TexelOffset(shadow->Extent, x, y + static_cast<Int>(row), 0, texel);
const SizeT end = begin + static_cast<SizeT>(w) * texel;
if (end > shadow->Bytes.size() || !StagedShadowStore::CoverageHas(shadow->Covered, begin, end))
return nullptr;
}
*rowTexels = shadow->Extent.x();
return shadow->Bytes.data();
}
// Diagnostics the sync path and the unit cases read, so that a check can assert WHAT
// HAPPENED rather than that nothing blew up.
Bool IsCovered(Uint64 key, Uint16 uploadTarget, Uint16 level) const {
@@ -99,15 +99,6 @@ namespace MobileGL::MG_Remote::Server {
// substitutes its own window there; no pointer crosses the wire (Rule G/H).
inline constexpr Int kServerOwnedWindowBackend = 0x10000;
// CreatePbufferSurface's flags, in the frame's `contextFlags` word (the wire's SurfaceOp
// contextFlags, 0 on every op but CreateContext before this, so an older server reads none).
// SURFACELESS STAND-IN: the hidden 1x1 pbuffer a client binds the backend to for a surfaceless
// make-current (EGL_KHR_surfaceless_context). It is never presented or read back, so it is no
// rendering path: it neither latches the session's surface mode nor is refused by it (D4).
// Without it, a client that made a context current with no surface before it created its
// server-owned window latched its session offscreen, and the window was refused.
inline constexpr Uint32 kPbufferFlagSurfacelessStandIn = 1u;
// P12. Why the server declined a surface op, carried back in the reply half (`refusal`). The
// values ARE the wire's SurfaceRefusal (protocol.fbs); SurfaceOpCodec pins the agreement with
// static_asserts, the way it pins SurfaceControlOp against SurfaceOpKind. None of them latches
@@ -142,8 +133,7 @@ namespace MobileGL::MG_Remote::Server {
Int swapInterval = 0;
// P14 S1. CreateContext's two values beyond `context` (which is the client context token
// itself): the share group the context was derived into, and the reserved flags word the
// schema carries so a later attribute has a slot. CreatePbufferSurface carries its own
// flags in the same word (kPbufferFlagSurfacelessStandIn). 0 on every other op.
// schema carries so a later attribute has a slot. 0 on every other op.
Uint64 shareGroupToken = 0;
Uint32 contextFlags = 0;
// The reply half: written by the dispatch on the apply thread, read by the poster after

Some files were not shown because too many files have changed in this diff Show More