Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
5ea26a6ee2 |
No files matched your search
@@ -405,7 +405,7 @@ or version, so the question is whether the declaration ever changed:
|
||||
| Hook / call | Yields |
|
||||
|---|---|
|
||||
| ~~`IDXGIAdapter3::QueryVideoMemoryInfo` (we **call** it, not hook it, once per second from our own thread)~~ | ~~**Per-process VRAM** `CurrentUsage` + `Budget` — previously impossible; now exact~~ **Never built; superseded 2026-10-03 (D43):** the game's memory is read from OUTSIDE the game by the Agent (`18_GPU_VENDOR_APIS` §The game process's memory), so nothing in the Overlay calls it. Only the budget would need it, and that stays open (`20_OPEN_QUESTIONS` §M11) |
|
||||
| NVAPI Reflex: hook `NvAPI_D3D_SetSleepMode`, `NvAPI_D3D_SetLatencyMarker`; call `NvAPI_D3D_GetLatency` | Reflex on/off + PC latency breakdown. Declarations come from the vendored MIT NVAPI headers (`18_GPU_VENDOR_APIS` §L3); the Overlay links them like any other header. NVIDIA-only — the whole block compiles out to a no-op capability flag elsewhere |
|
||||
| NVAPI Reflex: ~~hook `NvAPI_D3D_SetSleepMode`, `NvAPI_D3D_SetLatencyMarker`~~; call `NvAPI_D3D_GetLatency` *(**never built.** The two hooks cannot be: neither function is an export — `20_OPEN_QUESTIONS` §M14. What a call-only route would take is read through in `spike-notes` §30, 2026-11-12, and waits for the owner's go or no)* | Reflex on/off + PC latency breakdown. Declarations come from the vendored MIT NVAPI headers (`18_GPU_VENDOR_APIS` §L3); the Overlay links them like any other header. NVIDIA-only — the whole block compiles out to a no-op capability flag elsewhere |
|
||||
|
||||
### Explicitly not hooked
|
||||
Input APIs, file I/O, network, memory allocators, window messages beyond what the overlay needs, anything game-specific. Rule 4 in CLAUDE.md.
|
||||
|
||||
@@ -1863,7 +1863,7 @@ Moved verbatim, in this order.
|
||||
| M12 ❓ | **Advanced metrics — which NVAPI rows answer on real hardware (D101, 2026-11-11).** `18_GPU_VENDOR_APIS` §The inventory lists sixty `nvapi.` rows whose reach is `Agent`. They are declared in the vendored headers; **none has been called on a GPU**, and CI has no driver, so it never takes that branch. Unknown per row: whether the RTX 5080 on the current driver answers or returns `NVAPI_NOT_SUPPORTED` (the memory-temperature target already does not exist on that card). | **The measurement is the bridge's probe on the owner's PC**, then the page itself (the release's owner-only item). Pre-committed: a call that does not answer → that row is N/A with NVAPI's own status as the reason, and nothing is put in its place; a call that hangs or faults twice → the row is off for the session (§Runtime policy); a value that contradicts the vendor's own tool → the row is withheld until it is explained. **Half answered the same day, by the bridge's own test on the dev box** (ctest `fl_nvapi_bridge`, AVAILABLE branch; RTX 5080): every fact answers (`present = 0xFFFFF`), eight of ten live groups answer (`0x33F` — no board and no power-supply temperature sensor on this card: N/A, by the first pre-committed outcome), the display answers its four groups, the global profile lists 24 settings; figures in `18_GPU_VENDOR_APIS` §L3. **Still open**: the same values on the page beside the vendor's own tool, and the session rows (`nvapi.session.*`), which need a game. **And one thing seen once and not explained**: in one test run of about a dozen that day, `FlNvReadLive` came back with no field at all although `FlNvReadFacts`, a moment earlier in the same process, had answered everything; nine further runs did not show it. A handle the driver invalidated is the usual cause of that shape, and nothing here re-enumerates after `FlNvInit`. Pre-committed for the reader that owns the thread: two readings in a row with no field → release and initialise the bridge again, once, and say so in the log; if that does not bring the fields back the layer is off for the session, as any layer that fails twice is. |
|
||||
| M13 ❓ | **Advanced metrics — LibreHardwareMonitor's CPU, memory, motherboard and storage groups, elevated, with PawnIO (D103, 2026-11-11).** Never opened by any build: §M10's elevated run has not been taken either, and this is a larger surface — a sensor chip on the LPC bus, the embedded controller, SPD over SMBus, SMART. Unknown: whether each group opens on the owner's board, what a refresh costs, whether opening the storage group touches removable drives (this PC once had a failing USB drive), and whether any group enables a privilege (`PrivilegeFootprintTests`). | **One elevated run with the probe verb, before the option exists.** Pre-committed: the storage group cannot be opened without touching removable drives → `lhm.storage.*` stays N/A in beta.39 and its reach reads `Deferred`; a node that throws twice → skipped for the session; the Agent above 1% of one core or 150 MB with the option on (NFR-2) → the slow groups are read less often or dropped before the release; a privilege enabled by a group → that group is not opened, and the owner is asked. **Two of the four answered 2026-11-11, before the option exists.** (1) **Storage: not opened, by the first outcome.** LibreHardwareMonitor 0.9.6's `StorageGroup` lists every drive through DiskInfoToolkit's `ReloadStorages` with no filter by bus and follows drives plugged in later — it cannot be opened without touching removable drives. `lhm.storage.*` reads `Deferred`, and `LhmGroups` has no member for it. (2) **Cost, unelevated, measured with `probe-advanced`** on the dev box: one refresh of the graphics-card group alone is 14 ms of processor time (62 ms elapsed) — 1.4% of one core at one a second, above NFR-2 — and one NVAPI read 0.4 ms. By the third outcome the sensor library is read every fifth tick (0.28%). **Still open, and the owner's**: the same probe as administrator with PawnIO — whether the processor, memory and motherboard groups open on this board, what they cost, and `PrivilegeFootprintTests`' new case on a token that holds the privileges (CI's does; the dev box's unelevated run passes by construction). **The first run was taken on 2026-11-12, by the owner, in ordinary use** (0.1.0-beta.40, the Agent as administrator with PawnIO, an i7-14700KF on a board with an IT8689E chip, an RTX 5080), and read here from a copy of the ledger and the Agent's log, not from a probe. **The groups open and read**: nine of ten sessions stored 119 processor series (a clock and a load per thread, temperatures, powers, voltages), 14 memory series and 21 motherboard series (six fans, six temperatures, nine voltages) beside the card's 41 — 195 from the sensor library in all. **No value was compared with another tool**; that is still the owner's. **Two faults, one cause** (`Infrastructure.Telemetry.LhmLibrary`): the Agent held up to three `Computer`s at once, and the library keeps the driver it reads the processor through and its bus mutexes per process — closing one `Computer` let go of them under the others. After seven sessions the Advanced reader's processor device threw `NullReferenceException` twice and was left alone (the page lost the processor until the reader reopened); once a session's start met another instance's close, the reader's `Open` threw `ObjectDisposedException`, and that session stored 17 series instead of 212. **Fixed 2026-11-12**: opens and closes are serialised and a `Computer` is parked, not closed, while another is in use. The cause is read from the log's timing and was not reproduced — it needs this elevation — so **whether the faults are gone is the owner's next sessions to show**: no `advanced: a device is left alone` and no `did not open` in the Agent's log. **First evidence, 2026-11-12, 0.1.0-beta.41, the same PC:** seven sessions between 06:38 and 07:01 with no `advanced:` line at all, each with the option on storing 212 or 213 series; on beta.40 that morning the processor device faulted out after each of six sessions (04:34–05:07) — thirteen of sixteen over the night. The reader failing to open was seen once in sixteen, so this is not yet enough to call that one gone. Still open: any value beside another tool. |
|
||||
| M16 ✅ | **The L2 telemetry layer's cost — the first number, and it is above NFR-2 (found 2026-11-11, measuring something else).** `LhmTelemetrySource` refreshes LibreHardwareMonitor's graphics-card group once a second in every recorded session. `probe-advanced` measured that refresh, through the same library and the same group, at **14 ms of processor time** on the dev box (RTX 5080, 41 mapped sensors, about twenty of them the Direct3D engine nodes the library enumerates per card) — 1.4% of one core, where NFR-2 allows the whole Agent 1% during capture and `14_TESTING` §Hook overhead's Agent figure has never been measured. This is a measurement of the call, not yet of a session: L2's own poller was not instrumented. | **Measure L2 in a session** (the Agent's processor time over a ten-minute capture, telemetry at 1000 ms and at 2000 ms). Pre-committed: at or under 1% → this row closes with the number; above → the owner chooses between a slower default for `telemetry.interval_ms`, reading the sensors the layer keeps from NVAPI on NVIDIA cards (L3 already has most, at 0.4 ms), or amending NFR-2 to what is measured. Not decided here, and nothing about L2 changes in the Advanced-metrics train. **Measured in a real Agent, 2026-11-11 (owner decision D110), and answered (D117).** `tools/agent-cost.ps1` runs the shipped `FrameLedger.Agent.exe --console capture` against a copy of hook-harness in a scratch data folder — a session that is not hooked, so the telemetry poller runs as in every session and nothing drains frames — and reads the Agent process's own processor time at exit; the cost per second is the slope between a 45 s and a 165 s session, two runs of each. Dev box (RTX 5080, not elevated, layers `l1+lhm+nvapi`): **19.3 ms of processor time per second of session = 1.93 % of one core with Advanced metrics off** (2,312 and 2,312 ms over 45 s; 4,594 and 4,656 ms over 165 s), **20.4 ms = 2.04 % with it on** (2,984 and 3,000; 5,547 and 5,344); peak working set 113 MiB and 119 MiB. A first pass with 30 s and 90 s sessions gave 1.56 % and 2.21 % — its two short runs differed by 670 ms, which is why the lengths were raised. So the probe's number holds in a session: the Agent's steady cost is about twice NFR-2's 1 %, nearly all of it the layer every session has always used, and the new option adds about a tenth of a percent. **The owner's answer: NFR-2 is amended to ≤ 2.5 % of one core** — the limit had never been measured, the sensors keep their one reading a second, and nothing in the code changes. Not measured: a hooked session (the drain's cost on top), a session with the Agent elevated and PawnIO's groups open, another PC. |
|
||||
| M14 ❓ | **Reflex latency per frame — is there a route within rules 4 and 5? (Train C, 2026-11-11.)** `17_HOOK_ENGINE` §Memory / latency names hooks on `NvAPI_D3D_SetSleepMode` / `SetLatencyMarker` and a call to `NvAPI_D3D_GetLatency`. NVAPI resolves all three through `nvapi_QueryInterface` by id — they are not exports, so a hook on them is a patch at an address learned at run time, the class refused on 2026-08-09. The route to try first needs no hook: the Overlay's own background thread **calls** `GetLatency` with the device of the swap chain it already hooks, once a second (the call returns the last 64 frames' reports). Unknown: whether calling into the driver from that thread is safe on every device kind, what it costs, what it returns when the game never enabled Reflex, and what it means for the Disclaimer's sentence about that thread. | **A spike on `hook-harness` and a stub first, then one real title.** Pre-committed: no route without a patch at a run-time address or a loader-lock call on the game's thread → Reflex stays N/A and the page says why; overhead above NFR-1 → the same. The owner says go or no on the spike's result. |
|
||||
| M14 ❓ | **Reflex latency per frame — is there a route within rules 4 and 5? (Train C, 2026-11-11.)** `17_HOOK_ENGINE` §Memory / latency names hooks on `NvAPI_D3D_SetSleepMode` / `SetLatencyMarker` and a call to `NvAPI_D3D_GetLatency`. NVAPI resolves all three through `nvapi_QueryInterface` by id — they are not exports, so a hook on them is a patch at an address learned at run time, the class refused on 2026-08-09. The route to try first needs no hook: the Overlay's own background thread **calls** `GetLatency` with the device of the swap chain it already hooks, once a second (the call returns the last 64 frames' reports). Unknown: whether calling into the driver from that thread is safe on every device kind, what it costs, what it returns when the game never enabled Reflex, and what it means for the Disclaimer's sentence about that thread. | **A spike on `hook-harness` and a stub first, then one real title.** Pre-committed: no route without a patch at a run-time address or a loader-lock call on the game's thread → Reflex stays N/A and the page says why; overhead above NFR-1 → the same. The owner says go or no on the spike's result. **2026-11-12 — the reading that comes before that spike is `spike-notes` §30** (owner decision D130: a document first, beside 0.1.0-beta.45; nothing was run). It finds: a hook on NVAPI's latency functions is the refused class, and a hook on Streamline's Reflex and PCL functions is train D's wrapper (§M15) — and would miss a game that fetched them before the attach, as `slInit` is missed (D129); the Overlay calling `slReflexGetState` itself breaks the thread contract the vendor's header states; **what remains is the route named in this row**, the Overlay calling two driver getters with the game's device, and a no-injection ETW route that gives the game-side markers only and makes the game post messages to its own window. Corrected there: `nvapi64.dll` exports **two** functions on the dev box (`nvapi_Direct_GetMethod` beside `nvapi_QueryInterface`), not one. The go or no is the owner's, and a go needs the owner's ruling that calling a driver getter with the game's device is inside rule 4. |
|
||||
| M15 ❓ | **The Streamline state behind `slGetFeatureFunction` — re-examined, not reopened (Train D, 2026-11-11).** The owner asked for the refusal in `handoff/history/p0-queue-1-6.md` to be looked at again. `18_GPU_VENDOR_APIS` §The trains states the route to try (hook the export, hand back a wrapper for a fixed list of names) and what it raises: the wrapper is a write to what the game receives, which rule 4 forbids as written; a wrapper must outlive the Overlay's unhook; a game that fetched its functions before the hook existed is never seen. | **A written design against each of the five grounds, then a spike.** Pre-committed: any ground unanswered → the route stays refused, and `sl.dlssg.*`, `sl.reflex.*` and the rest of that block read N/A with "refused" as the reason. Proceeding needs the owner's amendment of rule 4, asked with the rule quoted. |
|
||||
| M10 ✅ | ~~PDH `\GPU Engine(*)\Utilization Percentage` summed across engines does not reproduce the Task Manager figure the doc invokes. Decide what we actually report and label it accordingly~~ **Decided 2026-09-09 (PR-E1): L1 does not read the engine counters at all.** `LoadPct` is L2's vendor-reported `GPU Core` load (measured ✓ on NVIDIA, §M5 row R1) and is labelled *GPU load (vendor)* wherever it is shown; on a machine without L2 the field is N/A, never a sum that is not the number the user expects. What L1 does read from PDH is one counter, `\GPU Adapter Memory(luid_…_phys_0)\Dedicated Usage`, bound by LUID — the figure Task Manager labels "Dedicated GPU memory", measured 1301 MB at an idle desktop on the RTX 5080. Reopening this needs a measurement of `max(engine)` against Task Manager's own number, not a decision |
|
||||
|
||||
|
||||
@@ -53,3 +53,4 @@ Each section below lives in its own file under `docs/spike-notes/`, moved verbat
|
||||
| §27 | Switching to Games, and a language change that lands elsewhere (2026-11-06, beta.34) | [`spike-notes/27-games-page-2026-11-06.md`](spike-notes/27-games-page-2026-11-06.md) |
|
||||
| §28 | The main line on .NET 11's release — the whole gate, and what the analyses read (2026-11-11, beta.37, D94–D96) | [`spike-notes/28-dotnet11-main.md`](spike-notes/28-dotnet11-main.md) |
|
||||
| §29 | C# 15 against the checks — the canary, and where its constructs would go (2026-11-11, beta.37, D96) | [`spike-notes/29-csharp15-canary.md`](spike-notes/29-csharp15-canary.md) |
|
||||
| §30 | Reflex latency per frame — the routes there are, and what each would cost; a reading, nothing run (2026-11-12, beside beta.45, D130; §M14) | [`spike-notes/30-reflex-latency.md`](spike-notes/30-reflex-latency.md) |
|
||||
@@ -0,0 +1,160 @@
|
||||
## 30 · Reflex latency per frame — the routes there are, and what each would cost *(2026-11-12, written beside 0.1.0-beta.45, owner decision D130; `20_OPEN_QUESTIONS` §M14)*
|
||||
|
||||
**Why this was written.** Train C of Advanced metrics is "Reflex latency per frame" (`18_GPU_VENDOR_APIS` §The
|
||||
trains). §M14 asks whether any route to it stays inside rules 4 and 5, and pre-commits the answer for the case
|
||||
that none does. The owner decided on 2026-11-12 (D130) that this spike is written beside 0.1.0-beta.45 **as a
|
||||
document**, and that no code of train C is written until the owner has read it and said go or no.
|
||||
|
||||
**What this is, and what it is not.** A reading — of the vendored NVAPI headers
|
||||
(`src/native/third_party/nvapi/nvapi.h`, `nvapi_interface.h`), of Streamline's public headers and plugin source
|
||||
at tag `v2.14.16` (`include/sl_reflex.h`, `include/sl_pcl.h`, `source/plugins/sl.reflex/reflexEntry.cpp`,
|
||||
`source/plugins/sl.pcl/pclstats.h`, `pclImpl.h`; fetched through GitHub's API, not vendored), of this
|
||||
repository's own hook engine, and of a copy of the owner's ledger; one file on the dev box was looked at, the
|
||||
export table of the installed `nvapi64.dll`. **Nothing was run in a game and no shipped code changed.** Every
|
||||
"unknown" below is unknown, not assumed either way.
|
||||
|
||||
### What Reflex's numbers are, and who holds each
|
||||
|
||||
| What | Where it lives | The catalog entry that wants it |
|
||||
|---|---|---|
|
||||
| **The per-frame report**: for each of the last 64 frames, the times of input sample, simulation start/end, render submit start/end, present start/end, driver start/end, OS render queue start/end, GPU render start/end, and two durations (`gpuActiveRenderTimeUs`, `gpuFrameTimeUs`) | The **driver**. A program gets it by calling `NvAPI_D3D_GetLatency(pDev, NV_LATENCY_RESULT_PARAMS*)` with the game's own device; Streamline's `slReflexGetState` makes that call and hands the same 64 reports back as `sl::ReflexState::frameReport` | `nvapi.reflex.frame_report`, `sl.reflex.state` |
|
||||
| **The driver's low-latency state**: low-latency mode on, the last sleep interval, whether the game calls the sleep, the frame-generation multiplier last used | The driver: `NvAPI_D3D_GetSleepStatus(pDev, …)` | `nvapi.reflex.sleep_status` |
|
||||
| **What the game asked for**: low latency or low latency with boost, the frame-rate limit, whether markers may steer the driver | Only the **arguments** of `NvAPI_D3D_SetSleepMode` or of Streamline's `slReflexSetOptions` — no getter returns boost or the limit | `nvapi.reflex.mode` |
|
||||
| **The markers the game sets** each frame (simulation start … present end, the latency ping, the flash trigger) | The arguments of `NvAPI_D3D_SetLatencyMarker` / `slPCLSetMarker`; the PCL plugin also writes each as an ETW event | `sl.pcl.markers` |
|
||||
|
||||
`FlFrameRecord.reflexLatencyUs` (@48, "0 = unavailable") has waited for this since the record was designed, and
|
||||
`03_METRICS` lists *PC latency* as "mean/p95 of `reflexLatencyUs` when Reflex reports it". **A report cannot go
|
||||
into its own frame's record**: the driver completes a frame's report after that frame's GPU work ends, several
|
||||
presents after the record was written, and a ring record is never rewritten. Whatever route is taken, latency
|
||||
arrives as a series beside the frames, not as a column of them.
|
||||
|
||||
### What the owner's sessions already say
|
||||
|
||||
From 0.1.0-beta.44's `sl.feature.versions` / `sl.feature.requirements` (sessions 181–186 of the ledger's copy;
|
||||
`docs/HANDOFF.md`, item 42):
|
||||
|
||||
| Game (session) | Interposer | Asked Streamline about `kFeatureReflex` | about `kFeaturePCL` |
|
||||
|---|---|---|---|
|
||||
| Phantom Blade Zero (181) | 2.14.1 | version and requirements | version and requirements |
|
||||
| Clair Obscur: Expedition 33 (182) | 2.7.30 | version and requirements | version and requirements |
|
||||
| Valor Mortis (183, 184) | 2.14.1 | version and requirements | version and requirements |
|
||||
| Black Myth: Wukong (185) | 2.7.4 | version and requirements | version and requirements |
|
||||
| Cyberpunk 2077 (186) | 2.14.1 | requirements only | not asked |
|
||||
|
||||
So **every Streamline game run asks about Reflex**, and the four Unreal Engine games about PCL as well. That a
|
||||
game asks about a feature is not that it uses it; 0.1.0-beta.45's `slIsFeatureLoaded` and `slSetFeatureLoaded`
|
||||
rows will say whether Reflex and PCL are loaded and switched, on the owner's next sessions. No session says
|
||||
anything about a game that uses Reflex without Streamline: none of the hooks sees NVAPI.
|
||||
|
||||
### The routes
|
||||
|
||||
**A — hook NVAPI's own functions** (`SetLatencyMarker`, `SetSleepMode`; what `17_HOOK_ENGINE` §Memory / latency
|
||||
still names). The `nvapi64.dll` on the dev box (driver 32.0.16.2114, its export table dumped for this note)
|
||||
exports two functions, `nvapi_QueryInterface` and `nvapi_Direct_GetMethod` — §M14 said one — and no latency
|
||||
function: each of those is an address `nvapi_QueryInterface` returns for an id (`nvapi_interface.h`:
|
||||
`NvAPI_D3D_GetLatency` is `0x1a587f9c`). A hook on one is a patch at an address
|
||||
learned at run time — the class refused on 2026-08-09 — or a wrapper returned from a hooked
|
||||
`nvapi_QueryInterface`, which is a write to what the game receives (rule 4). **Refused, as §M14 pre-committed.**
|
||||
|
||||
**B — hook Streamline's Reflex and PCL functions** (`slReflexSetOptions`, `slPCLSetMarker`, `slReflexGetState`).
|
||||
None is an export of `sl.interposer.dll`. The game gets each through the exported `slGetFeatureFunction(feature,
|
||||
name, &fn)`, and Streamline's own header does that **once**: `SL_FEATURE_FUN_IMPORT_STATIC` keeps the pointer in
|
||||
a function-local static after the first call. Two consequences. A hook on `slGetFeatureFunction` could only see
|
||||
the game's calls by handing back a wrapper — train D's question (§M15), which needs rule 4 amended. And a hook
|
||||
that exists only for Advanced metrics is installed after the attach (D111), by which time a game that has
|
||||
presented a frame has fetched its functions: **the same reason `slInit` is not hooked (D129) applies to the
|
||||
fetch.** Not a route for train C; it stays train D's, and this finding weakens train D as well.
|
||||
|
||||
**C — the Overlay calls `slReflexGetState` itself**, having asked the interposer's exported, documented-thread-safe
|
||||
`slGetFeatureFunction` for it. No patch, no wrapper, and Streamline uses the device it already holds. But the
|
||||
header says of `slReflexGetState`: *"This method is NOT thread safe"*, and the source shows why — the function
|
||||
**writes** two fields of the plugin's context (`lowLatencyAvailable`, `latencyReportAvailable`) from the result
|
||||
of the two driver calls it makes, with no lock, and then calls into the PCL plugin. The game calls the same
|
||||
function from a thread FrameLedger cannot know (the call is not hooked), so the Overlay cannot keep its call
|
||||
from overlapping the game's. It would be FrameLedger breaking the vendor's stated contract inside the game, and
|
||||
writing plugin state the game reads back. **Recommended refused**, on the header's own words.
|
||||
|
||||
**D — the Overlay calls the driver's two getters itself**: `NvAPI_D3D_GetLatency` and `NvAPI_D3D_GetSleepStatus`,
|
||||
resolved through `nvapi_QueryInterface` of an `nvapi64.dll` **the game already loaded** (never loaded by
|
||||
FrameLedger), with the device of the swap chain the Overlay already hooks. This is §M14's "route to try first".
|
||||
What it would be:
|
||||
|
||||
- **No patch and no new hook.** Two calls, both getters; `tools/nvapi-readonly-check.ps1`'s list (D108) would
|
||||
gain them, and the check would have to cover the Overlay as well as the bridge. The Overlay would not link
|
||||
`nvapi64.lib`: it needs the two ids and the two structs from the vendored MIT headers.
|
||||
- **It works without Streamline** — any Direct3D game that uses Reflex — and not on Vulkan (the Vulkan layer has
|
||||
no NVAPI device; Reflex there is a Vulkan extension, a different study).
|
||||
- **It gives** the report (`nvapi.reflex.frame_report`) and the sleep status (`nvapi.reflex.sleep_status`), and
|
||||
through them most of `sl.reflex.state`. **It does not give** what the game asked for (boost, the limit:
|
||||
`nvapi.reflex.mode` stays N/A, with the reason) or a count of markers.
|
||||
- **First of its kind in two ways**, and both are the owner's to rule on. The Overlay would call a *vendor's
|
||||
driver interface on its own initiative* inside the game — today it only forwards the game's calls and reads
|
||||
their arguments. And it would use *the game's device object* for a call the game did not make: rule 4 allows
|
||||
"COM/handle objects we legitimately own", and the device is the game's. The nearest precedent is the read of
|
||||
`IDXGISwapChain::GetLastPresentCount` on the hooked chain (rule 6, 2026-09-06), a getter on the game's swap
|
||||
chain inside the present detour.
|
||||
- **Unknown, and what the spike would have to measure**: which object NVAPI wants for a Direct3D 12 game (the
|
||||
device behind the queue the swap chain was made on — not verified); whether the getters are safe on a thread
|
||||
that is not the game's — the header is silent; Streamline's own plugin calls them on whatever thread the game
|
||||
asks for its state while the render thread sets markers, which suggests the driver tolerates it, and is an
|
||||
inference; what a call costs, on the presenting thread or on the Overlay's own; what it returns in a game that
|
||||
never set a marker (the header: valid only after markers with rising frame ids); whether a call that blocks
|
||||
in the driver can be bounded — an SEH guard does not bound a wait.
|
||||
- **How often**: one call returns 64 frames. At 240 presents a second that is four calls a second to lose none;
|
||||
once a second keeps the newest 64 and says how many it skipped.
|
||||
- **What else moves**: a series through region 5 (a layout change, or the reserved words), the Agent's sampler,
|
||||
the page; the Disclaimer's sentence about what the Overlay's own thread does (a version of its own, the
|
||||
owner's wording); the Privacy Policy (what is stored: times, no content).
|
||||
|
||||
**E — from outside the game: the PCL statistics ETW provider.** Streamline's PCL plugin (and the Reflex SDK's
|
||||
`pclstats.h` in a game without Streamline) registers `PCLStatsTraceLoggingProvider`
|
||||
(`{0d216f06-82a6-4d49-bc4f-8f38ae56efab}`) and writes an event for every marker (`PCLStatsEvent`: `Marker`,
|
||||
`FrameID`), which is what NVIDIA's own overlay listens to. No injection, so it would also be the only route for
|
||||
a game the guard refuses. What it costs:
|
||||
|
||||
- **It gives the game-side markers only** — simulation, render submit, present, the ping. The driver, OS queue
|
||||
and GPU times are not in these events; NVIDIA's overlay has them from the driver.
|
||||
- **A trace session needs administrator rights** (or membership of *Performance Log Users*); the Agent is
|
||||
unelevated by default (D34).
|
||||
- **Listening changes what the game does.** Enabling the provider sets the game's `g_PCLStatsEnable`, and its own
|
||||
ping thread then posts a registered window message — or, where the game chose a key, `F13`–`F15` key messages
|
||||
— to the game's window every 100–300 ms. It is the game's code and the vendor's design, and it is what any
|
||||
listener causes; FrameLedger would still be the cause, in a game it is not even injected into.
|
||||
- **It reopens a closed decision**: ETW left the product on 2026-08-27/28 (Tier 2 is not a measurement;
|
||||
`20_OPEN_QUESTIONS` §G keeps the question of a no-injection measurement).
|
||||
|
||||
**F — NVAPI from the Agent.** `NvAPI_D3D_GetLatency` takes the game's device. Another process has none. Not a
|
||||
route.
|
||||
|
||||
### What each catalog entry would become
|
||||
|
||||
| Entry | Route A, B | C | D | E |
|
||||
|---|---|---|---|---|
|
||||
| `nvapi.reflex.frame_report` | refused | (refused) | **read**, Direct3D | game-side times only |
|
||||
| `nvapi.reflex.sleep_status` | refused | part | **read**, Direct3D | — |
|
||||
| `nvapi.reflex.mode` | refused | — | N/A: no getter returns it | — |
|
||||
| `sl.reflex.state` | refused | (refused) | the same numbers, under the NVAPI entries | — |
|
||||
| `sl.pcl.markers` | refused | — | — | counted |
|
||||
|
||||
### What this reading settles, and what it leaves to the owner
|
||||
|
||||
- **Settled by reading**: A and B are the refused classes; C breaks the vendor's own contract; F does not exist.
|
||||
§M14's pre-committed "no route without a patch at a run-time address" does **not** fire — D has no patch and E
|
||||
has no injection — so the entries do not go to N/A on this document alone.
|
||||
- **The owner's**, because each crosses a line the rules draw today:
|
||||
1. **Route D — go to a spike, or no?** A go means: `hook-harness` and a stub `nvapi64.dll` first (the call
|
||||
made, the report read, the overhead measured against NFR-1, a blocked call and a missing module shown to be
|
||||
harmless), then one real title of the owner's choice, never first in a game inside the anti-cheat
|
||||
exception's trial (D38). Pre-committed for that spike: a fault or a hang attributable to the call, an
|
||||
overhead above NFR-1, or a Direct3D 12 device that cannot be obtained without reading what rule 4 forbids
|
||||
→ Reflex latency stays N/A and the page says why. A go also needs the owner's ruling that calling a
|
||||
driver getter with the game's device is inside rule 4, asked with the rule quoted, as §M15 asks for its
|
||||
own amendment.
|
||||
2. **Route C — recorded as refused?** (Recommended: yes.)
|
||||
3. **Route E — leave §G closed, or reopen it for latency markers?** (Recommended: leave it; the route gives
|
||||
the smaller half of the number and makes a game post messages to itself.)
|
||||
- **Not looked into**: Reflex on Vulkan; AMD Anti-Lag 2 and Intel XeLL, which have their own interfaces; what
|
||||
`nvapi_Direct_GetMethod` is (the vendored headers do not declare it; the vendored import library names it; nothing here
|
||||
would use it); what a
|
||||
real game's interposer and its Reflex and PCL plugins export (the above is the headers' and the source's word,
|
||||
not a dump of a game's files).
|
||||
Reference in new issue
Block a user