Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7ff2ffc794 |
No files matched your search
@@ -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
|
||||
|
||||
@@ -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
@@ -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.
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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]
|
||||
|
||||
Reference in new issue
Block a user