Skip to content

drm/asahi: g16: Keep compute commands in flight; one 64 MiB PB heap per VM (J773g) - #2419

Open
DjDeveloperr wants to merge 8 commits into
integration/aurorafrom
djdev/g16-in-flight
Open

DjDeveloperr wants to merge 8 commits into
integration/aurorafrom
djdev/g16-in-flight

Conversation

@DjDeveloperr

@DjDeveloperr DjDeveloperr commented Nov 19, 2026 •

Copy link
Copy Markdown
Contributor

On the J773g Mac mini (M4, G16G B0, 25G83 firmware), G16 had two structural gaps against macOS 27.2 on the same machine. It published one GPU command at a time and built the next only after the previous one retired on the host, so a 1.5 µs dispatch cost ~270 µs per submission at any depth. And every rendering process pinned ~0.5 GiB: two 256 MiB parameter-buffer heaps plus its arenas.

Stacking: the first commit is #1543 (@aeries0x, PB epoch reuse), included because commits 2-6 build on its epoch handling. Merge #1543 first; the six commits after it are this PR. Hardware results are with #2239 (J773g S10) as well, as on the mini.

Commits

  1. Keep compute commands in flight. Compute commands queue behind the same VM's in-flight compute on the one firmware compute queue; renders stay one at a time.
    • Each queued command has its own retained unit and its own UMA slot (1 + unit). With every unit in slot 1 (the old two-owner design), queued long compute triggered firmware recovery within seconds: the firmware sets up the next command while the current one runs.
    • The owner ledger generalizes to N owners that retire in publication order.
    • Each command posts its own submit record (the firmware ignores a WRITE advance without one).
    • Flights with later flights behind them retire on "passed" receipts; the newest keeps the exact one.
    • Same-queue compute dependencies follow the published frontier; renders and cross-engine dependencies still need completion.
    • Only the same VM queues (with six dEQP clients, compute queued behind another VM's produced wrong images and a firmware stall), and nothing queues behind a command with user timestamps (the host writes those at retirement; a queued query copy ran before they existed).
    • A VM that submits compute back to back gets 6 units (lazily; others keep 2).
    • Firmware moved its new state to the heap: it is built on the probe's stack, and the larger frame overflowed the 32 KiB stack.
    • debugfs aurora-g16/tune exposes depth, units and the repoll interval.
  2. Share one PB heap between a VM's render allocators. Renders are serialized and retire with their blocks returned.
  3. Let a closed VM's arenas go; slot leases keep their own. Hardware-slot leases held the whole VM state (every arena, PB heap included) until another VM displaced them; leases now hold exactly their arena, and the VM's cache drops its arenas at client close.
  4. Keep never-exposed PB epochs for the next renders. Render submit CPU went from ~190-435 µs to 35-46 µs per vkQueueSubmit (the epoch allocation, mappings and L2 sync were wasted with epoch reuse). The cache drops spares at close; a spare holds its VM.
  5. Size the PB heap at 64 MiB. The 25G83 firmware copes with a short PB without the host. With 8 MiB posted, heavy and tiler-overflow renders still complete, no growth event arrives, and PB-manager counters move only for the scenes that overran it. Heap 16-256 MiB made no difference on gpubench's heavy/tvb rows. Tunable via pb_heap_mb.
  6. Skip the submit-path publication while a render runs. Nothing is published behind a render, so a job submitted during one waits for the poll after its retirement anyway; the submit ioctl's full publication pass (ring drain, health and power checks) under the device lock only delayed the retire-to-publish path. render.light d8 389-396 → 344 µs, d64 368 → 345 µs.

Results (J773g Mac mini, kernel 7.3.0-ARCH-m4drv8; macOS 27.2 on the same machine)

gpubench, µs per submit; stock = the kernel's own aurora.ko, run back to back with this PR's module.

row stock this PR macOS
compute.light d8 / d64 268 / 269 100 / 101 26.4 / 19.7
compute.heavy alu d4 / d64 887 / 880 556 / 554 (= GPU time 554) 539 / 538
render.light tri d1 988 560 212
render.light tri d8 350 344 46.7
render.light tri d64 294 345 42.2
render.heavy fill 1080p d1 / d16 1316 / 801 1000 / 755 502 / 246
concurrent compute+render d4 464 323 54.9
render submit CPU 190-435 35-46 1-2
Geekbench 6.7.1 GPU (Vulkan vs Metal), ms/iteration macOS before (#2239+#1543) this PR this PR + Mesa packing (aurora-silicon/mesa#488)
Background Blur 9.14 82.4 34.7 23.2
Face Detection 6.17 122.8 50.9 38.8
Feature Matching 14.96 89.7 40.4 37.5
Particle Physics 31.17 145.4 67.0 64.2
Stereo / Gaussian / Edge / Horizon 7.4 / 9.4 / 10.3 / 13.8 21.8 / 22.9 / 16.1 / 22.4 18.6 / 22.5 / 13.4 / 18.4 18.8 / 22.6 / 13.3 / 18.2

Memory (unevictable delta per process, settled): 8 × render.light 158 MB (stock 551, macOS 60); 4 × render.heavy 100 / 124 MB (stock 324 / 348, macOS 111 / 95). Idle desktop after boot: 0.47 GB unevictable (before 2.75 GB). Compute-only process: 52 MB with 2 units, 149 MB with the 6 units a pipelining client gets.

Regressions against stock (same kernel)

  • render.light d64: 294 → 345 µs (d8 and d1 are faster). The per-render firmware turnaround (gap) went from ~302 to ~322 µs; I have not found the cause.
  • Compute-only processes pin more: 8 × compute.light, 60 → 174 MB unevictable per process (macOS 78). A process that submits compute back to back gets 6 units, each with its own arena; aurora-g16/tune compute_units=2 keeps 52 MB but gives back the pipelining.
  • The full gpubench plan was run with commits 1-5 only (before commit 6). Slower than stock there: compute processes in separate VMs (compute.heavy procs 893 → 1016-1025 µs, compute.light procs 261-267 → 283-310 µs; cross-VM commands still go one at a time and pay one more check per turnaround), render.heavy fill d2-d64 by 5-15%, render.light d32/d64, and mem.buffer 64 MiB / mem.image 4096 cycles (1373 → 1725 / 1317 → 1826 µs). The timestamp query rows look worse only because the baseline without queries got faster: commands with timestamps still run one at a time.

Tests

  • Vulkan CTS 1.4.7.1, 1/16 sample (198,732 cases), 6 jobs, commits 1-5: 84,219 Pass, 0 Fail, 0 Crash, 1 QualityWarning, no GPU recovery (before: 84,183 Pass / 0 Fail). Final module (all six): the groups that failed during development (api, binding_model, draw, host_image_copy, fast_linked_library, image, sampler, stencil, timestamp) rerun at 0 Fail, timestamp 18/18.
  • GLES/EGL (public GL plan, 6 jobs, commits 1-5): 0 Fail, 0 Crash. dEQP-EGL 2,360 Pass; dEQP-GLES2 17,051; GLES3 44,567; GLES31 37,543 (incl. multisample); KHR-GLES2/3/31/32 468 / 6,479 / 4,060 / 1,403; KHR-GL46 13,846 Pass of 15,000 run (the 25-minute budget ended with 4,211 left).
  • packtest (Mesa submit packing): 21/21 PASS.
  • tools/testing/selftests/drivers/gpu/asahi-m4/run-host-tests.py: 23/23. Harness mocks were updated for the new calls, and host cases were added for the N-owner ledger, the published frontier, in-order "passed" retirement and cache close.

Recovery: a firmware-aborted owner's unit returns to service (commit 7, 4b15d49)

  • The issue it fixes. This branch had it before commit 7, and stock has it too:

    • A firmware recovery marks every unfinished flight suspect. Each suspect flight the recovery passes without a full receipt is aborted, and its units were quarantined for good.
    • Once every compute unit a VM may use was quarantined, every compute job of every client was cancelled (ECANCELED) until a reboot. Rendering went the same way once both pass slots were quarantined.
    • With compute kept in flight, a single recovery can abort all six units.
  • The fix. An aborted owner is now abandoned:

    • Its job fails, and its VM's sticky error is latched under the device lock before anything else is published, so nothing loads the aborted storage again. The engine retains the job, so that storage stays mapped.
    • Its unit returns to service for other storage as a fresh owner. It never counts as a displacement proof: an owner published before it still needs a later full retirement.
    • Quarantine stays for storage that can't be trusted (corrupt descriptor identity, failed retirement).
  • Hardware, J773g, 2026-11-19. Four forced firmware recoveries in a row (event type 4), each aborting compute:

    • every aborted owner was abandoned, and none quarantined;
    • after each one, a new process ran a host-checked compute test that PASSED, with no reboot;
    • render and compute rows afterwards ran OK in other processes.

    With the quarantine rule, the same trigger left compute cancelled for every client until a reboot.

  • Trigger and module. The recoveries were forced with an experimental tune of my follow-up branch (compute_pool_share=1, which trips the firmware every time). The module was that branch plus this commit, whose poll.rs/slots.rs/lifetime.rs are byte-identical to this PR's. A write through an unmapped device address does not fault on G16G (it completes), so it can't serve as the trigger.

  • Host tests: run-host-tests.py 23/23. test-recovery.py now covers six pipelined units with a recovery aborting all of them every third round.

Bisect of the six commits (J773g, 2026-11-19, same boot state for all; 3 runs per module plus an ABAB repeat)

  • Commit 1 takes compute.light depth 64 from 275 to 104 µs. It's also the whole light-compute memory increase: 8 processes, 59.8 → 173.5 MB each (six units, each with its own 32 MiB UMA pool). That remains open.
  • Render memory per process: 629 MB stock → 373 MB with commit 2 → 181 MB with commit 5. render.light 4 processes: about 1,110 → 691 µs with commit 5, → about 550 µs with commit 6.
  • render.light depth 64: stock is bimodal here (344/433/436 µs, ±100 within runs), and commits 4–6 are stable at 367–389 µs. The earlier 294 → 345 µs reading didn't reproduce.
  • Heavy fill, compute processes, mem.buffer 64 MiB and mem.image 4096: within noise of stock.

Not done

  • Render pipelining (TA of the next render during the current FS). It needs per-slot render UMA slots and one PB manager shared across consecutive renders (the macOS model). render.light d64 is still ~345 µs vs macOS 42.
  • Cross-VM queuing is wrong on this firmware path as built (see commit 1). macOS gives each context its own queues.
  • PB growth. The heap is a fixed 64 MiB; the firmware handles overflow itself. Host-side growth between epochs from the overflow counters is possible.

🤖 Generated with Claude Code

aeries0x and others added 7 commits November 19, 2026 08:57
Every G16 render gets a fresh parameter buffer epoch at SUBMIT and an
InitBM ahead of its TA work, so the firmware rebuilds the allocator
state for each render. Reusing the epoch instead cuts a small triangle
render at queue depth 1 on a base M4 MacBook Pro (J604) from 1121 to
492 us.

With this change, the next render of the same VM on a pass slot gets the
slot's owner epoch, without a reseed or InitBM, if that epoch's render
retired normally and was exposed. InitBM binds the device-wide slot to
one epoch and VM, so this happens only while no other epoch was handed
to the slot since; after another VM's render on the slot, after a failed
or aborted render, or after any firmware recovery, the next render
starts fresh. SUBMIT still allocates a fresh epoch for every render, so
one is always at hand. Renders are bound, published and retired one at a
time, so the slot's owner is the epoch it is bound to whenever reuse is
allowed.

The reused epoch is the slot's existing owner lease, so this holds no
epoch, VM or admission permit beyond what the lease already holds: a
slot binding is tracked by a counter, not by a reference. A host test
covers when an epoch may be reused and that nothing else holds it.

aurora.g16_pb_reuse=0 restores a fresh epoch and InitBM per render.
The stats line counts reused and fresh bindings.

Assisted-by: LLM
Signed-off-by: Friedrich <261542475+aeries0x@users.noreply.github.com>
G16 published one command at a time and built the next only after the previous one fully
retired on the host, so every compute command paid the whole firmware and host round trip:
on the J773g Mac mini a 1.5 us dispatch cost ~270 us per submission at any queue depth, and
dependent work (one command buffer per dispatch, as Geekbench records it) was bound by it.

Queue compute commands behind in-flight compute commands on the one firmware compute queue:

- A VM gets more retained compute units, each in its own hardware UMA slot (unit k in slot
  1 + k). All units in slot 1, as before, is not safe once commands are queued: the firmware
  starts the next command while the previous one still runs, and with long commands two
  owners of one slot then corrupt each other (firmware recovery within seconds on queued ALU
  work). With one slot per unit, ~115k queued commands ran without a recovery.
- The displacement ledger generalizes to N owners: owners retire in publication order, and an
  owner is reusable once any later publication retired (the firmware finished it before
  starting that one). Publication stays serialized for the render pass slots.
- Every queued command posts its own submit record and doorbell (the firmware does not pick up
  a WRITE advance without one) behind unconsumed ones, with room checks before anything is
  visible.
- A flight with later compute flights behind it retires on "passed" receipts: its stamp,
  queue READ cursor and the submit pipe's cursors have moved past it. The newest flight keeps
  the exact receipt.
- A compute command may follow its queue's published (not yet retired) compute predecessors:
  the firmware compute queue runs commands in publication order, each to its Finalize.
  Renders and every cross-engine dependency still wait for completion, and nothing is
  published behind a render or a failed, doomed or recovering flight.
- Only the same VM's commands queue behind each other: with six dEQP clients, compute queued
  behind another VM's lost writes (image and sampler cases failed) and stalled the firmware
  queue. Nothing queues behind a command with user timestamps either: the host writes them
  when the command retires, and a query copy queued behind it ran before they existed and
  never finished.
- Recovery matches a snapshot entry against every flight and marks every unfinished one; a
  failed flight dooms the later flights of its queue (their commands would follow a hole).
- Two units per VM as before; a VM that submits compute back to back (three submissions within
  2 ms each, or three compute commands in one submission) gets four more, mapped at
  0x7090000000, so ordinary clients keep the old memory cost.
- Up to 16 jobs per logical queue reach the engine (was 2).
- The engine statistics and the compute owner ledger move to the heap: `Firmware` is built on
  the probe's stack, and its larger frame overflowed the 32 KiB kernel stack.
- `aurora-g16/tune` (debugfs, root) sets the depth (compute_flights; 1 = the serialized engine),
  the units of a growing VM and the completion repoll interval for measurements.

J773g Mac mini (G16G B0, 25G83), gpubench, before -> after (macOS 27.2 on the same machine):
compute.light d8 268 -> 136 us/submit, d64 269 -> 125 (gap between commands 266 -> 16.5 us;
macOS 19.7), compute.heavy alu d4 874 -> 557, d64 871 -> 554 (GPU time 554; macOS 540),
compute.heavy bw d16 1667 -> 1275 (macOS 1437).

Signed-off-by: Diljit Singh <hey@djdev.me>
Every rendering VM pinned two 256 MiB parameter-buffer heaps, one per render allocator (pass
slot), so each rendering process cost ~0.5 GiB of unevictable memory and a few dozen clients
(a dEQP-EGL run at six jobs) exhausted a 24 GiB Mac mini. macOS 27.2 on the same machine adds
~24 MiB of wired memory per rendering process.

A render is published only while nothing else is in flight and retires with its PB blocks
returned to its manager, so the two pass slots' PB managers never hand out heap blocks at the
same time. Back both with one heap at the first slot's address.

Signed-off-by: Diljit Singh <hey@djdev.me>
A hardware slot's last owner stays bound until a later owner displaces it, because the
firmware may still write that owner's descriptor then. The leases held the owner's whole VM
state, and with it every arena of the VM: a closed client whose compute unit was the last in
some UMA slot kept its 256 MiB PB heap and its compute pools pinned until another VM happened
to use that slot. With more compute units, slots used only by clients that queue compute are
displaced rarely, and closed clients stayed pinned.

Each lease now holds exactly the arena of its unit (compute) or pass slot (render) beside the
VM state, and the VM's cache lets go of its arenas when the client closes the VM. What jobs
and leases still need, they hold themselves; the rest is freed at close.

Signed-off-by: Diljit Singh <hey@djdev.me>
Each render submission allocated a fresh PB epoch: three firmware objects, their GPU and
firmware mappings and a shared-L2 synchronisation. With PB epoch reuse most renders never
expose that epoch, and its deferred teardown unmaps it again. Render submission cost ~390 us
of CPU per vkQueueSubmit on the J773g Mac mini (compute ~25 us).

Return a retired job's never-exposed epochs to its VM (up to four, under a spinlock: a job may
drop in any context) and hand them to the next render submissions before allocating. A spare
keeps the budget permit it was created with. A spare holds its VM, which holds the cache, so
the cache drops its spares, and takes no more, when the client closes the VM.

Signed-off-by: Diljit Singh <hey@djdev.me>
The parameter-buffer heap was the whole 256 MiB window, fully backed and pinned for every
rendering VM. The 25G83 firmware copes with a PB that runs out without the host: with only
64 blocks (8 MiB) posted, heavy and tiler-overflow renders still complete, no growth event
arrives, and counters in the PB manager move only for the scenes that overran it.

Back 64 MiB of the window by default and name only the backed part in the page and block
lists. `aurora-g16/tune` sets the heap of VMs created later (pb_heap_mb, 8..256) and caps the
blocks a fresh epoch posts (pb_blocks), for measurements.

Signed-off-by: Diljit Singh <hey@djdev.me>
Nothing is published behind a render, so a job submitted while one is in flight waits for the
poll pass after its retirement anyway. With more jobs admitted per queue, each such submit
still ran a full publication pass (ring drain, health and power checks) under the device lock
and delayed the retire-to-publish path: gpubench render.light at depth 8 took 389-396 us per
submission. Enqueue only; the next poll publishes it (344 us; stock 350, macOS 47).

Signed-off-by: Diljit Singh <hey@djdev.me>
A firmware recovery marks every unfinished flight suspect, and a suspect
the recovery passed without a full receipt is aborted. Its units were
quarantined for good. Once every unit a VM may use was quarantined, every
compute job of every client was cancelled until a reboot, and rendering
the same once both pass slots were. One client's fault with compute in
flight could do that; with compute kept in flight, one recovery can abort
all six units at once.

An aborted owner is now abandoned instead:

- Its job fails and its VM's sticky error is latched under the device
  lock before anything else is published, so no job of that VM is
  published again and nothing loads the aborted storage. The engine
  retains the job, which keeps that storage mapped for good.
- Its unit returns to service for other storage as a fresh owner. It is
  not a retired owner, so it proves no displacement: an owner published
  before it still needs a later full retirement.

The recovery passed the aborted command, so nothing runs in its UMA slot
when the next owner is published, and a render's next epoch is fresh
(the recovery invalidated every PB binding). Quarantine stays for storage
that cannot be trusted: a corrupt descriptor identity or a failed
retirement.

Measured on the J773g (M4, 25G83 firmware, kernel 7.3.0-ARCH-m4drv8),
2026-11-19: four forced firmware recoveries in a row, each aborting
compute. Every recovery's owner was abandoned (quarantined 0), compute
passed a host-checked dispatch test in a new process after each one with
no reboot, and render and compute ran in other processes afterwards.
Without this change the same trigger left compute cancelled for every
client until a reboot.

Signed-off-by: Diljit Singh <hey@djdev.me>
@davishann15-commits

Copy link
Copy Markdown

@DjDeveloperr, tested on a J604 (MacBook Pro 14" M4, 10-core G16G B0, GPU firmware 25G83). Each rendering process now pins 177.6 MiB instead of 625.5 MiB, a closed render+compute client no longer leaves 625 MiB behind, and the output is identical with no GPU faults.

Both rows are one boot each of the same tree: alarm-aurora's pkgrel 38 recipe on integration/aurora 0b03fe4, plus #1543, #1895, #1917, #1918, #1919, #1922 and #1971. The second boot adds this PR's commits 2-8 at 4b15d49. Commit 1 (#1543) is already in the tree and identical, and the rest applied cleanly. The asahi-m4 host suite passes 23/23 on the result.

Setup for both boots:

  • Mesa: mesa-aurora 26.3.0_devel (d4ad4a4dce6).
  • Desktop: Hyprland 0.57.2 at 3024x1964@120, scale 2.
  • Power: on battery (40-42 %), profile balanced.
  • Apps: Firefox, Glass and kitty open; each run started 4 minutes after login.

Method:

  • Memory is kernel_resident from gpu_memory. The idle rows also give Unevictable.
  • The clients are a small surfaceless GLES program.
  • During the per-client rows, a second client renders and dispatches every 200 ms, so an exited client's unit leases get displaced. Without it, an idle compositor leaves the last renderer pinned on both kernels.
stock (same tree, no PR) this PR
one rendering client 625.5 MiB (5/5) 177.6 MiB (177.5-177.7, 5/5)
one compute-only client 65.1 MiB 65.1 MiB
one render + compute client 690.5 MiB 242.6 MiB
three rendering clients at once, per client 625.5 MiB 177.7 MiB
extra kitty window (own process), kernel / user BOs 625.6 / 15.8 MiB 177.8 / 18.3 MiB
left pinned after a render+compute client exits, with only render work afterwards 625.5 MiB (5/5) 0.0 MiB (5/5)
right after login: Hyprland and one kitty (Unevictable) 1879 MiB (2207) 536 MiB (867)
same plus Firefox and Glass, 4 min after login (Unevictable) 3130 MiB (3569) 891 MiB (1334)
first frame of a new client 40-54 ms 14-19 ms
steady trivial frame, glFinish each 1.02-1.12 ms 0.58-0.59 ms
small dispatch, glFinish each 0.38-0.45 ms 0.42-0.43 ms
glmark2-es2-drm --off-screen build / shading(phong) / refract, 5 s each score 458/459 (652 / 648 / 78 FPS) score 669/671 (967 / 957 / 90 FPS)
1M small triangles at 3024x1964, GPU time 20.3-20.7 ms 19.9-20.1 ms
  • Rendering output: scenes of 250k and 1M small triangles at panel size were read back and hashed. The hashes match across both kernels and every repetition.
  • Debugfs after the PR run:
    • stats: pb: ... requests 0 bad 0, recoveries 0, aborted 0, nothing quarantined.
    • tune: pb_heap_mb=64, compute_units=6.
    • There is no PB high-water counter, so I can't tell whether those scenes went past 64 MiB.
  • Run-to-run noise: an earlier stock session on this Mac gave the same memory rows. Its glmark2 scores of 457-495 show the stock spread, and the PR scores are well outside it. The PR run also started warmer (54 °C vs 50 °C die).
  • My compute client never queues work back to back, so it stayed at 2 units (65 MiB). I didn't measure the 6-unit case.
  • Not tested: Vulkan, games, CTS, long sessions, suspend/resume on the PR kernel, and AC power.

This is the problem I reported in #1943 for this Mac: with this PR a terminal window costs 178 MiB instead of 626 MiB.


Disclosure: an LLM (Claude) ran these boots and measurements on my Mac and drafted this. I reviewed it and am responsible for it.

Assisted-by: LLM

@RyanTheTide

Copy link
Copy Markdown
Contributor

Blockers: 2.

I checked the N-owner ledger and the slot code at the head (slots.rs claim/hold/publish/retire/abandon/release, which keep pending_arena/arena in step with pending_owner/owner). The spare-epoch hand-back keeps the budget permit with the epoch, and the PB epoch drop goes through the cleanup queue without allocating. The commits after #1543 are signed off with no Co-Authored-By or Assisted-by trailers.

  1. drivers/gpu/drm/asahi/g16/poll.rs:623-624 together with engine.rs:398: an aborted flight's job is now pushed onto engine.retained and its unit goes back into service. retained is never drained, and each entry keeps its Prepared alive: the compute arena (base or extension units with their UMA pools), the render arena with its PB heap, and the VM state. Before this change, quarantine capped that growth, because once the units were used up compute stopped. Now every recovery that aborts work adds up to six more retained jobs, with no ceiling. A client whose work keeps getting aborted below the storm limit in recovery.rs:312 pins more memory each time. Fix: release an abandoned job's storage once a later owner of the same unit fully retires (the same proof Lifetime already uses for displacement), or cap the abandoned owners and quarantine past the cap.
  2. drivers/gpu/drm/asahi/g16/resources.rs:151/176/285: spares is a plain SpinLock. The commit message says the give-back runs "under a spinlock: a job may drop in any context", and prepare() pops from it with interrupts enabled (line 285). If Prepared can drop from a hardirq fence callback, that callback can spin on a lock its own CPU already holds. Either make it an irq-disabling lock, or send give_back() through the existing cleanup queue and say in the comment which contexts it runs in.
  3. drivers/gpu/drm/asahi/g16/params.rs:32-73: the writable aurora-g16/tune debugfs file changes shipped behaviour at runtime (queue depth, units per VM, PB heap and posted blocks, repoll). It also lets the bookkeeping drift: Slots::compute_exhausted() (slots.rs:449-453) checks only the first params::compute_units() units, so lowering compute_units while VMs hold six units changes when every client's compute gets cancelled. Keep the file read-only (show the values) and fix the values as constants, or document it as debug-only and make compute_exhausted() use sizes::COMPUTE_UNITS.
  4. The first commit is drm/asahi: g16: reuse a pass slot's retired PB epoch #1543's. It still carries an Assisted-by: LLM trailer and adds the g16_pb_reuse module parameter (asahi_core.rs:170). Both should be settled on drm/asahi: g16: reuse a pass slot's retired PB epoch #1543. Rebase this PR on it once it lands, so this PR doesn't merge that commit a second time.

The PR body ends with the "Generated with Claude Code" line rather than an Assisted-by: LLM (...) line.

HW row: J773g and J604 on the final 7-commit module, default command line: a compute client that queues back to back (6 units) under the Vulkan CTS 1/16 sample at 6 jobs, 0 Fail/0 Crash, no GPU recovery. Then 20 forced recoveries in a row with engine.retained length and kernel-resident memory reported after each, which should stay flat with point 1 fixed. Include the regression summary for each boot (0 AVC denials, 0 failed units, 0 new kernel errors).

Assisted-by: LLM (Claude:Opus 5.5)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants