Skip to content

LordOS — a free, fast and secure GNU/Linux distribution based on Debian, with its own desktop environment: display server and Wayland compositor in C, a React UI engine on QuickJS, and private native apps.

The desktop under load: lord-sessiond gives the compositor's cgroup cpu.weight 1000 (apps and helpers 100; nice values don't count between cgroups) and the compositor's main and paint threads ask for a 0.5 ms EEVDF slice (reset on fork); LordBench's desktop test under load on a Pi 5 without monitor 61 % -> 23 % late frames, 34.6 -> 47.6 fps; docs, CHANGELOG and paper (en/es/pt)

Federico Pereira3e7b30c37d70
diff --git a/CHANGELOG.md b/CHANGELOG.md
index aa01ffb..8fc7499 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -82,7 +82,8 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
HEVC 4K 57 fps; H.264 encoder 75 fps. Quick takes 34 s, Full 339 s.
- **Desktop impact measured** on the Pi 5 with a 1920×1080 60 Hz monitor and GPU composition: alone 59.4 fps, frame
build 10.9 ms median and 13.0 ms p99, 1.0 % late; under the low-priority all-core load 24.0 fps, 20.1/29.3 ms,
- 96.5 % late. A stability problem found by LordBench, to be investigated. On VM 116 (headless, with a remote viewer)
+ 96.5 % late. A stability problem found by LordBench; its cause and a first fix are under Fixed ("The desktop
+ under load"). On VM 116 (headless, with a remote viewer)
59.6 fps alone, p99 13.3 ms; p99 22.9 ms and 12.5 % late under load.
- **Boot measured:** the Pi 5 reaches the login screen on its monitor 5.99 s after the kernel starts (systemd: 2.1 s
kernel + 4.2 s userspace).
@@ -103,6 +104,20 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
### Fixed
+- **The desktop under load** (found by LordBench's desktop test; `docs/BENCHMARK.md`, "The desktop under load"): the
+ compositor's cgroup (`server`) had the same `cpu.weight` as every app scope, and nice values don't count between
+ cgroups, so an app keeping every core busy took half of the compositor's CPU even at nice 19. On a Raspberry Pi 5
+ the compositor's main thread waited 299 ms per second for a CPU under load (17 ms alone). Now:
+ - lord-sessiond gives the session's `server` leaf `cpu.weight` 1000 (apps and helpers keep 100), in the root-owned
+ subtree it already manages (`CG_SERVER_CPU_WEIGHT`, `sec/cgroup.c`);
+ - the compositor's main thread and paint threads ask for a 0.5 ms time slice (`par_short_slice`, `par.c`; EEVDF's
+ custom slice, Linux 6.12+, unprivileged, not inherited by what they start).
+
+ LordBench's desktop test under load, without a monitor: on the Pi 5 34.6 → 47.6 frames per second, p50 20.7 →
+ 14.0 ms, late frames 61 % → 23 %; on VM 116 8.6–17.5 % → 4.5–6.9 % late. Nothing changes without load. Checked on
+ VM 116 that a new session gets the weight and that only those threads get the slice. Not yet measured with the
+ Pi's monitor and GPU composition. What remains (the Pi kernel's 4 ms scheduler tick, a real-time priority for
+ the compositor) is described there and not built.
- **LordBench on the Raspberry Pi 5 measured no GPU:** inside `lord-bench`'s sandbox Mesa's loader could not identify
the V3D render node ("failed to retrieve device information") and every GPU measurement was skipped. The sandbox
now also allows reading `/sys/firmware/devicetree` and `/dev/dri` (read-only; the GPU is still reached only
diff --git a/docs/BENCHMARK.md b/docs/BENCHMARK.md
index e5c2cbe..4be71ac 100644
--- a/docs/BENCHMARK.md
+++ b/docs/BENCHMARK.md
@@ -325,12 +325,56 @@ Desktop impact:
| | under load | 24.0 fps | 20.1 ms | 29.3 ms | 96.5 % |
On the Pi the desktop stays at the refresh rate alone, but under an all-core load at the lowest priority (which
-still got 5.0 GFLOP/s done) it falls to 24 frames per second: a stability problem LordBench found, to be
-investigated (the time to build a frame is already 11 ms of the 16.7 ms budget at rest, and the load competes for
-the cores and the memory bandwidth the compositor's paint threads use). The first scene moved its window from JS
+still got 5.0 GFLOP/s done) it fell to 24 frames per second: a stability problem LordBench found, investigated
+below ("The desktop under load"). The first scene moved its window from JS
(`wm.move` every frame) and measured React instead of the compositor (12.8 fps on VM 116); it was replaced by the
drag's own path in C before these numbers.
+#### The desktop under load (2026-10-28)
+
+**Cause.** lord-sessiond puts the compositor in the session's `server` cgroup and every app and helper in a
+scope next to it (`lordos-bench.scope` for LordBench's load). A process's nice value only counts against
+processes in the same cgroup; between cgroups the kernel shares the CPU by `cpu.weight`, and every one of them had
+the default, 100. So the load's nice 19 did nothing against the compositor, and any app keeping every core busy
+would do the same. Measured from `/proc/<pid>/task/*/schedstat` during the test (Pi 5, the session without its
+monitor, CPU composition): the compositor's main thread waited for a CPU 17 ms per second alone and **299 ms per
+second** under the load (1.05 ms each time it woke up), and its three paint threads waited longer than they ran.
+
+**Changes.**
+
+- lord-sessiond gives the `server` leaf `cpu.weight` 1000 when it creates a session (`CG_SERVER_CPU_WEIGHT`,
+ `sec/cgroup.c`); app scopes and helpers keep 100. Root writes it in the root-owned subtree it already manages; no
+ new request or interface.
+- The compositor's main thread and its paint threads ask for a 0.5 ms time slice (`par_short_slice`, `par.c`:
+ `sched_setattr` with EEVDF's custom slice, Linux 6.12+, unprivileged, ignored by older kernels), so they get the
+ CPU back sooner when they wake up beside busy threads. `SCHED_FLAG_RESET_ON_FORK`: checked on both kernels that
+ the processes and threads they start get the default slice again.
+
+**Measured**, LordBench's desktop test under load, the same structure as a real session (the compositor and the
+load in sibling cgroups; on the Pi with user scopes, since the installed session can't be changed without root):
+
+| Machine | Compositor | Frames shown | Build p50 | Build p99 | Late |
+|---|---|---|---|---|---|
+| Pi 5, no monitor (CPU composition) | before (weight 100) | 34.6 fps | 20.7 ms | 40.8 ms | 61 % |
+| | weight 1000 | 42.2 fps | 16.5 ms | 34.3 ms | 35 % |
+| | weight 1000 and 0.5 ms slice | 47.6 fps | 14.0 ms | 31.4 ms | 23–24 % |
+| VM 116 (8 vCPU) | before | 52–58 fps | 6.6–13.0 ms | 16.6–24.6 ms | 8.6–17.5 % |
+| | weight 1000 and 0.5 ms slice | 58.9–59.5 fps | 6.2–6.3 ms | 15.5–17.8 ms | 4.5–6.9 % |
+
+The load still got its work done (3.0–3.7 GFLOP/s on the Pi in every row). Without load nothing changes (59–60 fps).
+A weight of 10000 or a 0.1 ms slice did not do better than 1000 and 0.5 ms. Also tried and dropped: turning the
+paint threads off when the frame waits for them under load (its own measurement showed the threads still saved
+time, so it never acted). On VM 116 a session started by the new lord-sessiond has `cpu.weight` 1000 on `server`
+and the 0.5 ms slice on the main thread and its 7 paint threads only. **Not yet measured with the monitor and GPU
+composition on the Pi**, where the 24 fps above came from; that needs the new package installed.
+
+**What remains.** Under load the main thread still waits about 0.9 ms each time it wakes up, whatever the weight:
+when a thread of the load gets a CPU it keeps it until the next scheduler tick, which is 4 ms on the LordOS Pi kernel
+(`CONFIG_HZ=250`), and the shared memory makes each frame about 20 % slower to build. Two further steps, not built:
+the Pi kernel at `CONFIG_HZ=1000` (`tools/rpi/build-kernel.sh`, a rebuild), and a real-time priority for the
+compositor's main thread (`SCHED_RR`, as other desktops do through rtkit) granted by lord-sessiond with a CPU-time
+limit, which is a new privilege and needs the maintainer's approval first.
+
Boot: the Pi 5 reaches the login screen on its monitor 5.99 s after the kernel starts (lord-sessiond's record;
systemd-analyze gives 2.1 s kernel + 4.2 s userspace). Boots where the monitor was connected late took 61 and
103 s, which is the wait for the monitor, not the boot. The N-boot test was checked by its unit tests
diff --git a/docs/PAPER-VALIDATION.md b/docs/PAPER-VALIDATION.md
index f315817..cab9412 100644
--- a/docs/PAPER-VALIDATION.md
+++ b/docs/PAPER-VALIDATION.md
@@ -106,7 +106,7 @@ memory from a process's RSS (§7.1) and points to versioned results (§11.5, `do
| 7.2 | — | New in 0.8.5: remote desktop CPU reference (`REMOTE.md`, "Measurements (0.8.5, CPU reference)") | Added in the 0.8.5 edition (§7.2) |
| 7.3 | GPU benefits on real cards not measured | — | **Untested** |
| 7.4 | Pi 5: build 1 min 02 s, tests 23/0/0, NEON 2.0–2.3×, idle 36 MB, fan behaviour | Measured once on the Pi | Measured |
-| 7.4 | — | New, 0.8.6 in development: with a 1920×1080 60 Hz monitor, login screen 5.99 s after the kernel starts; desktop 59.4 fps alone (p99 13.0 ms, 1 % late) and 24 fps under a low-priority all-core load (96.5 % late); 3 minutes sustained at 5.9 GFLOP/s, 55.6 °C; software video decoding per codec. LordBench on the Pi (`BENCHMARK.md`, "Built so far") | Measured with LordBench (one run each); the load result is an open problem |
+| 7.4 | — | New, 0.8.6 in development: with a 1920×1080 60 Hz monitor, login screen 5.99 s after the kernel starts; desktop 59.4 fps alone (p99 13.0 ms, 1 % late) and 24 fps under a low-priority all-core load (96.5 % late); 3 minutes sustained at 5.9 GFLOP/s, 55.6 °C; software video decoding per codec. LordBench on the Pi (`BENCHMARK.md`, "Built so far") | Measured with LordBench (one run each); the load result led to a fix (compositor CPU weight and slice, 61 % → 23 % late without the monitor), to re-measure on the monitor |
| 7.5 | No measurements on real PCs | — | **Untested** |
## §10–§11 Limits and verification
diff --git a/docs/PRIVACY.md b/docs/PRIVACY.md
index cc368e9..e527ea7 100644
--- a/docs/PRIVACY.md
+++ b/docs/PRIVACY.md
@@ -670,7 +670,9 @@ Now the subtree stays **root-owned** and the scopes are created by root:
- `cgroup_delegate_session()` (`server/src/sec/cgroup.c`) creates `lordos-session-<uid>/server`
and moves the session's `lord-server` there, but no longer chowns anything to the user
- (`cgroup_harden_session`). At startup, `cgroup_service_init()` hardens the subtrees left by an
+ (`cgroup_harden_session`). Since 0.8.6 (in development) it also gives `server` `cpu.weight` 1000
+ against 100 for every scope, so a busy app can't take half of the compositor's CPU (nice values
+ don't count between cgroups; `BENCHMARK.md`, "The desktop under load"). At startup, `cgroup_service_init()` hardens the subtrees left by an
older `lord-sessiond` (sessions survive a restart).
- `lord-sessiond` forks a small root child (`server/src/remote/cgsup.c`) that listens on
`/run/lordos/cgroup.sock` (`SOCK_SEQPACKET`, mode 0666; `SO_PEERCRED` decides). It serves one
diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md
index a3b8bed..e997413 100644
--- a/docs/ROADMAP.md
+++ b/docs/ROADMAP.md
@@ -709,7 +709,8 @@ the maintainer on 2026-10-27, item below).
(`BENCHMARK.md`, "Built so far"), and so are the video workloads (software decoding, the remote desktop's
encoders), the desktop-impact mode (the compositor's frame times alone and under a low-priority load), the N-boot
test and the Pi 5 reference. Left: input latency, hardware video decoding, the x86 PC reference,
- `lordos-sysreport bench`, and fixing what it found on the Pi 5 (the desktop falls to 24 fps under load).
+ `lordos-sysreport bench`, and the rest of what it found on the Pi 5 (the desktop fell to 24 fps under load; a first
+ fix, the compositor's CPU weight and time slice, is built, `BENCHMARK.md` "The desktop under load").
- [ ] **Community hardware reports (0.8.7)** — `BENCHMARK.md`. Share on GitHub with the
`hardware-report` template (the user submits it, LordOS sends nothing), schema validation and
labels in a workflow, and a tested-hardware catalogue on lordos.org that the Compatibility panel
diff --git a/server/src/par.c b/server/src/par.c
index 2f4b74a..be0ded9 100644
--- a/server/src/par.c
+++ b/server/src/par.c
@@ -7,6 +7,9 @@
#include <pthread.h>
#include <sched.h>
#include <stdatomic.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/syscall.h>
#include <unistd.h>
#define PAR_MAX 8
@@ -40,6 +43,7 @@ static void run_pieces(void) {
static void *worker(void *arg) {
(void)arg;
+ par_short_slice();
unsigned long seen = 0;
for (;;) {
pthread_mutex_lock(&mu);
@@ -58,6 +62,7 @@ void par_init(int threads) {
threads = !sched_getaffinity(0, sizeof set, &set) ? CPU_COUNT(&set) : (int)sysconf(_SC_NPROCESSORS_ONLN);
}
if (threads > PAR_MAX) threads = PAR_MAX;
+ par_short_slice(); /* the caller: the compositor's main thread */
for (int i = 1; i < threads; i++) {
pthread_t t;
pthread_attr_t at;
@@ -94,3 +99,20 @@ void par_rows(int j0, int j1, ParFn fn, void *ctx) {
pthread_mutex_unlock(&mu);
atomic_flag_clear(&busy);
}
+
+/* struct sched_attr (linux/sched/types.h), declared here: glibc has no wrapper before 2.41 */
+struct par_sched_attr { uint32_t size, policy; uint64_t flags; int32_t nice; uint32_t priority;
+ uint64_t runtime, deadline, period; uint32_t util_min, util_max; };
+
+void par_short_slice(void) {
+#ifdef SYS_sched_setattr
+ struct par_sched_attr a;
+ memset(&a, 0, sizeof a);
+ a.size = sizeof a;
+ a.policy = SCHED_OTHER;
+ a.flags = 0x01; /* SCHED_FLAG_RESET_ON_FORK: children start with the default */
+ a.nice = (int32_t)nice(0); /* keep this thread's nice value */
+ a.runtime = 500000; /* ns; the kernel allows 0.1–100 ms */
+ syscall(SYS_sched_setattr, 0, &a, 0);
+#endif
+}
diff --git a/server/src/par.h b/server/src/par.h
index 947871e..ad199c5 100644
--- a/server/src/par.h
+++ b/server/src/par.h
@@ -14,4 +14,9 @@ void par_init(int threads); /* 0: the CPUs this process may use, at most
int par_threads(void); /* threads that take pieces, the caller included (1: serial) */
void par_rows(int j0, int j1, ParFn fn, void *ctx);
+/* Asks the kernel for a short time slice (0.5 ms, EEVDF's custom slice, Linux 6.12+) for the calling
+ * thread, so it gets the CPU back sooner when it wakes up beside busy threads; not inherited by children
+ * (SCHED_FLAG_RESET_ON_FORK). Best effort: older kernels ignore it. Used by the compositor's threads. */
+void par_short_slice(void);
+
#endif
diff --git a/server/src/sec/cgroup.c b/server/src/sec/cgroup.c
index 3af8a56..55060bb 100644
--- a/server/src/sec/cgroup.c
+++ b/server/src/sec/cgroup.c
@@ -282,6 +282,11 @@ int cgroup_delegate_session(unsigned uid, unsigned gid) {
if (sfd < 0) return -1;
if (mkdirat(sfd, "server", 0755) && errno != EEXIST) { close(sfd); return -1; }
int lfd = openat(sfd, "server", O_DIRECTORY | O_CLOEXEC);
+ /* The compositor weighs ten times an app scope or helper: with the default weight, an app keeping
+ * every core busy took half of the compositor's CPU whatever its nice value (nice only counts inside
+ * one cgroup), and a Raspberry Pi 5's desktop fell from 59 to 24 frames a second
+ * (docs/BENCHMARK.md, "The desktop under load"). Best effort: without the cpu controller it stays. */
+ if (lfd >= 0) write_at(lfd, "cpu.weight", CG_SERVER_CPU_WEIGHT);
if (lfd < 0 || write_at(lfd, "cgroup.procs", "0")) { fprintf(stderr, "cgroup: could not move session %u to its leaf: %s\n", uid, strerror(errno)); if (lfd >= 0) close(lfd); close(sfd); return -1; }
/* The subtree stays root-owned (it used to be chowned to the user). lord-sessiond creates the
* app scopes on request (cgroup_place_serve) with a root-owned cgroup.procs, so no user
diff --git a/server/src/sec/cgroup.h b/server/src/sec/cgroup.h
index cf5022c..0b1c4a9 100644
--- a/server/src/sec/cgroup.h
+++ b/server/src/sec/cgroup.h
@@ -37,6 +37,9 @@ const char *cgroup_self(void);
* lord-sessiond on request (cgroup_place_serve). Best effort: without delegation (Delegate=yes in
* lordos.service) it warns and goes on. Returns 0 on success. See docs/SESSIONS.md. */
int cgroup_delegate_session(unsigned uid, unsigned gid);
+/* cpu.weight of the session's «server» leaf (the compositor), against 100 for each app scope and helper */
+#define CG_SERVER_CPU_WEIGHT "1000"
+
/* Called by lord-sessiond at startup (root, lordos.service with Delegate=yes): moves itself to the
* "supervisor" leaf so the service root can enable memory/CPU/pids for the
diff --git a/web/content/paper/paper.en.md b/web/content/paper/paper.en.md
index 584ed5c..ee39f29 100644
--- a/web/content/paper/paper.en.md
+++ b/web/content/paper/paper.en.md
@@ -484,7 +484,7 @@ The Raspberry Pi 5 is the only supported board. Results on a real board (16 GB,
**Fans.** On the Pi 5 in a test case, `lord-fand` kept the fan off at 50–53 °C during a 4-thread load (the aluminium case acts as a heatsink), drove it to 55 % (4,500 RPM) and full speed (7,400 RPM) with test curves, and restored the kernel's own settings after `SIGTERM` and `kill -9` (`docs/FANS.md`).
-**Monitor and image.** Since 0.8.4.1 the Raspberry Pi 5 image shows the desktop on an HDMI monitor at the first boot (the display driver line in `config.txt` now comes after the firmware's auto-detection lines, and LordOS waits up to 30 s for the driver), sets the clock from the network, and ships Chromium and Firefox ESR. Since 0.8.4 the LordOS Pi kernel (`6.18.57-lordos.3-rpi-2712`) also destroys the connections of a blocked app. **Measured on a monitor (LordBench, 0.8.6 in development):** the 0.8.5 image booted with a 1920×1080 60 Hz monitor on either HDMI port reaches the login screen 5.99 s after the kernel starts (systemd: 2.1 s kernel, 4.2 s userspace). With GPU composition (V3D) a window moved by the compositor keeps 59.4 frames per second, with a frame built in 10.9 ms (median) and 13.0 ms (99th percentile) and 1.0 % of frames late; under an all-core load at the lowest priority it falls to 24 frames per second with 96.5 % late, a problem LordBench found that is still to be fixed. In a 3-minute all-core load with the fan the board kept 5.9 GFLOP/s at 55.6 °C at most, and it decodes 1080p video in software at 258 (H.264), 246 (HEVC), 204 (VP9) and 159 (AV1) frames per second.
+**Monitor and image.** Since 0.8.4.1 the Raspberry Pi 5 image shows the desktop on an HDMI monitor at the first boot (the display driver line in `config.txt` now comes after the firmware's auto-detection lines, and LordOS waits up to 30 s for the driver), sets the clock from the network, and ships Chromium and Firefox ESR. Since 0.8.4 the LordOS Pi kernel (`6.18.57-lordos.3-rpi-2712`) also destroys the connections of a blocked app. **Measured on a monitor (LordBench, 0.8.6 in development):** the 0.8.5 image booted with a 1920×1080 60 Hz monitor on either HDMI port reaches the login screen 5.99 s after the kernel starts (systemd: 2.1 s kernel, 4.2 s userspace). With GPU composition (V3D) a window moved by the compositor keeps 59.4 frames per second, with a frame built in 10.9 ms (median) and 13.0 ms (99th percentile) and 1.0 % of frames late; under an all-core load at the lowest priority it falls to 24 frames per second with 96.5 % late, a problem LordBench found: the compositor's cgroup weighed the same as the load's, so the load's low priority did not count. Giving the compositor ten times the CPU weight of an app and a shorter time slice raised the same test, run without the monitor, from 35 to 48 frames per second (61 % → 23 % late); the measurement with the monitor is pending. In a 3-minute all-core load with the fan the board kept 5.9 GFLOP/s at 55.6 °C at most, and it decodes 1080p video in software at 258 (H.264), 246 (HEVC), 204 (VP9) and 159 (AV1) frames per second.
### 7.5 Modern PCs
diff --git a/web/content/paper/paper.es.md b/web/content/paper/paper.es.md
index 50b0396..96d4f5b 100644
--- a/web/content/paper/paper.es.md
+++ b/web/content/paper/paper.es.md
@@ -484,7 +484,7 @@ La Raspberry Pi 5 es la única placa soportada. Resultados en una placa real (16
**Ventiladores.** En la Pi 5 dentro de un gabinete de prueba, `lord-fand` mantuvo el ventilador apagado a 50–53 °C durante una carga de 4 hilos (el gabinete de aluminio funciona como disipador), lo llevó al 55 % (4.500 RPM) y a velocidad máxima (7.400 RPM) con curvas de prueba, y restauró la configuración propia del kernel después de `SIGTERM` y de `kill -9` (`docs/FANS.md`).
-**Monitor e imagen.** Desde la 0.8.4.1 la imagen para Raspberry Pi 5 muestra el escritorio en un monitor HDMI en el primer arranque (la línea del driver de pantalla en `config.txt` ahora va después de las líneas de autodetección del firmware, y LordOS espera hasta 30 s al driver), pone la hora desde la red y trae Chromium y Firefox ESR. Desde la 0.8.4 el kernel de LordOS para la Pi (`6.18.57-lordos.3-rpi-2712`) además destruye las conexiones de una app bloqueada. **Medido con monitor (LordBench, 0.8.6 en desarrollo):** la imagen 0.8.5 arrancada con un monitor de 1920×1080 a 60 Hz en cualquiera de los dos puertos HDMI llega a la pantalla de inicio de sesión 5,99 s después de que arranca el kernel (systemd: 2,1 s de kernel y 4,2 s del resto). Con composición por GPU (V3D), una ventana movida por el compositor se mantiene en 59,4 cuadros por segundo, con un cuadro armado en 10,9 ms (mediana) y 13,0 ms (percentil 99) y el 1,0 % de cuadros tarde; con una carga en todos los núcleos a la menor prioridad baja a 24 cuadros por segundo con el 96,5 % tarde, un problema que encontró LordBench y que falta resolver. En 3 minutos de carga en todos los núcleos con el ventilador la placa mantuvo 5,9 GFLOP/s con 55,6 °C como máximo, y decodifica video 1080p por software a 258 (H.264), 246 (HEVC), 204 (VP9) y 159 (AV1) cuadros por segundo.
+**Monitor e imagen.** Desde la 0.8.4.1 la imagen para Raspberry Pi 5 muestra el escritorio en un monitor HDMI en el primer arranque (la línea del driver de pantalla en `config.txt` ahora va después de las líneas de autodetección del firmware, y LordOS espera hasta 30 s al driver), pone la hora desde la red y trae Chromium y Firefox ESR. Desde la 0.8.4 el kernel de LordOS para la Pi (`6.18.57-lordos.3-rpi-2712`) además destruye las conexiones de una app bloqueada. **Medido con monitor (LordBench, 0.8.6 en desarrollo):** la imagen 0.8.5 arrancada con un monitor de 1920×1080 a 60 Hz en cualquiera de los dos puertos HDMI llega a la pantalla de inicio de sesión 5,99 s después de que arranca el kernel (systemd: 2,1 s de kernel y 4,2 s del resto). Con composición por GPU (V3D), una ventana movida por el compositor se mantiene en 59,4 cuadros por segundo, con un cuadro armado en 10,9 ms (mediana) y 13,0 ms (percentil 99) y el 1,0 % de cuadros tarde; con una carga en todos los núcleos a la menor prioridad baja a 24 cuadros por segundo con el 96,5 % tarde, un problema que encontró LordBench: el cgroup del compositor pesaba lo mismo que el de la carga, así que la baja prioridad de la carga no contaba. Darle al compositor diez veces el peso de CPU de una app y una porción de tiempo más corta subió la misma prueba, sin el monitor, de 35 a 48 cuadros por segundo (61 % → 23 % tarde); falta la medición con el monitor. En 3 minutos de carga en todos los núcleos con el ventilador la placa mantuvo 5,9 GFLOP/s con 55,6 °C como máximo, y decodifica video 1080p por software a 258 (H.264), 246 (HEVC), 204 (VP9) y 159 (AV1) cuadros por segundo.
### 7.5 PC modernas
diff --git a/web/content/paper/paper.pt.md b/web/content/paper/paper.pt.md
index be3b444..77d358c 100644
--- a/web/content/paper/paper.pt.md
+++ b/web/content/paper/paper.pt.md
@@ -484,7 +484,7 @@ O Raspberry Pi 5 é a única placa suportada. Resultados numa placa real (16 GB,
**Ventoinhas.** No Pi 5 num gabinete de teste, o `lord-fand` manteve a ventoinha desligada a 50–53 °C durante uma carga de 4 threads (o gabinete de alumínio funciona como dissipador), a levou a 55 % (4.500 RPM) e à velocidade máxima (7.400 RPM) com curvas de teste e restaurou as configurações do próprio kernel depois de `SIGTERM` e `kill -9` (`docs/FANS.md`).
-**Monitor e imagem.** Desde a 0.8.4.1 a imagem do Raspberry Pi 5 mostra o desktop num monitor HDMI no primeiro boot (a linha do driver de vídeo no `config.txt` agora vem depois das linhas de autodetecção do firmware, e o LordOS espera até 30 s pelo driver), acerta o relógio pela rede e traz Chromium e Firefox ESR. Desde a 0.8.4 o kernel do LordOS para o Pi (`6.18.57-lordos.3-rpi-2712`) também destrói as conexões de um app bloqueado. **Medido com monitor (LordBench, 0.8.6 em desenvolvimento):** a imagem 0.8.5 inicializada com um monitor de 1920×1080 a 60 Hz em qualquer uma das duas portas HDMI chega à tela de login 5,99 s depois que o kernel inicia (systemd: 2,1 s de kernel e 4,2 s do resto). Com composição na GPU (V3D), uma janela movida pelo compositor se mantém em 59,4 quadros por segundo, com um quadro montado em 10,9 ms (mediana) e 13,0 ms (percentil 99) e 1,0 % dos quadros atrasados; com uma carga em todos os núcleos na menor prioridade cai para 24 quadros por segundo com 96,5 % atrasados, um problema que o LordBench encontrou e que falta resolver. Em 3 minutos de carga em todos os núcleos com o ventilador a placa manteve 5,9 GFLOP/s com 55,6 °C no máximo, e decodifica vídeo 1080p por software a 258 (H.264), 246 (HEVC), 204 (VP9) e 159 (AV1) quadros por segundo.
+**Monitor e imagem.** Desde a 0.8.4.1 a imagem do Raspberry Pi 5 mostra o desktop num monitor HDMI no primeiro boot (a linha do driver de vídeo no `config.txt` agora vem depois das linhas de autodetecção do firmware, e o LordOS espera até 30 s pelo driver), acerta o relógio pela rede e traz Chromium e Firefox ESR. Desde a 0.8.4 o kernel do LordOS para o Pi (`6.18.57-lordos.3-rpi-2712`) também destrói as conexões de um app bloqueado. **Medido com monitor (LordBench, 0.8.6 em desenvolvimento):** a imagem 0.8.5 inicializada com um monitor de 1920×1080 a 60 Hz em qualquer uma das duas portas HDMI chega à tela de login 5,99 s depois que o kernel inicia (systemd: 2,1 s de kernel e 4,2 s do resto). Com composição na GPU (V3D), uma janela movida pelo compositor se mantém em 59,4 quadros por segundo, com um quadro montado em 10,9 ms (mediana) e 13,0 ms (percentil 99) e 1,0 % dos quadros atrasados; com uma carga em todos os núcleos na menor prioridade cai para 24 quadros por segundo com 96,5 % atrasados, um problema que o LordBench encontrou: o cgroup do compositor pesava o mesmo que o da carga, então a baixa prioridade da carga não contava. Dar ao compositor dez vezes o peso de CPU de um app e uma fatia de tempo mais curta elevou o mesmo teste, sem o monitor, de 35 para 48 quadros por segundo (61 % → 23 % atrasados); falta a medição com o monitor. Em 3 minutos de carga em todos os núcleos com o ventilador a placa manteve 5,9 GFLOP/s com 55,6 °C no máximo, e decodifica vídeo 1080p por software a 258 (H.264), 246 (HEVC), 204 (VP9) e 159 (AV1) quadros por segundo.
### 7.5 PCs modernos