Skip to content

fix(dash): initialise ADLX once on a resident thread - #1020

Merged
r0x0r merged 2 commits into
ROCm:mainfrom
r0x0r:fix/dash-adlx-resident-reader
Nov 12, 2026
Merged

r0x0r merged 2 commits into
ROCm:mainfrom
r0x0r:fix/dash-adlx-resident-reader

Conversation

@r0x0r

@r0x0r r0x0r commented Nov 10, 2026

Copy link
Copy Markdown
Collaborator

Problem

On Windows, rocm dash exits silently after about a minute. No panic message, no
backtrace, nothing in ~/.rocm/logs/. The exit code is 0xC0000409.

Windows Error Reporting names atiadlxx.dll as the faulting module, and under WinDbg the
crash is FAST_FAIL_FATAL_APP_EXIT — the AMD driver calling abort(). That bypasses
Rust's panic hook entirely, which is why nothing is printed and the terminal is left
unrestored.

The dashboard's in-process Windows collector initialised and terminated ADLX on every 1 s
metrics tick, each time on a different blocking-pool thread. That loads and unloads
amdadlx64.dll (and the d3d9, OPENGL32 and dbghelp it pulls in) over and over while
the driver's atiadlxx.dll stays resident. ADLX is meant to be initialised once per
process; after enough cycles the driver aborts.

What changed

ADLX is initialised once, on a dedicated adlx-reader thread that holds the helper for the
process lifetime and answers read requests over a channel. adlx_readings() sends a request
instead of initialising.

The reader answers with a Result, so a caller can tell an absent driver from a reader that
failed:

  • A failed init answers with no readings and no warning — that is what a machine with no AMD
    GPU looks like, and it is expected.
  • A read that panics is caught, surfaced as a warning, and leaves the reader usable.
  • A reader whose thread is gone is reported too.

That split matters because the reader is built once per process and never replaced: without
it, a single failure would blank temperature, power and clock for the rest of the session
and be indistinguishable from having no driver at all.

run_single_flight and the 5 s ADLX_TIMEOUT are unchanged.

How it was checked

init and read are injectable, so the once-only and same-thread contract is unit-tested
on every platform: init runs once across many reads, a failed init degrades without
retrying, a panicking read is reported while the reader survives, a dead reader is reported
rather than answering empty, and each fault warns in words that name ADLX and tell the
faults apart.

Mutation evidence — each check was shown to fail against a deliberately broken input:

Broken input Check that went red
init() moved inside the request loop once-only and same-thread tests (25 inits, not 1)
catch_unwind removed from the read step panicking-read test (ThreadGone, not ReadPanicked)
read() made to swallow the fault dead-reader test

On the reported hardware, a debug build of rocm dash died after 46 s with 0xC0000409;
the fixed build ran 241 s with no crash and no new Application Error event before being
stopped by hand.

Not verified. 241 s is about 5× the previous time-to-crash and is not proof — the
30-minute long-run check added to docs/manual-testing.md is the real one, and it has not
been run. The crash was never reproduced outside the dashboard: standalone harnesses
re-initialising ADLX every 100 ms for two minutes did not trigger it, so the per-tick
init/terminate cycle is the leading cause rather than a proven sole trigger. Evidence comes
from one machine and one driver version (31.0.21925.1001); whether other Adrenalin versions
abort the same way is unknown.

Platform-gated path, per AGENTS.md §3. init_adlx, read_adlx and the OnceLock
wiring in adlx_readings() are cfg(windows), so they compile on no developer machine
without Windows and in no default CI lane. They are covered by inspection only; the unit
tests above cover the shared logic, and windows-build-and-test is the first thing that
actually compiles them.

No Gherkin scenario: an internal crash fix with no change to command output or exit codes.

Scope

  • A wedged driver call strands two threads rather than one: the blocking-pool thread waiting
    on the channel, and the single resident reader. run_single_flight still refuses to start
    another call while one is outstanding, so that is bounded at one in-flight request rather
    than one per tick. ResidentReader::read() deliberately carries no deadline of its own,
    keeping the existing single-flight answer to AGENTS.md §6 rather than queueing a request
    per tick behind a wedged reader.
  • The process holds one extra OS thread for its lifetime on Windows once the dashboard runs,
    including on hosts with no AMD driver. ADLXTerminate is never called — Rust does not
    drop statics, so the helper is released by process teardown.

