Skip to content

drm/asahi: g17: M5: render large passes instead of losing the device after 26 s, refuse those that cannot fit, and account their memory to the client - #2501

Open
funkzy wants to merge 3 commits into
aurora-silicon:integration/aurorafrom
funkzy:pr/m5-render-pair-memory
Open

funkzy wants to merge 3 commits into
aurora-silicon:integration/aurorafrom
funkzy:pr/m5-render-pair-memory

Conversation

@funkzy

@funkzy funkzy commented Nov 20, 2026 •

Copy link
Copy Markdown
Contributor

Problem

On M5 a render pair's target records, TPC object and initial parameter buffer are sized from the client's render pass, with no cap: the objects were allocated in full before they were mapped into the client's 4 GiB compact window, and they were accounted as kernel memory rather than to the client. On the Mac Studio (M5 Ultra, J775D) a pass whose pair took more than half the window, such as a single-sample 512x512 pass of 2048 layers, never rendered: the queue's second render pair did not fit beside the first, and after about 26 s the client saw a lost device.

Change

Three commits in drivers/gpu/drm/asahi/g17:

  1. SUBMIT refuses, with ENOMEM and before anything is allocated, a layout whose pair cannot fit the 4 GiB window. A pair also checks for room before it allocates a target object or parameter blocks (ENOSPC).
  2. Those objects are admitted against the client's and the device's memory limits and counted as the client's memory.
  3. A render runs on both of its queue's pairs only when the window holds its layout twice, otherwise on one pair, always the same one.

Which parts it affects: the M5 render path (the G17 parts whose firmware uses the compact window), selected by the existing M5 firmware path in the driver; this series adds no chip, board or firmware condition of its own. The window size is the firmware interface's (32-bit offsets), not a tuned value. Commit 3 only matters where a queue holds two pairs, today the M5 Ultra; every other G17 part holds one pair per queue and is unchanged. No new parameter or default.

Testing

On the J775D (Mac Studio, M5 Ultra), 27.0 firmware, integration/aurora cc14570 with #1973 and our other three open drm/asahi PRs, default command line, one boot (the kernel also carries a local fix for an appledrm oops at boot on current integration, not part of this PR). Borealis, single-sample R8, all four corners read back:

Pass Pair size Before the series (earlier boots) With the series (this boot)
512x512x2048 2.2 GiB EBUSY after 26 s, lost device correct; also two in flight
16384x16384x22 2.3 GiB EBUSY after 26 s correct
over 4 GiB (16384x16384x54; x23 with more than four primitives) SUBMIT returns ENOMEM; the same client then renders and dispatches correctly, no lost device

The client's fdinfo grows during each pass (to 8201 MiB at 16384x16384x22 and 2984 MiB at 512x512x2048, image included) and the device's committed memory returns to its starting value within seconds of the client's exit. The render CTS subset gives 571 Pass and 57 NotSupported, as on the same base without the series. KUnit (366 of 368 pass, two skips as on the base) and the upstream host tests (427 of 427 on base and head, no result differs) pass.

Regression run (ALARM has no SELinux, so there is no AVC count): 0 new failed units (iwd.service and systemd-networkd-persistent-storage.service fail on the read-only test root with and without the series) and 0 new kernel error lines against the boot without the series, apart from the intended submit failed ... ENOMEM of the over-4 GiB cases.

Since RyanTheTide's review: the discard object's size is named once, for the bound and for the pair that allocates it (first commit), and the pair window is computed once at SUBMIT, kept with the command and used when the render's pairs are chosen (third commit). Behaviour is unchanged; git range-diff shows only those lines and the messages. The earlier rows on 27.2 firmware (below) were taken on the previous head.

Still to run

  • The M5, M5 Pro and M5 Max take commits 1 and 2 and were not run; rows from RyanTheTide's lab or their owners welcome: 16384x16384x22 and 512x512x2048 rendered with correct readback, a pass over 4 GiB returning ENOMEM without a lost device, the render CTS subset, 0 failed units and 0 new kernel errors.
