feat(overlay): the native log is whole after a game that simply exits, and says which module was patched and which descriptor types each ffx module was handed - the watchdog flushes when something new was logged (beta.42 PR-3, D121) (#408)

The log held the first half second of a session unless the Agent asked for it or a stop ran, and a game that exits does neither. FlushLogIfNew on the watchdog's tick; the init flush moved before the watchdog exists. Install lines name module!symbol from the inventory row (fl::inventory::NameOfRow; the event's text is 72 characters). fl_ffx_types.h keeps each descriptor type a hooked ffx-api module was handed, per entry point, and the watchdog logs it once (FFX_DISPATCH / FFX_QUERY), with UPSCALE_ROUTE and RUNTIME_CENSUS from words the detours already kept. A diagnostic: the log file and nothing else.

Measured on the header with the Overlay's flags: +3.8 ns per dispatch for a frame's three types; +0.9 ns first slot, +8.4 ns eighth.

Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
poli0981andClaude Fable 5.2 authored and GitHub committed 2026-11-12 01:36:55 +00:00
1 parent ca7d9cb028
commit 72ee9964b0
11 files changed
+627 -33

No files matched your search

+12
View File
@@ -35,6 +35,18 @@ numeric core and does not move; the heading is the full version — corrected 20
## [Unreleased]
### Changed
- **The Overlay's log is whole after a game exits, and says more.** The log FrameLedger's part inside the game
writes (`logs\overlay-<pid>-….log`) used to hold only the first half second of a session unless the session
ended while the game was still running: a game that exits takes the thread that writes the log with it. It is
now written during the session, whenever something new was noted. Each hook that went in is named by its module
and function (four AMD modules used to be four identical lines), a hook that could not go in says why, and the
log lists which kinds of call each AMD FidelityFX module received and which upscaling and frame-generation
modules the game loaded, and when. This is for finding out why a game's upscaler reads "unknown" — nothing in
it is a measurement, and nothing from it is stored in a session. Measured cost: about 4 billionths of a second
per FidelityFX call.
### Fixed
- **The part inside the game can no longer leave a hook in after it has stopped.** Two gaps in how the Overlay keeps
+1 -1
View File
@@ -93,7 +93,7 @@ Tails the active files (shared read), level filter, text search, pause autoscrol
2. **Bundle builder** creates `FrameLedger-bugreport-YYYYMMDD-HHmm.zip` in a user-chosen location:
- `logs/` (last 7 days, redacted copies)
- `sysinfo.json` (app + agent + **overlay build id**, OS build, CPU/GPU name, driver version, telemetry source, Vulkan layer state, PawnIO present?, elevation state, locale)
- `overlay-<pid>-*.log` for the last hooked sessions, plus hook fault details and the ring's dropped/fault counters — these are what make injection bugs diagnosable at all. *(The file exists since 2026-09-06 — `17_HOOK_ENGINE` §Native logging: written at init, on the Agent's request at session end, and on the stop; `FAULT` lines carry the exception code and the hook's name, `UNHOOK_*` lines say per patch whether it was restored or left to a later hooker.)*
- `overlay-<pid>-*.log` for the last hooked sessions, plus hook fault details and the ring's dropped/fault counters — these are what make injection bugs diagnosable at all. *(The file exists since 2026-09-06 — `17_HOOK_ENGINE` §Native logging: written at init, on the Agent's request at session end, and on the stop — and since 0.1.0-beta.42 by the Overlay's watchdog whenever something new was logged, so it is whole after a game that simply exits, with each install named by module and symbol and each descriptor type an ffx module was handed; `FAULT` lines carry the exception code and the hook's name, `UNHOOK_*` lines say per patch whether it was restored or left to a later hooker.)*
- `settings.json` (sanitized — no paths)
- optional checkbox: last session metadata + aggregates JSON (never raw blobs by default)
- crash dumps included only when the user ticks the checkbox (size warning shown)
+50 -4
View File
@@ -780,14 +780,16 @@ compare-and-restore that never restores is not a fix.
No logging in hook bodies. A small fixed-size in-memory ring of structured events (hook installed, symbol missing, fault, unhook) is flushed to `logs\overlay-<pid>-*.log` by the init thread at session end, on unhook, or on Agent request — never mid-frame.
> **Built 2026-09-06 (P1 item 4), as specified, with the details a bug report needs.** A ring of 256 ×
> 64-byte events (`qpc`, code, two operands, a 40-char name) appended with one `fetch_add` from init and
> ~~64-byte events (`qpc`, code, two operands, a 40-char name)~~ 96-byte events (`qpc`, code, two operands, a
> 72-char name — 64 bytes and 40 characters until beta.42) appended with one `fetch_add` from init and
> watchdog paths and from a hook's **SEH handler** — `NoteFault` records the exception code and the hook's
> `__func__` — never from a hook body. Codes: `RING_CREATED`, `PRESENT_HOOKS`, `HOOK_INSTALLED` (one per
> patch, with the target address), `SYMBOL_MISSING` (once per pair, and only when the module IS mapped),
> `FAULT`, `STOP` (the reason), `UNHOOK_RESTORED` / `UNHOOK_DECLINED` (one per patch), `LOADER_DETOUR`,
> `SUPERVISION_LOST`, since beta.24 `STOP_FLUSHED` (the last line after a stop: `a=1` when the stop had finished
> writing), and since beta.42 `PATCH_FAILED` (a patch that did not go in, once per target and reason — §Unhooking).
> **Three flush points, none on a present path:** the end of `InitThread` (so the
> writing), and since beta.42 `PATCH_FAILED` (a patch that did not go in, once per target and reason — §Unhooking)
> and `FFX_DISPATCH`, `FFX_QUERY`, `UPSCALE_ROUTE`, `RUNTIME_CENSUS` (the note at the end of this section).
> **Three flush points — four since beta.42, the same note —, none on a present path:** the end of `InitThread` (so the
> file exists from the start of the session and a crash mid-session still leaves it), the watchdog when
> `FlControlBlock.logFlushRequested` changes (a counter the Agent bumps at session end; nothing clears it),
> and the watchdog on its way out after any stop. Appended, never recreated; events overwritten before a
@@ -805,8 +807,52 @@ No logging in hook bodies. A small fixed-size in-memory ring of structured event
> line. Nothing on a present path changed. Path: `%LOCALAPPDATA%\FrameLedger\logs\overlay-<pid>-<yyyymmdd-hhmmss>.log`,
> resolved by `SHGetKnownFolderPath` (§S21's rule, not the environment). No allocation: static ring,
> static 64 KiB format buffer, static path. The CaptureHost prints the file and its `FAULT` / `STOP` /
> `UNHOOK_*` / `SYMBOL_MISSING` / `SUPERVISION_LOST` lines at the end of every session
> `UNHOOK_*` / `SYMBOL_MISSING` / `PATCH_FAILED` / `SUPERVISION_LOST` lines at the end of every session
> (`Consume/OverlayLog.cs`).
>
> **The log outlives the game, and says what each ffx module was handed (0.1.0-beta.42, owner decision D121).**
> Cyberpunk 2077, set to FSR upscaling with FSR frame generation, was recorded with frame generation measured and
> the upscaler "unknown": PREPARE and FRAMEGENERATION dispatches arrived and no UPSCALE ever did. The log could
> not say why. **It ended half a second into the session** — written at the end of init, then only when the Agent
> asked or a stop ran, and a game that exits does neither: the watchdog dies with the process. And **it could not
> have said much**: the two one-target rows logged their symbol and every other row the word `hook`, so four ffx
> modules were one indistinguishable line each. Four changes, none of them a new patch site:
>
> 1. **A fourth flush point: the watchdog, on any tick that finds something new in the ring** (`FlushLogIfNew`:
> one load on an uneventful tick, no file opened). Events are few and bounded — installs, first sights, three
> faults at most — so this is a handful of appends a session. The init thread's flush moved to **before** the
> watchdog is created: `FlushLog`'s state belongs to one thread at a time, and with the watchdog flushing on its
> first tick the old order could run two at once.
> 2. **Every install line names its module and its symbol** — `amd_fidelityfx_dx12.dll!ffxDispatch` — built at
> compile time from the inventory row's own two spellings (`fl::inventory::NameOfRow`), so no second list of
> names exists. The same name is on the `UNHOOK_*` and `PATCH_FAILED` lines. The event's text grew from 40 to
> 72 characters for it (an event is 96 bytes; the ring 24 KiB, static), and `PatchTarget` lost its default
> name, so a new call site cannot log `hook`.
> 3. **`FFX_DISPATCH` / `FFX_QUERY`: each descriptor type a hooked ffx-api module was handed, once**
> (`fl_ffx_types.h`). Text = the module, `b` = the type (`0x10001` UPSCALE, `0x20004` / `0x2000c` PREPARE,
> `0x20003` FRAMEGENERATION, …); `a` ≠ 0 with `b=0` says what did not fit (`1` a ninth distinct type, `2` a
> type of zero). The detour keeps the value of `type` — the member it reads already to choose an arm — in the
> first free of eight slots per module and entry point; the watchdog writes it. A query's type is kept whatever
> the vendor answered. `UPSCALE_ROUTE` names each source an UPSCALE came from, once (the FSR 3.0 host has no
> descriptor type, so this is the only line that says its export was called), and `RUNTIME_CENSUS` repeats the
> census word (`b`) whenever it gains a bit — both from words the detours kept before, at no cost to a hook.
> 4. **`PATCH_FAILED`** (§Unhooking) is the fourth: a patch that did not go in used to leave no line at all.
>
> **This is a diagnostic, not a measurement, and it is not behind the Advanced-metrics switch** — like
> `HOOK_INSTALLED`, it reaches the log file and nothing else: no record, no region of the shared memory, no session.
> Rule 4: the only thing read is `type`, of a descriptor handed to a hooked call. Rule 5: no allocation, no lock,
> no logging in the body; a type already kept costs loads and no write.
>
> **Measured overhead** (on `fl_ffx_types.h` itself with the Overlay's compile flags — `/O2 /GS /guard:cf
> /Qspectre`, 50 million calls a run, three runs, i7-14700KF): a frame's three dispatch types in turn, **+3.8 ns a
> dispatch** (3.79 / 3.87 / 3.81); a type in the first slot +0.9 to +1.0 ns; in the eighth, the worst steady
> state, +8.1 to +8.4 ns. A new type costs one compare-exchange, once per type and module.
>
> ctest `fl_ffx_types` (the header, including eight threads meeting the same six types at once: each kept exactly
> once) and `fl_guard` `[log]`: a harness on the 1.1.x monolith, generating frames and asking a ratio query, is
> supervised and told **nothing else** — no flush request, no stop — and its log holds the two install lines by
> module and symbol, the three dispatch types and the query type once each, the route and the census; the process
> is then killed and the file is as it was, one header, no `STOP`.
> **Tests and the real logs folder (2026-09-15).** The injection tests use the shipped Overlay, so their harness
> logs land in the user's real `logs\` too: measured that day, 2506 overlay logs, **2492 of them hook-harness's**,
@@ -75,12 +75,16 @@ internal static class OverlayLog
}
}
/// <summary>Faults, the stop, unhook decisions, a missing symbol, supervision loss — never the routine installs.</summary>
/// <summary>
/// Faults, the stop, unhook decisions, a missing symbol, a patch that did not go in, supervision loss — never the
/// routine installs.
/// </summary>
private static bool IsWorthPrinting(string line) =>
line.StartsWith('+', StringComparison.Ordinal)
&& (line.Contains(" FAULT ", StringComparison.Ordinal)
|| line.Contains(" STOP ", StringComparison.Ordinal)
|| line.Contains(" UNHOOK_", StringComparison.Ordinal)
|| line.Contains(" SYMBOL_MISSING ", StringComparison.Ordinal)
|| line.Contains(" PATCH_FAILED ", StringComparison.Ordinal)
|| line.Contains(" SUPERVISION_LOST ", StringComparison.Ordinal));
}
@@ -0,0 +1,119 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
// Which descriptor types an ffx-api module was handed, for the native log
// (17_HOOK_ENGINE §Native logging; 0.1.0-beta.42, owner decision D121).
//
// WHY. Cyberpunk 2077, set to FSR upscaling with FSR frame generation, was
// recorded with frame generation measured and the upscaler "unknown": the
// PREPARE and FRAMEGENERATION dispatches arrived and no UPSCALE dispatch ever
// did. Nothing in the field could say where the upscale went -- the record
// carries what was decoded, never what was not. This keeps, per hooked module
// and per entry point, the distinct values of the one member every ffx-api
// descriptor starts with -- its `type`, which the detours read already to choose
// an arm -- and the watchdog writes each to the log the first time it is seen.
// One session's log then says which module was called with what.
//
// NOT A MEASUREMENT AND NOT GATED BY ADVANCED METRICS: it is a diagnostic, like
// HOOK_INSTALLED. It reaches the log file and nothing else -- no record, no
// region of the shared memory, no session.
//
// THE HOOK'S SHARE IS A FEW LOADS. A type already kept costs one relaxed load
// per slot up to its own and no write; a title sends two to four distinct types
// per module, so that is two to four loads a call. A NEW type costs one
// compare-exchange, once. Slots fill in order and are never cleared, so the
// watchdog's "how many have I logged" is a prefix length. No allocation, no
// lock, no logging here (rule 5); nothing is read but the value passed in
// (rule 4).
//
// Header-only so the cost is measured on this code itself and ctest fl_ffx_types
// drives it without the Overlay.
#ifndef FRAMELEDGER_FL_FFX_TYPES_H
#define FRAMELEDGER_FL_FFX_TYPES_H
#include <atomic>
#include <cstdint>
namespace fl::ffxtypes {
inline constexpr std::uint32_t kSlots = 8;
// What did not fit, OR'd into Seen::more.
enum More : std::uint32_t {
kMoreTypes = 1u << 0, // a ninth distinct type arrived: the eight kept are not all there were
kMoreZero = 1u << 1, // a descriptor whose type was 0 arrived (0 is the empty slot, so it has no slot)
};
struct alignas(64) Seen {
std::atomic<std::uint64_t> types[kSlots]{};
std::atomic<std::uint32_t> more{0};
// Filled out to two cache lines by hand, so that the words another module's detour reads are never on a line
// this one writes -- and so that the padding is stated rather than left to the compiler (C4324).
std::uint8_t reserved[60]{};
};
static_assert(sizeof(Seen) == 128, "two cache lines: eight types, the More word, and the stated padding");
namespace detail {
inline void NoteMore(Seen& seen, std::uint32_t bit) noexcept {
// Read first: once the bit is set, a title that sends such a descriptor every frame writes nothing.
if ((seen.more.load(std::memory_order_relaxed) & bit) == 0u) {
seen.more.fetch_or(bit, std::memory_order_relaxed);
}
}
} // namespace detail
// Hook path. Keep `type` if it is new.
inline void Note(Seen& seen, std::uint64_t type) noexcept {
if (type == 0u) {
detail::NoteMore(seen, kMoreZero);
return;
}
for (std::atomic<std::uint64_t>& slot : seen.types) {
std::uint64_t kept = slot.load(std::memory_order_relaxed);
if (kept == type) {
return;
}
if (kept == 0u) {
if (slot.compare_exchange_strong(kept, type, std::memory_order_relaxed)) {
return;
}
if (kept == type) {
return; // another thread kept the same type in this slot first
}
// ...or a different one: this slot is taken, the next is tried.
}
}
detail::NoteMore(seen, kMoreTypes);
}
// Watchdog side: how far one Seen has been written to the log.
struct Reported {
std::uint32_t types = 0; // slots [0, types) are in the log
std::uint32_t more = 0; // More bits already in the log
};
// Calls onType(type) for every kept type not reported yet, in the order they were kept, and onMore(bits) for More
// bits not reported yet. One thread per Reported.
template <class OnType, class OnMore>
void ReportNew(const Seen& seen, Reported& reported, OnType&& onType, OnMore&& onMore) noexcept {
while (reported.types < kSlots) {
const std::uint64_t type = seen.types[reported.types].load(std::memory_order_relaxed);
if (type == 0u) {
break;
}
onType(type);
++reported.types;
}
const std::uint32_t more = seen.more.load(std::memory_order_relaxed);
if (const std::uint32_t fresh = more & ~reported.more; fresh != 0u) {
onMore(fresh);
reported.more |= fresh;
}
}
} // namespace fl::ffxtypes
#endif // FRAMELEDGER_FL_FFX_TYPES_H
@@ -383,6 +383,52 @@ inline constexpr uint32_t kRowCount = 0u FL_HOOK_INVENTORY(FL_COUNT_ROW);
#undef FL_COUNT_ROW
static_assert(kRowCount == 13u, "a row was added or removed: say so here, and in 17_HOOK_ENGINE §Hook inventory");
// A row's "module!symbol", for the native log, built at compile time from the row's own two spellings -- so an
// install line names the module it patched, and no second list of names exists to drift from the table
// (0.1.0-beta.42). The module names are ASCII by the table's own spelling; the assert below keeps every row inside
// the text, so no two rows can log the same truncated name.
struct RowName {
char text[72]{};
};
constexpr RowName NameOfRow(const wchar_t* moduleName, const char* symbol) noexcept {
RowName name{};
size_t i = 0;
for (; *moduleName != L'\0' && i + 1 < sizeof(name.text); ++moduleName) {
name.text[i++] = static_cast<char>(*moduleName);
}
if (i + 1 < sizeof(name.text)) {
name.text[i++] = '!';
}
for (; *symbol != '\0' && i + 1 < sizeof(name.text); ++symbol) {
name.text[i++] = *symbol;
}
return name;
}
constexpr size_t LengthW(const wchar_t* text) noexcept {
size_t n = 0;
while (text[n] != L'\0') {
++n;
}
return n;
}
constexpr size_t LengthA(const char* text) noexcept {
size_t n = 0;
while (text[n] != '\0') {
++n;
}
return n;
}
constexpr bool EveryRowNameFits() noexcept {
#define FL_ROW_NAME_FITS(mod, sym, family) \
if (LengthW(mod) + 1 + LengthA(sym) + 1 > sizeof(RowName::text)) { \
return false; \
}
FL_HOOK_INVENTORY(FL_ROW_NAME_FITS)
#undef FL_ROW_NAME_FITS
return true;
}
static_assert(EveryRowNameFits(), "a row's module!symbol does not fit RowName::text -- widen it, and the log event's");
// The FSR 3.0 host module and the one symbol dllmain's ffx arm keys on for it. Named
// constants HERE, for the reason kModuleSlInterposer gives below, and bound to the
// table so the row and the arm cannot drift apart.
+127 -21
View File
@@ -50,6 +50,7 @@
#include <fl_d3d12_vtable.h>
#include <fl_dxgi_count.h>
#include <fl_dxgi_vtable.h>
#include <fl_ffx_types.h>
#include <fl_hook_inventory.h>
#include <fl_patch_check.h>
#include <fl_patch_registry.h>
@@ -134,6 +135,15 @@ void PublishHandshake() noexcept {
// present path. No allocation anywhere: the ring, the format buffer and the path
// are static; the one system call that could allocate (SHGetKnownFolderPath)
// runs on the init/watchdog thread and is freed at once.
//
// AND, SINCE 0.1.0-beta.42, BY THE WATCHDOG WHENEVER SOMETHING NEW WAS LOGGED. A
// game that exits takes the watchdog with it: nothing asks for a flush and no
// stop runs, so the file held what init wrote and nothing after -- the first
// half second of a session. Cyberpunk 2077's upscaler read "unknown" (D121) and
// the log that should have said which hooks went in and what they were handed
// ended before the game had loaded its upscaler. Events are few and bounded
// (installs, a handful of first sights, three faults at most), so this is a few
// appends per session, on the watchdog's own tick.
// ---------------------------------------------------------------------------
enum FlLogCode : uint32_t {
kLogRingCreated = 1,
@@ -149,6 +159,10 @@ enum FlLogCode : uint32_t {
kLogTolerance,
kLogStopFlushed,
kLogPatchFailed,
kLogFfxDispatchType,
kLogFfxQueryType,
kLogUpscaleRoute,
kLogRuntimeCensus,
};
const char* LogCodeName(uint32_t code) noexcept {
@@ -179,18 +193,31 @@ const char* LogCodeName(uint32_t code) noexcept {
return "STOP_FLUSHED";
case kLogPatchFailed:
return "PATCH_FAILED";
case kLogFfxDispatchType:
return "FFX_DISPATCH";
case kLogFfxQueryType:
return "FFX_QUERY";
case kLogUpscaleRoute:
return "UPSCALE_ROUTE";
case kLogRuntimeCensus:
return "RUNTIME_CENSUS";
default:
return "?";
}
}
// 72 characters of text since 0.1.0-beta.42 (40 until then): an install line names its module AND its symbol, and
// "amd_fidelityfx_framegeneration_dx12.dll!ffxDispatch" is 51.
struct FlLogEvent {
uint64_t qpc;
uint32_t code;
uint32_t a;
uint64_t b;
char text[40];
char text[72];
};
static_assert(sizeof(FlLogEvent) == 96, "the native log's event: 256 of them are static storage in a game's process");
static_assert(sizeof(fl::inventory::RowName::text) <= sizeof(FlLogEvent::text),
"a row's module!symbol name must fit an event's text, or two rows could log the same truncated name");
constexpr uint32_t kLogCapacity = 256;
FlLogEvent g_log[kLogCapacity]{};
@@ -228,7 +255,7 @@ void LogNote(uint32_t code, const char* text, uint32_t a = 0, uint64_t b = 0) no
// Narrow ASCII copy of a module name for the log; anything outside ASCII is '?'.
void LogNoteW(uint32_t code, const wchar_t* text, uint32_t a = 0, uint64_t b = 0) noexcept {
char narrow[40]{};
char narrow[sizeof(FlLogEvent::text)]{};
size_t i = 0;
for (; text != nullptr && i + 1 < sizeof(narrow) && text[i] != L'\0'; ++i) {
narrow[i] = (text[i] < 128) ? static_cast<char>(text[i]) : '?';
@@ -333,6 +360,14 @@ void FlushLog(bool lastFlush = false) noexcept {
CloseHandle(h);
}
// The watchdog's own flush: only when something was logged since the last one, so an uneventful second costs one
// load and opens no file. Watchdog thread only -- see FlushLog.
void FlushLogIfNew() noexcept {
if (g_logNext.load(std::memory_order_acquire) != g_logFlushed) {
FlushLog();
}
}
// ---------------------------------------------------------------------------
// The patch registry (17_HOOK_ENGINE §Unhooking; P1 item 4). Every MinHook
// patch this DLL installs is recorded here so the stop can ask, per patch,
@@ -935,7 +970,7 @@ void StopObserving(uint32_t reason) noexcept {
// cannot reuse InstallRow because its targets come from a VTABLE rather than from a
// name; the LoadLibrary detour was the third, and until 0.1.0-beta.42 it carried a
// copy of the sequence with the re-check left out.
bool PatchTarget(void* target, void* detour, void** original, const char* name = "hook") noexcept {
bool PatchTarget(void* target, void* detour, void** original, const char* name) noexcept {
const fl::patch::InstallResult result =
fl::patch::Install(g_patches, g_observing, MinHookEngine{}, target, detour, original, name);
if (result == fl::patch::InstallResult::Installed) {
@@ -1878,6 +1913,14 @@ void NoteFfxExtent(const FfxApiDimensions2D& size) noexcept {
NoteFfxExtent(size.width, size.height);
}
// Which descriptor types each hooked ffx-api module was handed, per entry point, for the native log (fl_ffx_types.h;
// D121). The detours keep a type the first time it is seen; the watchdog writes it. A diagnostic: nothing here reaches
// a record or the shared memory.
fl::ffxtypes::Seen g_ffxDispatchTypes[fl::inventory::kFfxLeafCount];
fl::ffxtypes::Seen g_ffxQueryTypes[fl::inventory::kFfxLeafCount];
fl::ffxtypes::Reported g_ffxDispatchTypesLogged[fl::inventory::kFfxLeafCount]; // watchdog only
fl::ffxtypes::Reported g_ffxQueryTypesLogged[fl::inventory::kFfxLeafCount]; // watchdog only
// The answer one query returned, kept for the dispatch arm. Read only after the vendor answered OK; a mode, a size or a
// ratio the byte or the match cannot carry is not kept.
void ObserveFfxQuery(uint32_t leaf, const ffxQueryDescHeader* desc) noexcept {
@@ -1962,6 +2005,7 @@ void ObserveFfxDispatch(uint32_t leaf, const ffxDispatchDescHeader* desc) noexce
if (desc == nullptr) {
return;
}
fl::ffxtypes::Note(g_ffxDispatchTypes[leaf], desc->type);
switch (desc->type) {
case FFX_API_DISPATCH_DESC_TYPE_UPSCALE: {
const auto* up = reinterpret_cast<const ffxDispatchDescUpscale*>(desc);
@@ -2065,8 +2109,14 @@ ffxReturnCode_t Hook_FfxQueryT(ffxContext* context, ffxQueryDescHeader* desc) {
static_assert(Leaf < fl::inventory::kFfxLeafCount, "a trampoline per leaf, and no more");
const ffxReturnCode_t rc = g_origFfxQuery[Leaf](context, desc);
FL_HOOK_GUARD({
if (rc == FFX_API_RETURN_OK && MayObserve()) {
ObserveFfxQuery(Leaf, desc);
if (MayObserve()) {
// The type is kept whatever the vendor answered: a query that was refused is still a query that was made.
if (desc != nullptr) {
fl::ffxtypes::Note(g_ffxQueryTypes[Leaf], desc->type);
}
if (rc == FFX_API_RETURN_OK) {
ObserveFfxQuery(Leaf, desc);
}
}
})
return rc;
@@ -2220,6 +2270,8 @@ void PublishHookFamily(uint32_t family, std::atomic<uint32_t>& live) noexcept {
// upscaler runtime in this process" -- which is not the same question as "did the
// title generate frames", and fl_shm.h spends a section on why it must not be
// read as one.
uint32_t g_runtimeCensusLogged = 0; // watchdog only
void PublishRuntimeCensus() noexcept {
if (g_state == nullptr) {
return;
@@ -2227,6 +2279,42 @@ void PublishRuntimeCensus() noexcept {
const uint32_t seen = fl::inventory::ObserveRuntimeModules();
std::atomic_ref<uint32_t> census{g_state->runtimeCensus};
census.fetch_or(seen, std::memory_order_relaxed);
// The same word in the log whenever it gains a bit (0.1.0-beta.42): `b` is the whole census so far, so the last
// such line of a session's log is the census the session ended with, and the time of each line is when a
// runtime appeared.
if ((seen & ~g_runtimeCensusLogged) != 0u) {
g_runtimeCensusLogged |= seen;
LogNote(kLogRuntimeCensus, "FlRuntimeCensus bits (fl_shm.h)", 0u, g_runtimeCensusLogged);
}
}
// The diagnostics the watchdog writes from what the detours kept (0.1.0-beta.42, D121): each descriptor type a hooked
// ffx-api module was handed, once -- FFX_DISPATCH / FFX_QUERY, the module, b = the type; a = More bits and b = 0 for
// what did not fit -- and each source an UPSCALE came from, once. Watchdog only; nothing here is on a hook path.
uint32_t g_upscaleRoutesLogged = 0;
void LogFfxObservations() noexcept {
for (uint32_t leaf = 0; leaf < fl::inventory::kFfxLeafCount; ++leaf) {
const wchar_t* moduleName = fl::inventory::kFfxLeafModules[leaf];
fl::ffxtypes::ReportNew(
g_ffxDispatchTypes[leaf], g_ffxDispatchTypesLogged[leaf],
[moduleName](uint64_t type) noexcept { LogNoteW(kLogFfxDispatchType, moduleName, 0u, type); },
[moduleName](uint32_t more) noexcept { LogNoteW(kLogFfxDispatchType, moduleName, more, 0u); });
fl::ffxtypes::ReportNew(
g_ffxQueryTypes[leaf], g_ffxQueryTypesLogged[leaf],
[moduleName](uint64_t type) noexcept { LogNoteW(kLogFfxQueryType, moduleName, 0u, type); },
[moduleName](uint32_t more) noexcept { LogNoteW(kLogFfxQueryType, moduleName, more, 0u); });
}
// g_ffxUpscaleLeaf: leaf + 1 for an ffx-api leaf, kFfxUpscaleSourceFsr3Host for the 3.0 host's own export, 0 for
// none yet. The host has no descriptor type, so this is the only line that says its export was called.
const uint32_t route = g_ffxUpscaleLeaf.load(std::memory_order_relaxed);
if (route != 0u && route <= kFfxUpscaleSourceFsr3Host && (g_upscaleRoutesLogged & (1u << route)) == 0u) {
g_upscaleRoutesLogged |= 1u << route;
LogNoteW(kLogUpscaleRoute,
route == kFfxUpscaleSourceFsr3Host ? fl::inventory::kModuleFfxFsr3Host
: fl::inventory::kFfxLeafModules[route - 1u],
route);
}
}
// The tag census, on the same tick and by the same rule: OR-only, from the
@@ -2278,7 +2366,7 @@ void NoteSymbolMissingOnce(const wchar_t* moduleName, const char* symbol)
}
bool InstallRow(const wchar_t* moduleName, const char* symbol, uint32_t family, void* detour, void** original,
std::atomic<uint32_t>& live) noexcept {
std::atomic<uint32_t>& live, const char* name) noexcept {
if (live.load(std::memory_order_acquire) != 0) {
return true;
}
@@ -2292,7 +2380,7 @@ bool InstallRow(const wchar_t* moduleName, const char* symbol, uint32_t family,
return false;
}
if (!PatchTarget(target, detour, original, symbol)) {
if (!PatchTarget(target, detour, original, name)) {
return false;
}
@@ -2306,14 +2394,17 @@ bool InstallRow(const wchar_t* moduleName, const char* symbol, uint32_t family,
// is the safe direction: an unbound row is a table entry somebody added without
// writing its hook, and hooking it with a neighbour's body is exactly what this
// function exists to stop.
bool InstallByFamily(const wchar_t* moduleName, const char* symbol, uint32_t family) noexcept {
//
// `name` is the row's "module!symbol", for the log (0.1.0-beta.42): until then the two one-target rows logged their
// symbol and every other row logged the word "hook", so a log could not say WHICH of four ffx modules was patched.
bool InstallByFamily(const wchar_t* moduleName, const char* symbol, uint32_t family, const char* name) noexcept {
// EQUALITY AGAINST THE COMPOUND CONSTANT, not `& FL_HOOK_UPSCALER_IDENTITY`. A
// bit test would bind any future row that happens to include identity to THIS
// detour -- which is the neighbour's-body defect this function exists to stop,
// and it would arrive silently because the row would still install.
if (family == fl::inventory::kFamilyEvaluateFeature) {
return InstallRow(moduleName, symbol, family, reinterpret_cast<void*>(&Hook_SlEvaluateFeature),
reinterpret_cast<void**>(&g_origSlEvaluateFeature), g_upscalerIdentityLive);
reinterpret_cast<void**>(&g_origSlEvaluateFeature), g_upscalerIdentityLive, name);
}
if (family == static_cast<uint32_t>(fl::FL_HOOK_UPSCALER_PARAMS)) {
// TWO ROWS IN THIS FAMILY WITH DIFFERENT SIGNATURES, so the family alone would
@@ -2338,7 +2429,7 @@ bool InstallByFamily(const wchar_t* moduleName, const char* symbol, uint32_t fam
frameRow ? reinterpret_cast<void*>(&Hook_SlSetTagForFrame) : reinterpret_cast<void*>(&Hook_SlSetTag);
void** original =
frameRow ? reinterpret_cast<void**>(&g_origSlSetTagForFrame) : reinterpret_cast<void**>(&g_origSlSetTag);
if (!PatchTarget(target, detour, original)) {
if (!PatchTarget(target, detour, original, name)) {
return false;
}
patched.store(1, std::memory_order_release);
@@ -2346,7 +2437,7 @@ bool InstallByFamily(const wchar_t* moduleName, const char* symbol, uint32_t fam
}
if (family == static_cast<uint32_t>(fl::FL_HOOK_FG_EVALUATIONS)) {
return InstallRow(moduleName, symbol, family, reinterpret_cast<void*>(&Hook_SlGetNewFrameToken),
reinterpret_cast<void**>(&g_origSlGetNewFrameToken), g_frameTokensLive);
reinterpret_cast<void**>(&g_origSlGetNewFrameToken), g_frameTokensLive, name);
}
if (family == fl::inventory::kFamilyFfxDispatch) {
// FOUR ROWS, ONE ARM: the row's MODULE picks the trampoline and the latch slot,
@@ -2379,7 +2470,7 @@ bool InstallByFamily(const wchar_t* moduleName, const char* symbol, uint32_t fam
return false; // not loaded, or a module of the name that does not speak the 3.0 host ABI
}
if (!PatchTarget(target, reinterpret_cast<void*>(&Hook_FfxFsr3ContextDispatchUpscale),
reinterpret_cast<void**>(&g_origFfxFsr3DispatchUpscale))) {
reinterpret_cast<void**>(&g_origFfxFsr3DispatchUpscale), name)) {
return false;
}
g_fsr3HostPatched.store(1, std::memory_order_release);
@@ -2393,7 +2484,7 @@ bool InstallByFamily(const wchar_t* moduleName, const char* symbol, uint32_t fam
if (target == nullptr) {
return false; // not loaded, or a module of the name that does not speak ffx-api
}
if (!PatchTarget(target, FfxDispatchDetour(slot), reinterpret_cast<void**>(&g_origFfxDispatch[slot]))) {
if (!PatchTarget(target, FfxDispatchDetour(slot), reinterpret_cast<void**>(&g_origFfxDispatch[slot]), name)) {
return false;
}
g_ffxPatched[slot].store(1, std::memory_order_release);
@@ -2414,7 +2505,7 @@ bool InstallByFamily(const wchar_t* moduleName, const char* symbol, uint32_t fam
if (target == nullptr) {
return false; // not loaded, or a module of the name that does not speak ffx-api
}
if (!PatchTarget(target, FfxQueryDetour(slot), reinterpret_cast<void**>(&g_origFfxQuery[slot]))) {
if (!PatchTarget(target, FfxQueryDetour(slot), reinterpret_cast<void**>(&g_origFfxQuery[slot]), name)) {
return false;
}
g_ffxQueryPatched[slot].store(1, std::memory_order_release);
@@ -2514,7 +2605,11 @@ void PublishParamsFamilyIfWhole() noexcept {
bool InstallUpscalerHooks() noexcept {
bool any = false;
#define FL_INSTALL_ROW(mod, sym, family) any = InstallByFamily(mod, sym, static_cast<uint32_t>(family)) || any;
#define FL_INSTALL_ROW(mod, sym, family) \
{ \
static constexpr fl::inventory::RowName kRowName = fl::inventory::NameOfRow(mod, sym); \
any = InstallByFamily(mod, sym, static_cast<uint32_t>(family), kRowName.text) || any; \
}
FL_HOOK_INVENTORY(FL_INSTALL_ROW)
#undef FL_INSTALL_ROW
PublishParamsFamilyIfWhole();
@@ -2649,13 +2744,15 @@ bool InstallRtHooks() noexcept {
if (dispatchAgrees && g_rtDispatchLive.load(std::memory_order_acquire) == 0 &&
PatchTarget(directVtbl[fl::d3d12::kDispatchRaysIndex], reinterpret_cast<void*>(&Hook_DispatchRays),
reinterpret_cast<void**>(&g_origDispatchRays))) {
reinterpret_cast<void**>(&g_origDispatchRays),
"d3d12!ID3D12GraphicsCommandList4::DispatchRays")) {
PublishHookFamily(static_cast<uint32_t>(fl::FL_HOOK_RT_DISPATCH), g_rtDispatchLive);
installed = true;
}
if (buildAgrees && g_rtAsBuildLive.load(std::memory_order_acquire) == 0 &&
PatchTarget(directVtbl[fl::d3d12::kBuildRaytracingAccelerationStructureIndex],
reinterpret_cast<void*>(&Hook_BuildRtAs), reinterpret_cast<void**>(&g_origBuildRtAs))) {
reinterpret_cast<void*>(&Hook_BuildRtAs), reinterpret_cast<void**>(&g_origBuildRtAs),
"d3d12!ID3D12GraphicsCommandList4::BuildRaytracingAccelerationStructure")) {
PublishHookFamily(static_cast<uint32_t>(fl::FL_HOOK_RT_AS_BUILD), g_rtAsBuildLive);
installed = true;
}
@@ -2779,6 +2876,11 @@ DWORD WatchdogLoop() noexcept {
PublishDxgiPresentCounters();
PublishLoaderWords();
// What the detours kept for the log, then the log itself when this tick -- or a fault in a hook since the
// last one -- added to it. BEFORE the supervision check: its healthy branch continues the loop.
LogFfxObservations();
FlushLogIfNew();
// Supervision loss. guardTicks counts COMPLETED guard evaluations, not
// seconds, so a stalled guard loop stops it advancing even while the
// Agent process is alive -- which is exactly the case a timer-driven
@@ -3743,6 +3845,14 @@ DWORD WINAPI InitThread(LPVOID) noexcept {
// fatal: the present-path checks still work, and an Overlay that reacts only
// while the game presents is strictly better than none. It is recorded in the
// fault counter so the Agent can see it rather than inferring it.
//
// The first flush: init is over, on the init thread, never mid-frame. The
// file therefore exists from the start of the session, which is what makes a
// crash mid-session diagnosable at all (10_LOGGING). BEFORE THE WATCHDOG
// EXISTS since 0.1.0-beta.42: FlushLog's state belongs to one thread at a
// time, and the watchdog now flushes on its own first tick -- placed after
// CreateThread, as it was, this flush could run beside that one.
FlushLog();
HANDLE watchdog = CreateThread(nullptr, 0, WatchdogThread, nullptr, 0, nullptr);
if (watchdog == nullptr) {
std::atomic_ref<uint32_t> faults{g_state->faultCount};
@@ -3750,10 +3860,6 @@ DWORD WINAPI InitThread(LPVOID) noexcept {
} else {
CloseHandle(watchdog); // fire and forget; it exits on its own once stopped
}
// The first flush: init is over, on the init thread, never mid-frame. The
// file therefore exists from the start of the session, which is what makes a
// crash mid-session diagnosable at all (10_LOGGING).
FlushLog();
return 0;
}
+9
View File
@@ -178,6 +178,15 @@ target_compile_options(fl_unhook_inline_test PRIVATE /EHsc)
target_compile_definitions(fl_unhook_inline_test PRIVATE WIN32_LEAN_AND_MEAN NOMINMAX)
add_test(NAME fl_unhook_inline COMMAND fl_unhook_inline_test)
# fl_ffx_types.h (0.1.0-beta.42, D121): the descriptor types an ffx-api module was handed, kept by the detours for
# the native log. The header the Overlay compiles, driven without the Overlay -- including from eight threads.
add_executable(fl_ffx_types_test ffx_types_test.cpp)
target_include_directories(fl_ffx_types_test PRIVATE "${CMAKE_SOURCE_DIR}/FrameLedger.Overlay/include")
target_link_libraries(fl_ffx_types_test PRIVATE fl_native_flags Catch2::Catch2WithMain)
target_compile_options(fl_ffx_types_test PRIVATE /EHsc)
target_compile_definitions(fl_ffx_types_test PRIVATE WIN32_LEAN_AND_MEAN NOMINMAX)
add_test(NAME fl_ffx_types COMMAND fl_ffx_types_test)
add_test(NAME fl_vklayer COMMAND fl_vklayer_test "[vklayer]")
add_test(NAME fl_vklayer_supervision COMMAND fl_vklayer_test "[vklayer-deadline]")
# The real-loader leg SKIPS (Catch2 exit 4) where there is no Vulkan loader or no
+138
View File
@@ -0,0 +1,138 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
// fl_ffx_types.h: the descriptor types an ffx-api module was handed, kept by the
// detours and written to the native log by the watchdog (0.1.0-beta.42, D121).
// The header is what the Overlay compiles, so these cases are about the shipped
// code: each type once, in the order it arrived, nothing lost when two threads
// meet a new type at the same moment, and what does not fit SAID rather than
// dropped.
#include <catch2/catch_test_macros.hpp>
#include <cstdint>
#include <fl_ffx_types.h>
#include <thread>
#include <vector>
namespace {
std::vector<std::uint64_t> Kept(const fl::ffxtypes::Seen& seen) {
std::vector<std::uint64_t> out;
for (const auto& slot : seen.types) {
if (const std::uint64_t v = slot.load(); v != 0u) {
out.push_back(v);
}
}
return out;
}
} // namespace
TEST_CASE("a type is kept once, in the order it first arrived", "[ffxtypes]") {
fl::ffxtypes::Seen seen;
for (int frame = 0; frame < 1000; ++frame) {
fl::ffxtypes::Note(seen, 0x00020004u); // PREPARE
fl::ffxtypes::Note(seen, 0x00020003u); // FRAMEGENERATION
if (frame >= 10) {
fl::ffxtypes::Note(seen, 0x00010001u); // UPSCALE, from the eleventh frame on
}
}
const std::vector<std::uint64_t> expected{0x00020004u, 0x00020003u, 0x00010001u};
CHECK(Kept(seen) == expected);
CHECK(seen.more.load() == 0u);
}
TEST_CASE("what does not fit is said: a ninth type, and a type of zero", "[ffxtypes]") {
fl::ffxtypes::Seen seen;
for (std::uint64_t type = 1; type <= fl::ffxtypes::kSlots; ++type) {
fl::ffxtypes::Note(seen, type);
}
CHECK(Kept(seen).size() == fl::ffxtypes::kSlots);
CHECK(seen.more.load() == 0u);
fl::ffxtypes::Note(seen, 3u); // already kept: still nothing to say
CHECK(seen.more.load() == 0u);
fl::ffxtypes::Note(seen, 99u);
CHECK(seen.more.load() == fl::ffxtypes::kMoreTypes);
CHECK(Kept(seen).size() == fl::ffxtypes::kSlots); // and none of the eight was displaced
fl::ffxtypes::Note(seen, 0u);
const std::uint32_t both = fl::ffxtypes::kMoreTypes | fl::ffxtypes::kMoreZero;
CHECK(seen.more.load() == both);
fl::ffxtypes::Seen zeroOnly;
fl::ffxtypes::Note(zeroOnly, 0u);
CHECK(Kept(zeroOnly).empty()); // zero is the empty slot: it takes none
CHECK(zeroOnly.more.load() == fl::ffxtypes::kMoreZero);
}
TEST_CASE("the watchdog's report: each kept type once, new ones on a later pass, the rest untouched", "[ffxtypes]") {
fl::ffxtypes::Seen seen;
fl::ffxtypes::Reported reported;
std::vector<std::uint64_t> types;
std::vector<std::uint32_t> more;
const auto report = [&] {
fl::ffxtypes::ReportNew(
seen, reported, [&types](std::uint64_t t) noexcept { types.push_back(t); },
[&more](std::uint32_t m) noexcept { more.push_back(m); });
};
report();
CHECK(types.empty());
CHECK(more.empty());
fl::ffxtypes::Note(seen, 0x20004u);
fl::ffxtypes::Note(seen, 0x20003u);
report();
report(); // nothing new: nothing said again
const std::vector<std::uint64_t> firstTwo{0x20004u, 0x20003u};
CHECK(types == firstTwo);
fl::ffxtypes::Note(seen, 0x10001u);
fl::ffxtypes::Note(seen, 0u);
report();
const std::vector<std::uint64_t> allThree{0x20004u, 0x20003u, 0x10001u};
CHECK(types == allThree);
const std::vector<std::uint32_t> zeroSaid{fl::ffxtypes::kMoreZero};
CHECK(more == zeroSaid);
for (std::uint64_t t = 100; t < 110; ++t) {
fl::ffxtypes::Note(seen, t);
}
report();
report();
CHECK(types.size() == fl::ffxtypes::kSlots);
const std::vector<std::uint32_t> bothSaid{fl::ffxtypes::kMoreZero, fl::ffxtypes::kMoreTypes};
CHECK(more == bothSaid);
}
TEST_CASE("threads that meet the same new types at once keep each exactly once", "[ffxtypes]") {
// The detours run on whatever threads the game dispatches from. Six types, eight threads, each noting all six in
// its own order, many times over: six slots filled, no type twice, none lost, nothing said to be missing.
for (int round = 0; round < 200; ++round) {
fl::ffxtypes::Seen seen;
std::vector<std::thread> threads;
for (int t = 0; t < 8; ++t) {
threads.emplace_back([&seen, t] {
for (int i = 0; i < 6; ++i) {
fl::ffxtypes::Note(seen, 0x10000u + static_cast<std::uint64_t>((i + t) % 6) + 1u);
}
});
}
for (std::thread& th : threads) {
th.join();
}
std::vector<std::uint64_t> kept = Kept(seen);
REQUIRE(kept.size() == 6u);
std::uint64_t sum = 0;
for (std::size_t i = 0; i < kept.size(); ++i) {
sum += kept[i] - 0x10000u;
for (std::size_t j = i + 1; j < kept.size(); ++j) {
REQUIRE(kept[i] != kept[j]);
}
}
REQUIRE(sum == 21u); // 1 + 2 + ... + 6: every one of the six, once
REQUIRE(seen.more.load() == 0u);
}
}
+111
View File
@@ -5985,6 +5985,117 @@ TEST_CASE("the FSR 3.0 host facade: Fsr3 identity and the count from its upscale
}
}
namespace {
// Whether the log has a line of this code whose text starts with `name` and which ends in `tail`.
bool LogHasLine(const std::string& text, const char* code, const char* name, const char* tail) {
const std::string head = std::string("s ") + code + " ";
std::size_t at = 0;
while (at < text.size()) {
std::size_t end = text.find('\n', at);
if (end == std::string::npos) {
end = text.size();
}
const std::string line = text.substr(at, end - at);
const std::size_t h = line.find(head);
if (h != std::string::npos) {
std::size_t n = h + head.size();
while (n < line.size() && line[n] == ' ') {
++n;
}
const std::string tailText = tail;
if (line.compare(n, std::strlen(name), name) == 0 && line.size() >= tailText.size() &&
line.compare(line.size() - tailText.size(), tailText.size(), tailText) == 0) {
return true;
}
}
at = end + 1;
}
return false;
}
std::size_t CountOf(const std::string& text, const char* needle) {
std::size_t n = 0;
for (std::size_t at = text.find(needle); at != std::string::npos; at = text.find(needle, at + 1)) {
++n;
}
return n;
}
} // namespace
TEST_CASE("the native log outlives a game that just exits (beta.42, D121): the watchdog writes it unasked -- installs "
"by module and symbol, the descriptor types each ffx module was handed, the census",
"[guard][inject][shm][ffx][log]") {
// WHAT A REAL SESSION LOOKED LIKE UNTIL NOW. The log was written at the end of init, when the Agent asked, and on
// a stop. A game that exits asks for nothing and stops nothing: the file held the first half second -- before
// the title had loaded its upscaler -- and Cyberpunk 2077's "unknown" upscaler (FSR set, frame generation
// measured) could not be read back from anywhere. Here nobody asks and nothing stops; the process is then killed.
Child child;
REQUIRE(StartHarness(
child, L"--real --presents-per-eval 4 --ffx-topology 1x --ffx-query ratios --hold-presenting-ffx 14"));
ResetFake();
g.modules = {"kernel32.dll"};
g.scanSet = {child.pi.dwProcessId};
REQUIRE(GuardedInjectWithSources(child.pi.dwProcessId, FL_OVERLAY_DLL, FakeSources()).Allowed());
MappedRing r;
REQUIRE(OpenRingFor(child.pi.dwProcessId, r));
// The monolith's three dispatch types of an SDK 1.1.x title generating frames, and the ratio query, by value:
// UPSCALE 0x10001, FRAMEGENERATION_PREPARE 0x20004, FRAMEGENERATION 0x20003, GETUPSCALERATIOFROMQUALITYMODE
// 0x10002 (the vendored ffx_upscale.h / ffx_framegeneration.h).
const char* mono = "amd_fidelityfx_dx12.dll";
std::wstring log;
std::string text;
bool complete = false;
for (int i = 0; i < 150 && !complete; ++i) {
++r.ctl->guardTicks; // supervised, as a session is -- and that is ALL this test tells the Overlay
Sleep(100);
if (log.empty() && !FindOverlayLog(child.pi.dwProcessId, child.pi.hProcess, log)) {
continue;
}
text = ReadWholeFile(log);
complete = LogHasLine(text, "FFX_DISPATCH", mono, " b=0x10001") &&
LogHasLine(text, "FFX_DISPATCH", mono, " b=0x20004") &&
LogHasLine(text, "FFX_DISPATCH", mono, " b=0x20003") &&
LogHasLine(text, "FFX_QUERY", mono, " b=0x10002") &&
LogHasLine(text, "UPSCALE_ROUTE", mono, " a=1 b=0x0");
}
INFO("log " << Narrow(log) << ":\n" << text);
REQUIRE(complete);
CHECK(r.ctl->logFlushRequested == 0u);
CHECK(r.ctl->unhookRequested == 0u);
CHECK(r.st->status == fl::FL_STATUS_READY);
CHECK(r.st->faultCount == 0u);
// The game exits. No stop, no last flush, no watchdog left to make one.
REQUIRE(TerminateProcess(child.pi.hProcess, 0));
WaitForSingleObject(child.pi.hProcess, 5000);
text = ReadWholeFile(log);
INFO("after the exit:\n" << text);
CHECK(CountOf(text, "# FrameLedger.Overlay build ") == 1u); // one file, one header, however many flushes
CHECK(CountOf(text, "RING_CREATED") == 1u);
// Every row that went in says which module and which symbol -- these two read "hook" until now.
CHECK(LogHasLine(text, "HOOK_INSTALLED", "amd_fidelityfx_dx12.dll!ffxDispatch", ""));
CHECK(LogHasLine(text, "HOOK_INSTALLED", "amd_fidelityfx_dx12.dll!ffxQuery", ""));
CHECK(text.find(" hook ") == std::string::npos);
// Each type once, however many thousand dispatches carried it.
CHECK(CountOf(text, "FFX_DISPATCH") == 3u);
CHECK(CountOf(text, "FFX_QUERY") == 1u);
CHECK(CountOf(text, "UPSCALE_ROUTE") == 1u);
// The census, with the monolith's bit in the word it carries.
CHECK(text.find("RUNTIME_CENSUS") != std::string::npos);
// And nothing that did not happen.
CHECK(text.find(" STOP ") == std::string::npos);
CHECK(text.find("STOP_FLUSHED") == std::string::npos);
CHECK(text.find("PATCH_FAILED") == std::string::npos);
CHECK(text.find("FAULT") == std::string::npos);
CHECK(text.find("overwritten before") == std::string::npos);
}
TEST_CASE("FSR's quality mode (beta.25, D65): the mode the title asked for names the dispatch, by its size and by "
"its ratio",
"[guard][inject][shm][ffx]") {
@@ -33,6 +33,8 @@ public sealed class OverlayLogTests : IDisposable
"# FrameLedger.Overlay build abc pid 4242 layout v3 image game.exe",
"+ 0.001s RING_CREATED Local\\FrameLedger.Ring.<pid> a=8192 b=0x0",
"+ 0.020s HOOK_INSTALLED dxgi!IDXGISwapChain::Present a=0 b=0x7ff0",
"+ 1.020s PATCH_FAILED amd_fidelityfx_dx12.dll!ffxDispatch a=4 b=0x7ff8",
"+ 2.020s FFX_DISPATCH amd_fidelityfx_dx12.dll a=0 b=0x10001",
"+ 3.400s FAULT Hook_Present a=3221225477 b=0x0",
"+ 9.000s STOP observing stopped a=3 b=0x0",
"+ 9.001s UNHOOK_RESTORED dxgi!IDXGISwapChain::Present a=1 b=0x7ff0",
@@ -44,12 +46,13 @@ public sealed class OverlayLogTests : IDisposable
OverlayLog.Find(4242, _dir).Should().Be(newer);
List<string> lines = [.. OverlayLog.Describe(4242, _dir)];
lines[0].Should().Contain(newer).And.Contain("(6 event(s))");
lines.Should().HaveCount(5, "the header, then FAULT, STOP and the two unhook decisions; the installs stay in the file");
lines[1].Should().Contain("FAULT");
lines[2].Should().Contain("STOP");
lines[3].Should().Contain("UNHOOK_RESTORED");
lines[4].Should().Contain("UNHOOK_DECLINED");
lines[0].Should().Contain(newer).And.Contain("(8 event(s))");
lines.Should().HaveCount(6, "the header, then the patch that failed, FAULT, STOP and the two unhook decisions; the installs and what was seen stay in the file");
lines[1].Should().Contain("PATCH_FAILED");
lines[2].Should().Contain("FAULT");
lines[3].Should().Contain("STOP");
lines[4].Should().Contain("UNHOOK_RESTORED");
lines[5].Should().Contain("UNHOOK_DECLINED");
}
[Fact]