Not in this PR

  • A native fail-fast bypasses the panic hook, so any driver abort is silent. A
    SetUnhandledExceptionFilter or minidump writer recording the fault module and offset
    would make the next one diagnosable.
  • Running ADLX out of process would contain a driver abort rather than only reducing its
    likelihood. Worth doing if the crash recurs.

  • If this PR fixes a bug, searched tests/e2e-cucumber/expectations.toml for the fixed ticket ID and removed/narrowed any now-stale xfail rows. — no xfail row references this crash; nothing to narrow.
  • If this PR adds a new subcommand or subsystem, its domain implementation lives in its own file per docs/architecture.md. — n/a, no new subcommand or subsystem.
  • If this PR adds, renames or removes a production source file, docs/architecture.md has the matching entry. — n/a, no file added, renamed or removed.
  • Every new or changed user-facing message was read against the code path that runs after it, and its test asserts the resulting state — not only the wording — per AGENTS.md §3. — two new warnings (ADLX read panicked, the ADLX reader thread is gone). snapshot pairs each with no readings, so the state is "ADLX columns blank, with a reason"; an absent driver stays warning-free. Covered by the fault-warning test plus the two reader-fault tests that pin which fault is reported.

On Windows the dashboard's in-process collector initialised and
terminated ADLX on every 1s tick, on a different blocking-pool thread
each time. That loaded and unloaded amdadlx64.dll (and the d3d9, OPENGL32
and dbghelp it pulls in) repeatedly while the driver's atiadlxx.dll stayed
resident. After a while atiadlxx.dll fail-fasts (0xC0000409,
FAST_FAIL_FATAL_APP_EXIT), which kills rocm dash with no panic message or
stack trace.

Initialise ADLX once on a dedicated reader thread that keeps the helper
for the process lifetime and answers read requests over a channel. Init
is attempted once per process. The init and read steps are injectable so
the once-only and same-thread contract is unit-tested on every platform.

The reader answers with a Result, so a caller can tell an absent driver
from a reader that failed. A failed init answers with no readings and no
warning, as before, since that is what a machine with no AMD GPU looks
like. A read that panics is caught, reported as a warning and leaves the
reader usable; a reader whose thread is gone is reported too. Without
that split, one failure would blank temperature, power and clock for the
rest of the session and be indistinguishable from having no driver —
the reader is built once per process and never replaced.

The crash was not reproduced outside the dashboard, so the per-tick
init/terminate cycle is the leading cause rather than a proven one. The
manual-testing checklist gains a 30 minute long-run check for it.

Signed-off-by: Roman Sirokov <roman.sirokov@amd.com>
@r0x0r
r0x0r force-pushed the fix/dash-adlx-resident-reader branch from d4e1868 to 1a5329d Compare November 11, 2026 07:04
@r0x0r
r0x0r marked this pull request as ready for review November 11, 2026 10:50
@r0x0r
r0x0r requested a review from a team as a code owner November 11, 2026 10:50
@r0x0r
r0x0r requested a review from jussielo-amd November 11, 2026 10:50

@juhovainio juhovainio left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

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

I read the diff and found nothing blocking. Moving ADLX init onto one resident thread matches the stated cause (per-tick init/terminate), and the FFI stays off the async workers. This reflects a diff-only read plus green CI, not a runtime check.

Non-blocking points, mostly left inline:

  • An init failure is dropped via .ok() and never retried, so a transient startup failure blanks temp/power/clock for the whole session with no log line. Logging it would make that diagnosable.
  • init() runs outside catch_unwind, while read panics are caught. An init panic kills the reader and every later tick warns ThreadGone.
  • The spawn-failure path has no test, and the "degrades to no readings" comment is stale: it actually yields Err(ThreadGone) and a warning.
  • snapshot's new Done(Err(gone)) arm has no direct test.
  • A caught read panic still runs the process-wide panic hook. Worth checking that the dash's hook doesn't disturb the terminal.
  • The Windows-only paths are covered only by CI compiling them, and the 30-minute soak hasn't been run. The PR says both honestly, and the cause is described as the leading one, not proven.