Full description of the three commits
  1. Refuse layouts that do not fit. Deriving the layout (which SUBMIT does for every M5 render) returns ENOMEM when one pair's objects do not fit the 4 GiB window: the records, TPC object and initial parameter blocks the layout sizes, about 3.8 MiB of per-pair objects it does not size (context state, scene scratch, page lists, metrics), guard pages and placement alignment. A layout accepted at SUBMIT can therefore run on one pair. Before allocating a target object or parameter blocks, a pair also checks that the window has room for them, and returns ENOSPC otherwise, as the mapping would.
    • The bound depends on the pass's tile size and on whether it is marked as drawing few primitives. On the M5 Ultra, for a single-sample pass with 32x32 tiles (what Borealis uses for such a pass), it admits a 16384x16384 target of up to 22 layers with more than four primitives and up to 53 layers with four or fewer, and 2048 layers of a target up to 1024x1024 (up to 2048x2048 with few primitives). With 16x16 tiles, it admits up to 5 layers at 16384x16384 and 2048 layers up to 512x512. KUnit pins these sizes.
  2. Account the memory to the client. The target records, TPC object, initial parameter blocks and each growth are admitted against the client's and the device's memory limits, as the M5 pool backing already is. They are then counted as the client's memory until freed. A refusal fails that render, or declines that growth.
  3. Run a pass on one render pair when the window holds it only once (M5 Ultra). A render queue there may hold two render pairs, each with its own copy of the layout's objects in the same window. For a pass over about half the window (any 2048-layer target, for example), the second pair did not fit, the render waited for room its own first pair held, and failed with EBUSY after about 26 seconds. Each render now gets a pair count: both pairs for a layout the window holds twice, one otherwise. Admission keeps such renders on one of the queue's pairs, so a later render is never placed on a pair that cannot be built. Smaller renders of the same queue still use both pairs.

Other G17 parts are unchanged.

Full test results

On the Mac Studio (M5 Ultra), 27.2 firmware, on the integration branch at the previous head, with Borealis (single-sample R8, one draw per pass, all four corners read back):

Pass Pair size Before the series With the series
16384x16384x15 1.9 GiB correct correct, on two pairs
512x512x2048 2.2 GiB EBUSY after 26 s, lost device correct; also two, three and four in flight
16384x16384x22 2.3 GiB EBUSY after 26 s correct
1152x1152x2048 3.1 GiB not run correct
2048x2048x2047 3.9 GiB EBUSY after 26 s correct
16384x16384x22, more than four primitives 4.0 GiB not run correct
16384x16384x53 4.0 GiB not run correct
16384x16384x54; x23 with more than four primitives; 1152x1152x2048 with more than four primitives over 4 GiB SUBMIT returns ENOMEM
  • With the series but the queue's full pair count for every render, three 512x512x2048 renders in flight still failed with EBUSY after 26 s; with the per-render count they are correct.
  • Heavy 1080p rows at depth 8, same boot: fill 38.2 us and geometry 36.9 us per submit, the same as with the queue's full pair count for every render, and 7-10% less time per submit than on one pair (42.4 and 39.8 us).
  • Render CTS subset (628 cases): 571 Pass and 57 NotSupported.
  • vkcompute, vkchain (300 rounds), vktimestamp and 46 concurrent clients: all exact.
  • KUnit: all asahi suites pass, including the pinned window sizes and the pair-count and admission cases (348 of 350 on the previous head with the integration base, the two skips as on the base).
  • Kernel log and units: the control boot and the series boots were compared line by line after removing timestamps and numbers; the only error line the series adds is the ENOMEM refusal above. The boot journals list iwd.service as failed in every boot, and wayvnc.service in the boot whose test stopped the desktop.
Known limits
  • The window is shared by all of a client's render pairs. A layout that fits on its own can still find too little room beside the client's other pairs, on another queue or built for an earlier layout of the same queue; that render waits for room as before.
  • Borealis advertises 16384x16384x2048 framebuffers. On M5 the largest of these do not fit the window, before or after this change.
  • The other G17 parts still allocate their (capped) targets as kernel memory.

Thanks to ewb, who reported the uncapped M5 target sizes and suggested refusing and charging them, and to RyanTheTide for the review.

  • Clean-room: no Apple code, strings, firmware, RE output or tuning values
  • No chip/board/firmware-version gate where a hardware property can decide
  • Works on the default kernel command line; no hacks, delays or lab-only paths
  • Safety limits come from the machine, not from constants in code
  • Hardware safety rules followed for every test boot
  • Third-party commits unchanged; reporters and testers credited
  • Commits: human Signed-off-by only; no co-author or Assisted-by trailers
  • Tested on the affected hardware; no regression

Assisted-by: LLM (Claude:Opus 5.5)

