Repository navigation
R1: no in-game route to HIP; GPU identity from the driver; other cards use the front end's upscaler - #225
Merged
Conversation
phantoslayer21
marked this pull request as draft
November 15, 2026 01:56
phantoslayer21
force-pushed
the
r1/non-rdna4
branch
2 times, most recently
from
November 15, 2026 18:13
4dc2e6f to
f08ce3c
Compare
…om the driver Executor choice (executor_select.h, backend.cpp): "auto" on an adapter that is not an RDNA 4 Radeon RX 9000-series card, or one that cannot be identified, no longer tries the HIP executor (its kernels are RX 9000-only and the attempt only failed at kernel load): the context is not created, one warning line says "WrongGPU's models need an RX 9000-series GPU; using AMD FSR (adapter ...)", and the front end's own upscaler takes the game. The same for every model. RDNA 4 auto is unchanged (models M, L, K on the D3D12 executor); explicit executor=hip stays a loud diagnostic; the sparkle guard (M, L) and the frame capture choose HIP with a warning line. GPU identity (rdna4.h, new rdna4_win.h, device_d3d12.cpp): the adapter is identified from the system's own dxgi.dll (loaded by its full path, not the proxy a game folder may hold under that name) and from the kernel-mode driver's vendor and device id, never from the description OptiScaler's GPU spoofing can rewrite. A real RX 9000 keeps WrongGPU under any displayed name; another board does not become one. The native D3D12 device uses the same rule, so a spoofed name no longer makes it refuse a real RX 9000. Launcher: the toolbar's GPU line and the first-run check say the same sentence on other cards (GpuRuntimeLine, NeedsRx9000Sentence in wg_core, with tests); the old "HIP" and "Not supported" words are gone. Tests: test_executor_select.cpp (non-RDNA-4, unidentified, spoofed name on a real RX 9000 id, real non-RDNA-4 id, RDNA 4 auto unchanged, warning levels), wg_core_tests.cpp (the launcher line). Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
…for any model; RR uses it too (REVIEW-225) Identity (rdna4.h, rdna4_win.h): an adapter is RDNA 4 when the kernel-mode driver's vendor and device id for the game device's LUID say so, and for no other reason. The description never accepts or rejects (not even "KMT failed but the name says RX 9070"); ids that cannot be read, or are not RDNA 4's, are refused with the one line, which carries the description and the ids so that a board missing from the id list shows in a log. The lookup takes its two sources as functions (AdapterSources), so the CPU tests cover several adapters with the game's LUID selecting one, a spoofed name on an RX 9000 id, a supported-looking name on another id, and a failing driver query or DXGI. The AMD AGS library is not part of this project's build (the "AGS" in the repository is the WMMA intrinsic channel of the shaders), so the id list is the only source; it is noted in the pull request. Executor choice (executor_select.h, backend.cpp): a D3D12 refusal at create (driver probe, device preparation, network init) is the front end's fallback for every model, one line, never the HIP executor; the sparkle guard is turned off for every model with one line and the model stays on D3D12; HIP only with an explicit executor=hip or the frame capture, both loud. hip_switch=on for models M and L (an explicit ini option) is unchanged. RR (rr_runtime.cpp): set-device identifies the game device's adapter by the same ids before anything is created and refuses an unknown or unsupported one with the shared sentence; its other adapter checks use the same rule. Launcher: the toolbar line is worded "detected" and shows the sentence for no card and for an unidentified one too (GpuToolbarLine). Tests: clean/tests/test_executor_select.py builds and runs the selector test in the Python tests (CI) and pins the order of Context::create from the source; the GPU interop harness expects WG_TEST_EXPECT=refused instead of a HIP context. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
…in a game The 0.6.0 option hip_switch=on moved a model M or L context to the HIP executor for good. Under R1 the only HIP left is an explicit executor=hip and the frame capture, so the option is ignored for models M, L and K alike, with one log line at create. The switch code, its retired-executor bookkeeping and the policy type are gone; the selector tests and a source pin cover the three models. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
…ows HIP-only choices as not available The runtime drops output_filter=quality5|quality9 for a context on the D3D12 executor (default filter, one line, no HIP). The launcher offers Auto and Direct3D 12 only under Runs on, greys the two filters and the sparkle guard with 'Not available on the DX12 runtime yet'. Selector tests and source pins cover the filter fallback. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
…al (H2) launcher_core_tests: NeedsHipRuntime and the help texts. test_interop_d3d12: matrix case (every DLSS-style ratio x output x declared maximum x HDR/LDR gets a default-executor context and a frame; none may reach the create refusal or a HIP line); clean/k/runner/k_refusal_matrix.py drives it with a synthetic model K. ui_activate: Runs on has two segments. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
…tch=on case The matrix case reads the output with the any-format readback (the LDR output is RGBA8), recognises a HIP executor by its ready line and the switch line by its text, and with hip_switch=on in the options requires the one 'ignored' line per context. The driver takes --hip-switch-on. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
--model M|L --model-dir <folder> runs the same contexts with the files the caller names (M: model.wgcm in the folder; L: L/model.wgcm); K keeps the synthetic model. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
…the front end
Release builds ignore executor=hip and capture_dir with one logged line each
('ignored: diagnostic key, release build') and keep the context on Direct3D 12; the
two diagnostics exist only in a developer build (WG_DEV_DIAGNOSTICS, build.py
--dev-diagnostics). The library says which kind it is (wgBuildMarker) and
check_no_dev_diagnostics.py checks it. A profile.ini or wronggpu.ini that holds
executor=hip loses the key (install, repair and update log it).
A refused frame is answered WG_ERROR_UNSUPPORTED for every model and every executor
choice, also a forced executor=dx12: no bilinear substitute. A create the runtime
refuses as a hard incompatibility (WG_ERROR_UNSUPPORTED) goes to the front end's
upscaler whatever fallback_to_amd says; a create that does not finish in
create_giveup_ms (30 s) is refused and handed over instead of waiting for ever.
Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
A release build of the runtime ignores both keys (one line each) and every context stays on Direct3D 12; --diag-keys in the driver adds them. The case fails on a developer build, which runs them. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
… the device; bounded retry; remembered refusals keep their class make_payload.py runs check_no_dev_diagnostics on every embedded file and refuses the payload for a runtime that says dev-diagnostics=1 or has no marker; the checker reads zips and executables; tools/release/check_package_diagnostics.py runs it on the final package; a CI step runs the real packager on both markers. The create worker takes a COM reference on the game's D3D12 device before it starts and releases it as its last step (also after a timeout), for the FidelityFX route and the FSR 3.0 route. The retry without the split service goes through the same bounded asynchronous path as the first create. A remembered custom-slot refusal keeps its classification: a hard incompatibility hands over to the available provider on a repeat exactly as on the first create. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
…ailures; owned device reference build.py writes <library>.build.json (configuration, SHA-256 of the library). The payload packager accepts a runtime library only when its SHA-256 matches a manifest that says dev_diagnostics is false, the marker says =0 and none of the texts that exist only in the diagnostics' code is found (those texts are now compiled only into a developer build); the manifest itself is not shipped. tools/ci/check_release_runtime.py builds the runtime in release and developer configuration and checks both, with a forged marker, a stripped library and a changed library. A split retry that is still running stores no session failure and a late success clears one. The create worker's device reference is owned by an RAII object: given back when the worker finishes, when it could not be started (the create then fails, nothing throws) and on any exception before it starts. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
…manifest only when the library exists Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
…f an allocation throws) Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
…nbuffered output Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
…guration aborted on one) Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
…wing copy terminates under /Zc:lambda MSVC's /Zc:lambda (on with /permissive-, as in the CI builds) terminates the process when the copy of a lambda's capture throws, instead of unwinding. AcquireHold's lambda captured a std::function by copy, so a failed allocation while the owner is built (std::bad_alloc from copying a large callable) would have been a std::terminate in a release build. The callable is now a class whose constructor does the copy (that unwinds normally), and the test that drives a throwing copy is back: it passes in the CI configuration. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
phantoslayer21
force-pushed
the
r1/non-rdna4
branch
from
November 15, 2026 21:25
37ae27d to
00aa1e1
Compare
phantoslayer21
marked this pull request as ready for review
November 15, 2026 21:32
phantoslayer21
added a commit
that referenced
this pull request
Nov 15, 2026
Conflicts: - launcher.cpp ApplyProfile: one state-lock hold covers #224's settings (validated first, then settings.ini through the state keys), the model choice record, OptiScaler.ini's entry and #224's RR state, in that order. WriteLauncherModelChoice / GuiApplyRequest sit next to #224's FrontEndStateKeys / WithFrontEndState. - record.cpp: #224's version (model-choice.ini is WrongGPU's by its stamp, not by its name). Follow-ups for main's changes: - The model choice record is written with wgstate::WriteStamped (#224's stamp for model-choice.ini and the install's id), so an uninstall knows it as WrongGPU's; a test covers the stamp, a parse of a stamped record and a write without an install id. - A create no entry names, whose record names a model this build lacks, runs Model M, never the persisted sr_model (which an earlier session may have left on another model); test case (16). - wronggpu.ini's reader for the upgrade migration is a named callable class, not a lambda capturing the path by copy. - run_model_k_tests: since #224 the uninstall also removes the seeded, unchanged wronggpu-asi.ini, so the game folder is byte for byte as before. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
7 tasks done
phantoslayer21
added a commit
that referenced
this pull request
Nov 15, 2026
Since the payload gate (#225), a WRONGGPU_TESTING launcher built from the mock payload stopped at "Embedding the payload": the stand-in runtime had no "wg-build dev-diagnostics=0" marker and no build manifest. - The suite's prepare step (run_installer_tests.py --prepare-only) writes the stand-in runtime with the marker and a build manifest for its exact bytes that says stand_in. - make_payload.py embeds a stand-in runtime only with --testing, which CMake passes in WRONGGPU_TESTING builds; any other build refuses it at the payload step. A real payload is checked exactly as before. The release path never passes --testing or WRONGGPU_TESTING. - build-mingw.sh (the Wine runner's build) is a WRONGGPU_TESTING build; RELEASE=1 makes a release-type build that refuses the stand-in. - CI builds the testing launcher from the stand-in payload and checks that a release build with the same payload refuses it (the negative control). The packager tests cover the stand-in with and without --testing. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
7 tasks done
phantoslayer21
added a commit
that referenced
this pull request
Nov 16, 2026
… text offers HIP (#250) Three test_ui_dump checks failed on main since #225. The launcher's behaviour did not regress: the dump's probes drove controls #225 disabled or removed. - Discard from the keyboard and Space on key-up acted on Sparkle guard, which is now off and disabled (no Direct3D 12 port); a disabled switch takes no focus and no Space. Both probes now use Pre-exposure's Original. - Advanced settings opening for a saved value off its default saved Runs on as HIP, which is no longer a Runs on value (auto|dx12). The probe now saves Direct3D 12; the unsaved case changes Pre-exposure. - No launcher text offers HIP as a choice any more: the first-run check and Settings' HIP runtime row say Model M runs on Direct3D 12 without it, the note about another HIP tool says WrongGPU doesn't use HIP in a game, and the installer README lists executor as auto | dx12. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
7 tasks done
phantoslayer21
added a commit
that referenced
this pull request
Nov 16, 2026
…driver's id query is not implemented (#252) Wine and Proton answer the driver's PCI id query (D3DKMTQueryAdapterInfo type 31) with STATUS_NOT_IMPLEMENTED, so #225's RDNA 4 check refused every board there. - Only when the query returns exactly STATUS_NOT_IMPLEMENTED and the process runs under Wine (ntdll exports wine_get_version), the system DXGI's vendor and device id of the adapter with the game device's LUID stand in, against the same vendor and RDNA 4 id list. - Any other status, a query that could not be made, the same status outside Wine, or DXGI not answering: refused as before. When the driver's ids are read, they alone decide. - One log line when the fallback accepts an adapter (the executor choice and the Ray Reconstruction runtime). - Tests with injected query results, including that the Windows path never asks the fallback's sources; the test's MSVC build uses /permissive-. Fixes #248 Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com>
This was referenced Nov 16, 2026
j0nsh1n
added a commit
to j0nsh1n/wronggpu
that referenced
this pull request
Nov 17, 2026
…hantoslayer21#225's no-name-rule pin clean/tests/test_executor_select.py (CreateOrder.test_no_name_rule_left, phantoslayer21#225) requires that clean/runtime/rdna4.h contains no find( outside comments, so that no GPU name rule can come back into the identity code. The parser of the WG_DEV_GFX11_NATIVE_K list (developer builds only) used std::string::find to split at commas and broke that pin. It now walks the characters; the entries, the exact-name match and the treatment of stray commas are unchanged. Verified: test_executor_select and test_dev_gfx11_native_k (the host build of the list cases with and without WG_DEV_GFX11): 20 tests OK. With the separator changed to ';' on purpose the list cases fail ("a listed port switches", "the first and the last entry switch", "a list selects only its names"); restored, green. Signed-off-by: Jonathan Shin <85975340+j0nsh1n@users.noreply.github.com>
j0nsh1n
added a commit
to j0nsh1n/wronggpu
that referenced
this pull request
Nov 18, 2026
…hantoslayer21#225's no-name-rule pin clean/tests/test_executor_select.py (CreateOrder.test_no_name_rule_left, phantoslayer21#225) requires that clean/runtime/rdna4.h contains no find( outside comments, so that no GPU name rule can come back into the identity code. The parser of the WG_DEV_GFX11_NATIVE_K list (developer builds only) used std::string::find to split at commas and broke that pin. It now walks the characters; the entries, the exact-name match and the treatment of stray commas are unchanged. Verified: test_executor_select and test_dev_gfx11_native_k (the host build of the list cases with and without WG_DEV_GFX11): 20 tests OK. With the separator changed to ';' on purpose the list cases fail ("a listed port switches", "the first and the last entry switch", "a list selects only its names"); restored, green. Signed-off-by: Jonathan Shin <85975340+j0nsh1n@users.noreply.github.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Refs #15 (R1 of the 0.6.5 release plan: in a game every model runs on the D3D12 runtime). Based on main with the Model K runtime (#215) merged; the branch is rebased on main (20 commits, no merge commit, every commit signed off).
On a GPU that is not an RX 9000-series card, WrongGPU's networks cannot run (their kernels are built for RDNA 4 only), yet "auto" tried the HIP executor first and failed at kernel load before the front end handed the game to AMD FSR. And on an RX 9000 card several routes still led to HIP in a game. This PR sends other cards to the front end's own upscaler at once, identifies the card by the driver's PCI ids, and closes every in-game route to HIP: nothing in a game starts HIP, in any release build, whatever the game's files say.
What changes
executor_select.h,backend.cpp,build.py):executor=hip(profile,wronggpu.ini,WG_RUNTIME_OPTIONS) andcapture_dir(also together withexecutor=dx12) are developer diagnostics. A release build ignores both, with one warning line each (executor=hip ignored: diagnostic key, release build; ...,capture_dir ignored: ...), and the context stays on Direct3D 12 (withcapture_dirdropped before anything is made).WG_DEV_DIAGNOSTICS(clean/runner/build.py --dev-diagnostics). The define is off in the default build and in every CI job and release path; the runtime library says which kind it is (wgBuildMarker:wg-build dev-diagnostics=0|1),clean/tests/check_no_dev_diagnostics.py <library or folder>fails on a library that says=1, has no marker, or on a path with no library, andclean/tests/test_dev_diagnostics_off.py(in the CI Python tests) checks that the build script adds the define only on request, that no CI, release or installer file turns it on, and the checker itself. The package cannot carry it, and the gate rests on the build, not on marker bytes.build.pywrites a build manifest next to the runtime library (wronggpu_runtime.build.json: the configuration,dev_diagnostics, and the SHA-256 of the library). The payload packager (clean/installer/tools/make_payload.py) accepts a runtime library only when its SHA-256 matches a manifest that saysdev_diagnosticsis false, its marker saysdev-diagnostics=0, and none of the texts that exist only in the diagnostics' code is found in it (those texts, theexecutor=hipand frame-capture lines, are compiled only into a developer build, so a release library has none); otherwise it refuses the payload, failing closed (no manifest, a manifest of another file or another build, a library changed after its build, a stripped library, a developer build, a forged=0marker). The manifest is read for the gate and is not shipped. The checker also reads zip files and executables, andtools/release/check_package_diagnostics.py <final zip | folder | launcher exe>runs the marker and code-text checks on the final package (a path with no runtime found fails). CI builds the real runtime library in the release configuration (Model L and K on) and as a developer build (tools/ci/check_release_runtime.py, in the release-models job:build.py --runtime-only --no-embed, the C++ runtime without the GPU code objects) and checks those libraries: the release one passes the real packager; the developer one, the same with its marker forged to=0, a release library stripped of its marker, one changed after its build and one without its manifest are refused. Threat model, in one sentence: the gate stops an accidental developer build from shipping; a person who forges a library and its manifest on the build machine defeats any local check, so release provenance is the CI build and the tested record. The release script must keep each runtime's.build.jsonnext to the library it packages, and must not change the library after the build (signing or stripping after the build breaks the match and refuses the payload: regenerate throughbuild.py).hip_switch=on(it moved a model M or L context to HIP after a refused frame) is ignored for every model with one line; the switch code is removed.output_filterwins as in the runtime.backend.cpp): a frame the D3D12 executor does not take is answeredWG_ERROR_UNSUPPORTEDfor every model and every executor choice, also a forcedexecutor=dx12(it used to take a bilinear path there); the front end gives it to AMD's FSR, else the stand-in. No substitute image is made here.frontend.cpp,config.h/.cpp): a create the runtime answersWG_ERROR_UNSUPPORTED(an adapter that is not RDNA 4, a build without its D3D12 kernel set, a D3D12 executor that cannot take the context) is a hard incompatibility, not a runtime failure: the context goes to AMD's FSR whateverfallback_to_amdsays (the option keeps governing runtime failures). With no AMD provider the answer isNO_PROVIDER, explicit (documented inclean/fsr/README.md). The wait that was unbounded when nothing could upscale meanwhile (fallback_to_amd = 0, or a custom slot without an AMD DLL of its own) is bounded bycreate_giveup_ms(default 30000): on timeout the create is refused, logged, and the context goes to AMD's FSR for now (a late result takes over, as for a create that outlastscreate_wait_ms). The same bounded asynchronous path serves the retry without the split service (when the hooks cannot be installed after a successful first create), so a stalled retry hands over too. A retry that is still running when the call returns stores no session failure (a custom slot would otherwise refuse every later create of these options), and a late success clears any stored one. A remembered refusal (custom slot) keeps its classification: a hard incompatibility hands over to the available provider on a repeat exactly as on the first create, also withfallback_to_amd = 0and without a new attempt; a runtime failure stays an error. The create worker owns the device: a COM reference on the game's D3D12 device is taken on the game's thread before the worker starts and released by the worker as its last step, also after a timeout (the FidelityFX route and the FSR 3.0 route), so a late worker never meets a released device. The reference is owned by an RAII object (ScopedRelease, built before the reference is taken, so an allocation that throws leaks nothing; its callable is a named class, not a lambda, because MSVC's/Zc:lambda, which/permissive-turns on in the CI builds, terminates the process when the copy of a lambda's capture throws; tests observe the order and drive a throwing copy, which now reaches the caller as an exception): given back when the worker finishes, at once when the worker could not be started (the create then fails withWG_ERROR_DEVICE; nothing is thrown into the game's thread), and when anything between taking it and starting the worker throws.rdna4.h,rdna4_win.h,device_d3d12.cpp,backend.cpp,rr_runtime.cpp): an adapter is RDNA 4 when the kernel-mode driver's vendor and device id for the game device's LUID say so (D3DKMTQueryAdapterInfo, resolved from gdi32 at run time); the system's own DXGI is read for the log line only and a description never accepts or rejects an adapter. The id list holds every RX 9000-series id known today (7550,7551,7590,7591); an unknown AMD id gets AMD FSR and the message, with the ids in the line. No AMD AGS library in 0.6.5: TODO for 0.6.6, an AGS family check (decide on bundling the library, then add its answer as a second source throughAdapterSources; never accepting alone). The native device and the RR runtime use the same rule.executor=hipis no game setting: aprofile.iniorwronggpu.inithat holds it loses the key when it is read (executorisauto|dx12; the next Apply writeswronggpu.iniwithout it), and install, repair and update log the removal (executor=hip removed: ...). "Runs on" offers Auto and Direct3D 12 only. Quality 5 / 9 and the sparkle guard are shown greyed with "Not available on the DX12 runtime yet". The toolbar's GPU line says "detected" and gives the RX 9000 / AMD FSR sentence for another card.The hard rule, and where it is enforced
A refused D3D12 route never falls back silently to HIP or to a reference path in a release build. The selector enforces it:
choose_executorcan return the HIP executor only inside aWG_DEV_DIAGNOSTICSblock (a release library does not contain that code or its texts); a test runs it over every executor word (auto,dx12,hip, an unknown word, a reference-like word), every model, the capture and the sparkle guard, an RDNA 4 board, another board and an unidentified one, in both configurations, and finds no release choice that is HIP (the only other answers are the D3D12 executor, no context so that the front end's upscaler takes the game, and the explicit offline test executor). After the choice: a create the D3D12 executor refuses ends in one loud line and no context (the front end's upscaler), and a refused frame is answeredWG_ERROR_UNSUPPORTEDfor every model; neither builds an executor of its own, no substitute image is made (source pins intest_executor_select.py). A failure inside a network frame that has already started returns an error to the front end (it records no success); the front end's upscaler then takes the frame, with a log line.Every route from an RX 9000 card to HIP in a game, and where it stands
fallback_to_amd = 0); the matrix below proves no supported context reaches it. Remaining: the in-game overlay message (the overlay status carries no executor yet): front end, owner a8.hip_switch=on: closed. R1-b / R1-c (capture as a loud diagnostic, the selector tests' level and comments): superseded by the ignore rule; the selector tests assert the release configuration and the developer one. H8 identity: closed.Tested
test_executor_select.cpp(ROCm clang++), run byclean/tests/test_executor_select.pyin both configurations (a release build and one withWG_DEV_DIAGNOSTICS; 9 tests with the source pins) andtest_dev_diagnostics_off.py(11 tests:build.pywrites the manifest of what it built; the build flag; no CI, release or installer file turns the diagnostics on; the checker; and the real packager: a release runtime with its manifest is packaged (the manifest is not shipped); no manifest, a developer build, a diagnostics build with a forged=0marker (refused by the code-text scan and by the manifest), a stripped library, a library changed after its manifest, another library's manifest, an unreadable manifest, a second library and any other file carrying the developer runtime or its code text each refuse the payload, and nothing is written for a refused payload; the final-package check on zips, launcher executables and folders): for models M, L and K, in the developer configuration the old diagnostic routes, in the release configurationexecutor=hipandcapture_dir(alone, withexecutor=dx12, together) ignored with the right lines and the context on D3D12 (also on another board: the front end's upscaler); the sparkle guard,hip_switch, the Quality 5 / 9 fallback, the identity rule and lookup, the create-refusal line. Pins on the source ofContext::create: the ignored keys are logged andcapture_dirdropped before anything is made, a refused frame returnsWG_ERROR_UNSUPPORTEDwith no policy function and no bilinear branch,hip_switchreaches no model-specific code.test_frontend.cpp(1409 checks, 0 failures; ROCm clang++): a create answeredWG_ERROR_UNSUPPORTEDgoes to AMD's FSR withfallback_to_amdon and off (the line says the option did not apply); a runtime failure still returns the error withfallback_to_amd = 0; no AMD provider:NO_PROVIDERwith and without the fallback; a create that never finishes withfallback_to_amd = 0returns aftercreate_giveup_mswith AMD's FSR (waited for the bound, not longer than a few seconds in the test) and the late create is cleaned up on destroy. Device lifetime: with a stalled worker past the timeout (with an AMD context, and withNO_PROVIDER) and the host's device reference released meanwhile, the worker runs on a live device and gives its reference back (retains = releases); the same sequence without the hold is caught by the harness (negative control). Split retry: the first create works, the hooks cannot be installed, the second create stalls: the call returns after the bound with AMD's FSR and the first worker's reference is released while the stalled one still holds its own (both with and withoutfallback_to_amd). Pending retry stores nothing: custom slot, the retry past the wait limit then succeeding: no failure is remembered while it runs, WrongGPU takes the context over, and the next create is a real attempt that uses WrongGPU. Launch failure: a worker that cannot be started (an injected launcher that throws) is a failed create without an exception, the device reference is given back at once (retains = releases), with and withoutfallback_to_amd;ScopedReleasereleases exactly once through moves and repeated calls. Remembered refusal: custom slot, an AMD provider,fallback_to_amd = 0: anUNSUPPORTEDcreate hands over three times in a row with one real attempt; a runtime failure staysERROR_RUNTIME_ERRORon the repeats with one real attempt.cl /Zs /std:c++17, no errors and no warnings:dllmain.cpp,dll_fsr3.cpp,dll_fsr3upscaler.cpp,win_util.cpp,fsr30_hook.cpp,frontend.cpp,async_create.cpp: the device reference of the FidelityFX and FSR 3.0 create routes). CI is CPU-only and cannot run these DLL entry points; a clang syntax pass and the fake-backend tests cover the same code.launcher_core_tests(426 checks) andwg_core_tests(92 checks), built with the ROCm clang++:executor=hipinprofile.iniis removed and reported, the saved profile no longer holds it, the same for an importedwronggpu.ini(and the next Apply writes it without the key), it is not offered as a change made outside the launcher,setrefuses it,executor=dx12is still kept;NeedsHipRuntimeand the help texts. The launcher files this PR edits pass an MSVC syntax-only compile; the full launcher target is built by CI.dev-diagnostics=0;test_interop_d3d12 matrix, driverclean/k/runner/k_refusal_matrix.py, official ROCm 7.2, one GPU slot per run). Each run creates default-executor contexts for one output height (1080, 1440 or 2160) with each of the five upscaler-mode ratios (1.0, 0.667, 0.58, 0.5, 0.333), the declared maximum render size both a little above the render size and equal to the output, and HDR (RGBA16F) and LDR (RGBA8) output: 20 contexts, each given one frame. A context passes only when it logsnetwork runtime ready: executor dx12, its frame returns OK, and there is no create-refusal line and no HIP start-up line.bfbd9dad238721fb51ed60e85ceb9789ddb3468c3538efb651d09f8ca820c350), Model L (converted model file, sha256d3c040191ec7ab0164efc03ee76413277e7fb54e6e6d2b168f2c0202aa1ad806), Model K (synthetic model from random parameters): for each, 1080, 1440 and 2160: 60 contexts, 60 on D3D12, 0 create refusals.hip_switch=onleg (1080, 20 contexts per model): the onehip_switch=on is ignoredline each, still D3D12.executor=hipandcapture_dir=<folder>in the options, 1080, 20 contexts per model): each context logs bothignored: diagnostic key, release buildlines and stays on D3D12, 0 refusals (the case fails on a developer build).public_gates.py: the must-pass gates pass; the LOOK counts equal main's (leak-plain 42, leak-layout 29, numbers 143).Not tested
tools/release/check_package_diagnostics.pyon the package that is published, and keeping each library's manifest next to it, is the release step (release lead). CI has no runtime library to build, so no CI step builds the real one.rr_runtime.cpp's set-device identity check was syntax-checked and is built in the CI plugin job; no RR run with it. A real spoofed game session: the ids are read where the spoof cannot change them, but no game was run with the switch on. A GPU that is not an RX 9000: none is available here; the other-card paths are covered by the lookup and selector tests with the ids such a card gives.