// `state` is deliberately held until the request channel closes
// (never, for the process-wide reader) so it is not torn down
// and re-initialised between ticks.
let state = init();

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

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

init() runs outside catch_unwind, so a panic here kills the reader and every later tick warns ThreadGone. Consider wrapping it, and logging the init failure (init_adlx drops the Err via .ok()) so a silent blank is diagnosable.

#[cfg(windows)]
fn adlx_readings() -> Vec<AdlxReading> {
fn adlx_readings() -> ReaderAnswer {
static READER: std::sync::OnceLock<ResidentReader> = std::sync::OnceLock::new();

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

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

Init is never retried, so a transient first-tick failure blanks ADLX metrics for the whole session with no warning. It's a documented trade-off; at least log the init error.

/// Not gated: `snapshot` matches on it and the non-Windows `adlx_readings`
/// stub returns it, on every platform.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ReaderGone {

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

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

ReadPanicked isn't "gone" (the reader survives), so the name and doc are slightly misleading; ReaderFault might fit better. Also worth checking that a caught panic doesn't trip a terminal-restoring panic hook in the dash.

@nowycondro nowycondro left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

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

🤖 Automated review · review-code · head 1a5329d492

This automation never files a GitHub approval, so no approving review will appear here whatever the outcome — the merge decision stays with a human reviewer.

Review — no blocking findings

Full review of the whole change.
No ticket named in the PR description or title; the change is scoped and described on its own terms (a Windows ADLX crash fix), not against an external tracker item.

Blocking

None

Non-blocking

  • A panic during init() is not caught, unlike a panic during read() — crates/rocm-dash-collectors/src/winperf.rs:482 (let state = init();) runs outside the catch_unwind that wraps the per-request read(state) call at winperf.rs:490. If init_adlx() (e.g. adlx::helper::AdlxHelper::new()) ever panics rather than returning Err, the adlx-reader thread unwinds before entering its request loop, inbox drops, and every later ResidentReader::read() call (winperf.rs:511) permanently answers Err(ReaderGone::ThreadGone) for the rest of the process. Before this change, each tick created a fresh AdlxHelper, so a one-off init panic would simply be retried, and likely succeed, on the next tick. The new resident-thread design trades that self-healing property away for exactly the init step the comment at winperf.rs:482-485 says must not be re-run — the asymmetry is real even though init_adlx()'s only fallible call already returns Result rather than panicking in the documented case.
    Confidence 75 · architectural · Fix: wrap init() in the same catch_unwind as read(), mapping a caught panic to Err(ReaderGone::ThreadGone) (or a new variant) before entering the loop, so an init panic degrades the same way a read panic does.
  • The new SingleFlight::Done(Err(gone)) arm in snapshot() has no direct test — winperf.rs:101 (SingleFlight::Done(Err(gone)) => (Vec::new(), Some(gone.warning()))) is new behaviour this diff introduces (the prior Done arm only ever carried Vec<AdlxReading>, never a Result). No test in the file calls WinPerfCollector::snapshot() or adlx_readings() directly (confirmed: neither symbol appears anywhere under #[cfg(test)]), so this exact wiring — "a reader fault turns into no readings plus gone.warning() in the warnings list" — is unverified by anything that runs in CI. The components it wires together are each tested in isolation (ResidentReader's Err paths, ReaderGone::warning()), and snapshot()'s hardcoded call to Self::run_script() makes mocking the whole function impractical the same way adlx_readings()'s own FFI chain is documented as untestable at winperf.rs:1183 — but that precedent is never stated for this specific arm.
    Confidence 70 · logic · Fix: either extend parse_metrics's existing "take ADLX readings as a parameter" testability pattern to this match (e.g. a small pure helper taking a ReaderAnswer and returning (Vec<AdlxReading>, Option<String>)), or add a one-line comment next to the Done(Err(gone)) arm pointing at the same impracticality argument already made for adlx_readings().

Decisions for the author

  • ResidentReader::read() deliberately carries no deadline of its own — tradeoff
    AGENTS.md §6's subprocess/FFI checklist says a blocking FFI call wrapped only by an outer timeout() still leaks its thread, and to "give the blocking call its own deadline or cancellation flag instead." This PR's read() (winperf.rs:511) has none, relying solely on run_single_flight's outer ADLX_TIMEOUT plus the single-flight gate — the same reasoning the pre-existing ADLX_TIMEOUT doc comment already used. The PR body's "Scope" section names this explicitly and ties it to AGENTS.md §6 by number, arguing ADLX's FFI has no cancellation primitive a deadline could act on. That argument holds for this driver, but it is worth the author confirming out loud that the general rule is knowingly not followed here rather than overlooked, since the next engineer touching FFI code in this crate may cite this file as precedent without re-deriving the exception.
  • A single truly-wedged read now strands two threads instead of one, for the rest of the session — tradeoff
    Pre-PR, a wedged adlx_readings() call leaked one blocking-pool thread and left ADLX_IN_FLIGHT permanently set, so every later tick also got StillRunning with no new attempt — the same terminal "no more ADLX readings this session" end-state as today. Post-PR the dedicated adlx-reader thread is also stuck mid-read, so every future tick's blocking-pool thread blocks on answer.recv() forever too, and the one extra OS thread is now held for the process's whole lifetime even on hosts with no AMD driver. The end state for the user is unchanged (no more temp/power/clock either way), but the resource shape is different and already disclosed candidly in the PR's "Scope" section — flagging here only so the tradeoff is a confirmed decision rather than a side effect nobody weighed.

Positive signals

  • ResidentReader::spawn takes init/read as injectable closures specifically so the "built once, same thread for every read" contract is unit-testable without Windows or a driver — the same testability pattern parse_metrics already uses for ADLX readings, applied consistently to the new abstraction.
  • The new tests are mutation-grade, not just happy-path: resident_reader_initialises_once_and_reads_on_one_thread encodes which thread a read ran on into the returned value itself, so it fails (not just passes vacuously) if init() is ever moved inside the per-request loop — verified by tracing the code, matching the PR's own stated mutation table.
  • The PR description is unusually honest about the limits of its own evidence ("Not verified" section: the crash was never reproduced outside the dashboard, evidence comes from one machine and one driver version) rather than overclaiming a proven root cause.

Deployment notes

This adds one dedicated, permanent OS thread (adlx-reader) for the lifetime of the rocm dash process on Windows, created lazily on the first metrics tick — present even on hosts with no AMD driver or ADLX at all. ADLXTerminate/DLL unload is intentionally never called on this path; the PR explicitly relies on process teardown to release it.

What this covered

Single-context pass over the whole change (crates/rocm-dash-collectors/src/winperf.rs and docs/manual-testing.md, merge-base eb2a8194a2aa4323904b01ab15a573c5b9cb0fa3…head 1a5329d4925eb84528ad776cad91c5a2f41442f4), read completely at both the merge-base and PR-head blobs via git show (not the working tree, to avoid any interference from other processes sharing the clone). This is a deliberate choice given the diff's size (one source file plus a short doc addition), not a degraded or failed fan-out. Also read: AGENTS.md in full; git log/git show history for winperf.rs back through the commit that introduced ADLX support (#715) and the one intermediate touch (#812); the PR description and its single commit message; and live CI status via gh pr view --json statusCheckRollup (every required check green, including windows-build-and-test, clippy, and the dash-crate coverage ratchet).

Did not run: no cargo/rustc toolchain is available in this sandbox, so cargo test, cargo clippy, and the author's own mutation checks could not be executed directly here — findings and the "tests are mutation-grade" positive signal are based on tracing the logic by hand against the code, cross-checked against the green CI results and the author's own stated mutation-evidence table, not an independent run. Impact-analysis searches (consumers, docs, fixtures) were done by direct grep rather than a separate worker pass, given the narrow blast radius (two files, no changed public signatures). Not reconciled against the existing human review thread already on this PR (a separate APPROVED review is present) — this review was produced blind to it, per method.

@jussielo-amd jussielo-amd left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

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

Nothing blocking. Moving ADLX init onto one resident thread matches the stated cause, the helper is built and used on that one thread (only a Sender is shared), and CI on this head is green. This was a static review: no tests were run (no Rust toolchain here), and the cfg(windows) paths and the 30-minute soak are only as verified as the PR says.

Non-blocking (some overlap with the existing threads):

  • crates/rocm-dash-collectors/src/winperf.rs:~482: init() runs outside catch_unwind, so an init panic kills the reader and every later tick warns that the reader thread is gone. Wrapping it like read() keeps the two failure paths alike.
  • init_adlx drops the init error via .ok() and init is never retried. A missing driver is fine to treat as silent, but a transient ADLXInitialize failure with the driver present then blanks temperature, power and clock for the session with no trace, the case the ReaderGone comment says must not be silent. At least a tracing::warn! with the error, or separating "DLL absent" from "init failed".
  • AGENTS.md section 6 (FFI) asks for the blocking call's own deadline; ResidentReader::read() waits on answer.recv() with none. The PR says single-flight is the section 6 answer, which reads as compliance. Either use recv_timeout (as device_readable_within_budget in rocm-core/src/amd_smi.rs does) or state in the code that this is a reviewed exception.
  • The new warnings ("the ADLX reader thread is gone", "ADLX read panicked", and the older "ADLX reading task panicked") use internal wording and give no effect or next step; one phrasing per cause such as "ADLX unavailable: temperature, power and clock hidden; restart rocm dash" would read better in the dash badge. ReaderGone::ReadPanicked also isn't "gone".
  • Stale comments and a test gap: the spawn-failure comment (~500) says reads "degrade to no readings" but they now return ThreadGone; the test-module comment (~1183) says adlx_readings() is not unit-testable although the shared logic now is; and the Done(Err(gone)) arm of snapshot has no test asserting the resulting state (AGENTS.md section 3), only the wording.

🤖 by agenthub on AMD AgentHub

@r0x0r
r0x0r added this pull request to the merge queue Nov 12, 2026
@github-merge-queue
github-merge-queue Bot removed this pull request from the merge queue due to failed status checks Nov 12, 2026
@r0x0r
r0x0r added this pull request to the merge queue Nov 12, 2026
@r0x0r
r0x0r removed this pull request from the merge queue due to a manual request Nov 12, 2026
Review follow-ups on the resident ADLX reader. Both findings were real.

`read` was wrapped in `catch_unwind` and `init` was not, and the asymmetry
mattered more on the init side. A panic escaping `init` unwound the reader
thread before its request loop started, so `inbox` dropped and every later
tick answered `ThreadGone` — the one verdict that cannot be told apart from
"the thread never started", for a cause that is neither. Because the reader
is built once per process, that verdict was permanent, where the previous
per-tick design would simply have retried init on the next tick.

Init is now caught the same way, with its own `InitPanicked` variant rather
than being folded into `ThreadGone`: the two are different faults and the
remedy differs. This does not restore per-tick retrying — that is the trade
this design makes deliberately — but it keeps the thread answering and
names the real cause. Verified by mutation: dropping the `catch_unwind`
turns the new test red with the reader thread unwinding, which is the
reported defect exactly.

The `SingleFlight::Done(Err(_))` arm added by this PR was the one piece of
new wiring nothing executed: `snapshot` calls `run_script()`
unconditionally, so no test can drive it. The match is pure and total, so
it is now `adlx_outcome`, tested over every arm — including the one that
must stay silent, since an absent driver is an expected state and not a
fault to warn about. Mutation-checked by making the fault arm silent.

Signed-off-by: Roman Sirokov <roman.sirokov@amd.com>
@r0x0r

r0x0r commented Nov 12, 2026

Copy link
Copy Markdown
Collaborator Author

Both non-blocking findings fixed — a3bbda02e; the two decisions confirmed below

@nowycondro — no blocking findings, but both non-blocking items were real and both are now fixed rather than waved through.

1. init() was not caught, unlike read()

Correct, and the asymmetry mattered more on the init side than the confidence rating suggests. A panic escaping init unwound the reader thread before the request loop started, so inbox dropped and every later tick answered ThreadGone — the one verdict that is indistinguishable from "the thread never started", for a cause that is neither. And because the reader is built once per process, that verdict was permanent, where the pre-PR per-tick design would simply have retried init on the next tick. You identified exactly the property this design traded away.

Init now goes through the same catch_unwind. I gave it its own ReaderGone::InitPanicked rather than mapping to ThreadGone, because they are different faults with different remedies: a read panic is per-tick and the next read may succeed, while an init panic is terminal for the process.

To be explicit about what this does not do: it does not restore per-tick init retrying. That remains the deliberate trade of the resident-reader design. What it fixes is that the failure is now named and the thread keeps answering, instead of the reader silently becoming a closed channel.

Mutation-checked: dropping the catch_unwind turns a_panicking_init_is_named_and_leaves_the_reader_answering red, with thread 'adlx-reader' panicked in the output — i.e. it reproduces the exact defect you described, not merely a changed string.

2. The Done(Err(gone)) arm had no direct test

Also correct — and your diagnosis of why was right: snapshot() calls Self::run_script() unconditionally, so nothing can drive it. I took the first of your two suggested fixes rather than the comment-only one, since the match is pure and total and extracting it costs nothing: it is now adlx_outcome(SingleFlight<ReaderAnswer>) -> (Vec<AdlxReading>, Option<String>).

The new test covers every arm, including the one that must stay silent: an absent or failed-to-initialise driver answers Ok with no readings and raises no warning, because "no AMD GPU" is an expected state rather than a fault. Mutation-checked by making the fault arm silent, which turns it red.

Decision 1 — read() carries no deadline of its own (AGENTS.md §6)

Confirming out loud, as you asked, so the next person does not have to re-derive it: the general rule is knowingly not followed here, not overlooked. §6 says to give a blocking FFI call its own deadline or cancellation flag rather than relying on an outer timeout(). ADLX's FFI exposes no cancellation primitive for an in-flight query, so a deadline on read() could only stop waiting — which is precisely what the outer ADLX_TIMEOUT already does. Adding one would move the same wait, not bound the call.

What actually bounds the damage is the single-flight gate: run_single_flight refuses to start a second call while one is outstanding, so a wedged driver costs one outstanding request rather than one per tick. If someone later cites this file as precedent for skipping §6, the thing to check is whether their FFI has a cancellation primitive — if it does, §6 applies and this exception does not.

Decision 2 — a wedged read now strands two threads instead of one

Confirmed as weighed, not a side effect. Your read of the end state is right: pre-PR a wedged call leaked one blocking-pool thread and left ADLX_IN_FLIGHT permanently set, so the user already got "no more ADLX readings this session". Post-PR that is unchanged for the user; what differs is that the dedicated adlx-reader thread is also stuck, and every later tick's blocking-pool thread blocks on answer.recv().

The one extra OS thread for the process lifetime, even on hosts with no AMD driver, is the deployment cost of making init happen once — which is the crash this PR exists to fix. I judged a permanent thread cheaper than a permanent crash. Disclosed in the PR body's Scope section, and now confirmed here rather than left implicit.

Verification

Linux devbox (this Mac cannot build the workspace): cargo clippy --workspace --all-targets -- -D warnings, cargo clippy -p e2e-cucumber --test e2e -- -D warnings, cargo fmt --all --check, cargo test -p rocm-dash-collectors (147 passed), cargo test -p e2e-cucumber --test feature_naming, cargo xtask check-crate-edges / check-module-size / check-architecture-doc — all clean.

Unverified, as before: none of this runs the real ADLX path. These tests drive the injected init/read closures, which is the whole reason ResidentReader::spawn takes them; the FFI itself still has no coverage on any platform, and the original crash is still only evidenced from one machine and one driver version, as the PR body says.

This push restarts CI and dismisses the two approvals — sorry for the churn; I judged the init-panic hole worth re-approving for.

@r0x0r

r0x0r commented Nov 12, 2026

Copy link
Copy Markdown
Collaborator Author

Correction to the last line of my previous comment: the push did not dismiss the approvals — this repo does not dismiss stale reviews on push, so #1020 still reads APPROVED at a3bbda02e. Only CI is re-running. Apologies for the inaccurate warning; flagging it rather than leaving a wrong statement in the thread.

That does mean the two approvals now stand on a commit the approvers have not seen. The delta is small and self-contained (one file: catch init panics behind a new InitPanicked variant, extract adlx_outcome and test it), but it is a real change to the reader's failure behaviour, so a re-look is welcome if either of you wants one.

@r0x0r
r0x0r added this pull request to the merge queue Nov 12, 2026
Merged via the queue into ROCm:main with commit c95da05 Nov 12, 2026
47 checks passed
@r0x0r
r0x0r deleted the fix/dash-adlx-resident-reader branch November 12, 2026 09:42
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