@funkzy
funkzy force-pushed the pr/m5-render-pair-memory branch from 9d1e69b to 48c5f89 Compare November 20, 2026 19:25
@funkzy funkzy changed the title drm/asahi: g17: M5: bound render target layouts by the compact window and account their memory to the client drm/asahi: g17: M5: render large passes instead of losing the device after 26 s, refuse those that cannot fit, and account their memory to the client Nov 20, 2026
@funkzy
funkzy force-pushed the pr/m5-render-pair-memory branch 2 times, most recently from 8a3871f to daa0d08 Compare November 21, 2026 06:20
@RyanTheTide

Copy link
Copy Markdown
Contributor

No blockers.

I checked these and they read correct:

  • The SUBMIT-time bound (m5_layout()/pair_window_bytes(), drivers/gpu/drm/asahi/g17/queue/render/m5_render_submission.rs:135-217) uses checked arithmetic throughout and refuses a layout before anything is allocated.
  • check_m5_room() runs before each allocation in both the target and TVB paths.
  • KernelObject::client_backing() (g17/object.rs:118-134) releases its admission if the allocation fails, because Commit is RAII, and drops the charge with the object.
  • Admission (can_pick_render()/pick(), g17/queue/admission.rs:414-465) follows the same one-pair rule in the scheduler check and at pick time; usable() and join() agree.
  • The two-pair split only applies where self.pairs > 1, so other G17 parts are unchanged. No trailers to fix.

Two nits:

  1. pair_fixed_bytes() uses a bare 0x8000 for the discard object (m5_render_submission.rs:197), and the allocator uses its own literal for the same object (Compact::new(alloc, vm, 0x8000) in g17/queue/render/memory.rs:568). Name it once and use the constant in both places, so the SUBMIT bound cannot drift from what a pair actually maps.
  2. render_pairs() (g17/runtime/render/submit.rs:43-54) derives the whole layout again on every call, and a packet goes through it up to four times (submit.rs:106, 209, 431, 594, plus ensure_render). Compute the window bytes once at SUBMIT, where layout_and_window() already runs, and keep them on the packet.

HW row: an M5, M5 Pro or M5 Max (for example J815 or K114c) on this head, since commits 1 and 2 apply there. Run 16384x16384x22 and 512x512x2048 single-sample passes (correct readback), one over-4 GiB pass (SUBMIT returns ENOMEM, no lost device) and the same render CTS subset (no Pass to Fail). Check the client's fdinfo memory grows by the pair size during the large pass and returns afterwards. Pass: 0 failed units and no new kernel errors besides the intended ENOMEM line.

Assisted-by: LLM (Claude:Opus 5.5)

…compact window before allocating them

On M5 a render pair's target records, TPC object and initial parameter
buffer are sized from the client's render pass. The record and TPC
limits apply only to the other G17 parts, so on M5 these sizes were
bounded only by integer overflow. A pair allocated and zeroed each
object in full before mapping it into the client's compact window, so a
layout too large for the window was allocated first and then failed at
the mapping, and the render was retried while the runtime waited for
capacity.

The other parts are bounded by the window their targets live in. On M5
that window is the client's compact window, which the firmware addresses
with 32-bit offsets: 4 GiB. A pair maps there its target records (one
stride of the page-rounded record for each of the 32 command slots), its
TPC object, its initial parameter blocks at 0x88000 bytes each, and
about 3.8 MiB of objects its layout does not size: the context state of
each command slot, the parameter buffer's scene scratch and discard, its
block manager's page list, its metrics entry and its pool page list.
Each object is followed by its guard page where it has one and placed at
32 KiB alignment. The discard object's size is named once, for the bound
and for the pair that allocates it. A layout whose pair does not fit in
the window can never be mapped, so deriving the layout, which SUBMIT
already does for every M5 render, now refuses it with ENOMEM before
anything is queued or allocated.

The bound depends on the pass's tile size and on whether it is marked as
drawing few primitives, which sets how much of the TPC object is needed.
On the M5 Ultra, for a single-sample pass with 32x32 tiles, the size the
Borealis Vulkan driver uses for such a pass, this admits a 16384x16384
target of up to 22 layers when the pass draws more than four primitives,
and up to 53 layers when it draws four or fewer; 2048 layers of a target
up to 1024x1024, or up to 2048x2048 with few primitives. With 16x16
tiles it admits up to 5 layers at 16384x16384 and 2048 layers up to
512x512. KUnit pins these sizes and their first refused neighbours.

The window is shared by the client's pairs, so a layout that fits on its
own can still find too little room. Before allocating a target object or
parameter-buffer blocks, a pair now checks that the window has a hole
for the object and room for all the blocks, and fails with ENOSPC, as
the mapping would, without allocating them.

Other G17 parts are unchanged.

Reported-by: Erik Bourget <erik@ebourget.net>
Suggested-by: Erik Bourget <erik@ebourget.net>
Suggested-by: Ryan Murray <ryan@aurorasilicon.org>
Signed-off-by: Jeff Queisser <funkzy@users.noreply.github.com>
…izes it

On M5 a render pair's target records, TPC object and parameter buffer
are sized from its client's passes and geometry: up to the 4 GiB of the
client's compact window for each pair, and a client can hold a pair on
each of its queues. They were allocated as kernel memory, which counts
toward the device total but is not refused and is attributed to no
client, so the client's memory limit and fdinfo did not include it.

Charge that backing as the M5 pool backing is charged: admitted against
the client's and the device's memory limits before it is allocated, as
a user buffer of the same size would be, and counted as the client's
held memory instead of kernel memory until it is freed. This covers the
target records and TPC object when a pair is built for a client and
when a larger target replaces them, and the parameter buffer's initial
blocks and every growth. A refusal fails the allocation with ENOMEM:
building or growing the pair for a render fails that render, and a
growth the firmware asks for is declined, as when the buffer is at its
largest. The client's fdinfo now includes this memory.

Other G17 parts are unchanged.

Reported-by: Erik Bourget <erik@ebourget.net>
Suggested-by: Erik Bourget <erik@ebourget.net>
Signed-off-by: Jeff Queisser <funkzy@users.noreply.github.com>
…one render pair, so it renders instead of failing after 26 s

On the M5 Ultra a render queue may hold two render pairs. Each pair maps
its own target records, TPC object and parameter blocks, sized from the
pass, in the client's 4 GiB compact window. The first render of a pass
warms the second pair at the same layout, and admission spreads a
queue's renders over both. A pass whose pair takes more than half the
window, such as a single-sample 512x512 pass of 2048 layers or a
16384x16384 pass of 22 layers (2.2 to 2.4 GiB a pair), never rendered:
building the second pair failed with ENOSPC, the render waited for room
that its own first pair held, and after about 26 seconds failed with
EBUSY, which the client saw as a lost device. Skipping the second pair
when it does not fit is not enough: with three such renders in flight
the third went to the unbuilt pair and failed the same way.

Decide per render how many pairs its queue uses: both for a layout the
window holds twice, else one (g17::pairs::for_window). SUBMIT, which
already derives the layout, keeps the window bytes of one pair on the
command, and the decision reads them there. A render that runs on one
pair goes, through admission, only to the pair that took its queue's
previous such render, so the large layout's objects exist in one pair,
and it claims and warms no sibling. The scheduler's admission check
applies the same rule, so it waits for that pair rather than for any.
Smaller renders of the same queue still use both pairs. The optional
warm-up of a sibling for which the window or the client's memory limit
has no room is skipped as a busy one is, and the render runs on its
pair.

The rule only narrows a queue's renders to a slot it already holds: a
held, quarantined or killed slot is handled as before, and no slot goes
to another queue.

On the M5 Ultra, Borealis (Vulkan) renders of 512x512x2048 (one, and
two, three or four in flight), 16384x16384x22, 2048x2048x2047 and
1152x1152x2048 are now correct; heavy 1080p fill and geometry rows at
depth 8 still run on both pairs, at the same time per submit as before
(38.2 and 36.9 us) and 7-10% faster than on one pair.

KUnit covers the decision and the admission routing: renders that run on
one pair stay on the same pair up to its depth and never move to the
other, and a new queue whose renders need one pair claims no sibling.

Other G17 parts, which hold one pair per queue, are unchanged.

Fixes: b1c9a21 ("drm/asahi: g17: restore two render pairs per queue on G17D within the shared QID capacity, 9-15% faster heavy 1080p rows at depth 8")
Suggested-by: Ryan Murray <ryan@aurorasilicon.org>
Signed-off-by: Jeff Queisser <funkzy@users.noreply.github.com>
@funkzy
funkzy force-pushed the pr/m5-render-pair-memory branch from daa0d08 to 5d6427e Compare November 21, 2026 19:14
@funkzy

funkzy commented Nov 21, 2026

Copy link
Copy Markdown
Contributor Author

Thanks, Ryan. Both nits are fixed in the commits, now at 5d6427e, with no change in behaviour:

  1. Discard size named once. fw::m5::pool::DISCARD_BYTES is the discard object's size, and both the window bound (pair_fixed_bytes) and the pair that allocates it (Compact::new) use it. First commit; its message says so.
  2. Pair window computed once. SUBMIT computes the pair window bytes once, in prepare_command, and keeps them on the validated render command. render_pairs() reads them from the packet instead of deriving the layout again. Third commit.

I've added your Suggested-by to both. git range-diff against the current head: the first and third commits change only in those lines and their messages; the second is unchanged.

J775D on this head (stacked with #1973 and our other three open drm/asahi PRs on integration/aurora cc14570, 27.0 firmware, default command line; the kernel also carries a local fix for an appledrm boot oops, see #1973):

  • 16384x16384x22 and 512x512x2048 (also two in flight): correct readback in all four corners.
  • 16384x16384x54, and x23 with more than four primitives: SUBMIT returns ENOMEM, and the same client then renders and dispatches correctly, with no lost device.
  • fdinfo grows during each pass (8201 MiB at 16384x16384x22, 2984 MiB at 512x512x2048, image included), and the device's committed memory is back to its starting value within seconds of the client's exit.
  • Render CTS subset: 571 Pass, 57 NotSupported, the same as without the series.
  • KUnit: 366 of 368 pass (two skips, as on the base), including the pair-window and pair-count suites. Host tests: 427 of 427 on base and head.
  • Regression: 0 new failed units (iwd.service and systemd-networkd-persistent-storage.service fail on the read-only test root with and without the series) and 0 new kernel error lines apart from the intended ENOMEM refusals. ALARM has no SELinux, so there is no AVC count.

Rows we can't run: could your lab, or an owner of an M5, M5 Pro or M5 Max, run this head? These take the first two commits (the third only matters where a queue holds two pairs). The useful row is the same cases: 16384x16384x22 and 512x512x2048 with correct readback, a pass over 4 GiB returning ENOMEM without a lost device, fdinfo growing and returning, the render CTS subset, 0 failed units and 0 new kernel errors.

@RyanTheTide

Copy link
Copy Markdown
Contributor

Re-review of 5d6427e: No blockers.

  1. Discard object size duplicated (nit): resolved. fw::m5::pool::DISCARD_BYTES (drivers/gpu/drm/asahi/g17/fw/m5/pool.rs:58) is used by the window bound in m5_render_submission.rs and by Compact::new in g17/queue/render/memory.rs:568.
  2. Layout derived again on every render_pairs() call (nit): resolved. prepare_command (g17/runtime/backend.rs:201-218) stores the window bytes from layout_and_window() on Validated::Render::pair_window, and render_pairs() (g17/runtime/render/submit.rs:43-49) reads them. Dropping the pairs == 1 early return is fine: pairs::for_window returns the queue count when it is 1 (pairs.rs:56-61, covered by its KUnit case), and a render without an M5 plan keeps None, which also leaves the count unchanged, as before.

The second commit is unchanged since the last review.

HW row: the new numbers are from the M5 Ultra, on an integration stack with other open PRs and a local appledrm fix. Still needed: an M5, M5 Pro or M5 Max (one queue holding one pair) on this head: 16384x16384x22 and 512x512x2048 with correct readback, a pass over 4 GiB returning ENOMEM with no lost device, fdinfo growing during the pass and returning after, the render CTS subset unchanged, 0 failed units, 0 new kernel errors apart from the intended ENOMEM line.

Assisted-by: LLM (Claude:Opus 5.5)

@DjDeveloperr DjDeveloperr left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Pre-PR checklist review (§1–§6) on live head 5d6427e7cba76199c56b2b76cce8af2ac15abf4a (host-tests: pass).

Checklist Summary

  • §1 No model gating: Pass — uses the existing M5 firmware path and architectural 32-bit compact-window size; commit 3 keys on queue pair count (queue > 1), not chip IDs.
  • §2 Production-ready, no hacks: Pass — default command line, no new params/hacks.
  • §3 Safety: Pass — no hardcoded hardware safety constants.
  • §4 Clean-room & attribution: Pass — all 3 commits (312bbde50816, aeed8c38c412, 5d6427e7cba7) carry human author/committer and human Reported-by/Suggested-by/Signed-off-by trailers only; PR body includes Assisted-by:.
  • §6 Naming: Pass — uses Borealis and Aurora naming.
  • §5 Evidence: Still needs a 1-pair-per-queue M5/M5 Pro/M5 Max row for commits 1–2 in addition to the code fixes below.

Blocking Code Findings

  1. Stale State::wide[slot] can route a >2 GiB render onto the second pair and reproduce the 26 s ENOSPC/lost-device failure (drivers/gpu/drm/asahi/g17/queue/admission.rs):

    • self.wide[slot] is only written in State::pick() when pairs == 1 (self.wide[usize::from(slot)] = owner), and is never cleared when self.owners[slot] changes or is cleared (take_idle, claim_sibling, reassign_unused_spare, cancel_empty_slot), nor are other slots cleared when a new wide slot is assigned for owner.
    • Concrete failure path on a 2-pair queue (owner O):
      1. O picks slot 1 for a 1-pair render (pairs == 1) -> wide[1] = O.
      2. Slot 1 leaves O via cancel_empty_slot(1, O) (failed/cancelled build before publication) or reassign_unused_spare(1, Some(O), ...) -> owners[1] becomes 0 or another owner, while wide[1] remains O.
      3. O's next >2 GiB render takes slot 2 -> owners[2] = O, wide[2] = O, and slot 2 builds and maps the >2 GiB target in the 4 GiB compact window.
      4. O runs a small render (pairs == 2) and claim_sibling claims slot 1 back for O. Now owners[1] == O, owners[2] == O, and both wide[1] == O and wide[2] == O.
      5. O's next >2 GiB render runs (0..cfg::RENDER_SLOTS).find(|slot| self.owners[*slot] == owner && self.wide[*slot] == owner), which returns the lowest-index slot (slot 1) instead of slot 2. Slot 1 then tries to map a second >2 GiB pair beside slot 2's live >2 GiB pair in the 4 GiB compact window -> ENOSPC -> 26 s timeout / lost device.
    • Fix: Clear self.wide[slot] = 0 whenever self.owners[slot] is reassigned or cleared (take_idle, claim_sibling, reassign_unused_spare, cancel_empty_slot), and clear any prior wide[other] == owner when recording self.wide[slot] = owner. Add a KUnit case covering slot loss + sibling reacquire with a live wide slot at a higher index.
  2. pair_window_bytes() omits task-stage mesh_storage (32 MiB default) mapped in M5_COMPACT (drivers/gpu/drm/asahi/g17/queue/render/m5_render_submission.rs):

    • For any render pass using a task shader (programs.uses_task()), Memory::mesh_storage_register() (drivers/gpu/drm/asahi/g17/queue/render/memory.rs:672-685) maps m5_mesh_storage_chunks * 64 KiB (default 0x200 chunks = 32 MiB, plus 16 KiB guard rounded to 64 KiB alignment) into BlockGeometry::M5_COMPACT via Compact::new_aligned().
    • pair_window_bytes() does not account for this reservation when resources.as_deref().is_some_and(|p| p.uses_task()) and m5_mesh_storage_chunks > 0. As a result, a task-shader pass whose pair fits in (4 GiB - 32 MiB, 4 GiB] passes SUBMIT instead of failing with ENOMEM, and a pass in (2 GiB - 32 MiB, 2 GiB] gets for_window() == 2 even though two pairs plus mesh storage exceed the 4 GiB compact window.
    • Fix: Include the aligned mesh_storage compact-window reservation (when uses_task() and m5_mesh_storage_chunks != 0, using a shared helper/constant with Memory::mesh_storage_register) in pair_window_bytes() and add a KUnit check.

Verified Non-Blocking Items

  • KernelObject::client_backing() (g17/object.rs) properly orders fields (mapping, obj, ptr, size, charge) so GPU unmap and GEM teardown precede releasing the client charge, and RAII Commit rolls back admission on allocation failure.
  • Object::new (buffer/target.rs) and Tvb::allocate (buffer.rs) both pre-check compact-window room (check_m5_room) before allocating and cover both initial creation and growth (Target::ensure_capacity / Tvb::grow).
  • DISCARD_BYTES deduplication and SUBMIT-time Validated::Render::pair_window caching are clean.

Also Needed Before Merge (§5)

  • After fixing the two code issues above, re-prove on J775D and obtain a 1-pair-per-queue M5 / M5 Pro / M5 Max row on the updated head covering commits 1–2 (16384x16384x22, 512x512x2048 readback, over-4 GiB ENOMEM with no lost device, fdinfo growth/release, render CTS subset, 0 failed units, 0 new kernel errors beyond the intended ENOMEM).

Assisted-by: LLM (Gemini 4 Neon)

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.

3 participants