mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-18 07:23:24 +09:00
[MG_Util, MG_IntegrationTest, CI] (P6): the readers the role split left behind
The per-role log split renamed BOTH halves so that an un-updated reader would fail loudly instead of silently reading half a session. It worked: CI found four readers this way. This is them. - MG_Util/Debug/Log.h: the role vocabulary now exists in the PULL build too, header-only. It was wholly inside #if MOBILEGL_BUILD_DISAGGREGATED, so PipeInputsTest - which builds in the verify flavour - could not name ReadRoleLogs and took the whole build-linux-verify job down at compile time. Inline rather than out-of-line because of G1: nothing in the library calls these, so an inline definition emits code into the readers and NOTHING into libMobileGL.so. Verified: pull symbols 30570 -> 30570, 0 added / 0 removed, .text still 0xa52203, and zero role-log symbols in the pull library. - PipeStatsWindow.h: the harness copy of the naming rule is now flavour-aware. It derived `.client` in BOTH flavours, so in the verify build - one role, MOBILEGL_LOG_FILE_PATH written unchanged - it opened a file that never existed. The copy has to stay a copy: MG_Util's RoleLogPath is `t` (local) in the shipping .so this module links, so calling it does not link. Added LogMark/MarkLaneLog/ReadLaneLogSince: one offset PER ROLE, because a single scalar over the concatenation slides by whatever the other role wrote. - The four arming scenarios: they asserted on lines the BACKEND emits, and under inproc the backend runs on the apply thread - the server role - so the line lands in the server's log. Reading only the client's half reported the emulation unarmed, i.e. accused the product of a defect the reader invented. Four copies of the same private helper pair now delegate to the harness. - scripts/ci/magma_runahead_checks.py: it unlinked and read the base name as if it were a file, so the negative arm saw an empty log and could not prove the knob took. It now imports split_log_paths' derivation - the authoritative one - rather than becoming a third copy. Local verification (WSL, lk-split + c6-pull): - the 4 CI-red entries: 10/10 PASS under inproc, 10/10 under monolith - unit role-log readers: 510/510 PASS - magma_runahead_checks negative: run_ahead_0 EXPECTED_RED, restored GREEN - the 5 affected TUs compile clean with MOBILEGL_BUILD_DISAGGREGATED=0 - G1: 0/0/0/0, .text 0xa52203 Red-once is the CI run itself (35677991453), which failed for each of these reasons before the change. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
@@ -29,6 +29,7 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <fstream>
|
||||
@@ -41,13 +42,20 @@ namespace MGITest::PipeStatsWindow {
|
||||
// ROLE - `<stem>.client<ext>` and `<stem>.server<ext>` - because under inproc both roles are
|
||||
// threads of one process and a single file made every per-side assertion a search.
|
||||
//
|
||||
// THE SUFFIX IS DERIVED HERE AND NOWHERE ELSE, matching MG_Util/Debug/Log.cpp's
|
||||
// RoleLogPathFor. Two copies of a naming rule is one copy too many: the one that is not
|
||||
// updated opens a file that does not exist and reports "the library never logged", which
|
||||
// reads as a product failure rather than as a stale path.
|
||||
// THE RULE IS COPIED HERE AND IT HAS TO BE, which is worth stating because the obvious fix is
|
||||
// to call the library's own MG_Util::Debug::RoleLogPath and delete this. That does not link:
|
||||
// this module links the SHIPPING libMobileGL.so, built -fvisibility=hidden, and the role-path
|
||||
// helpers are `t` (local) in it - only MG_Test, which links the static archive, may call them.
|
||||
//
|
||||
// SO THE COPY IS FLAVOUR-AWARE INSTEAD. That is the part the first copy got wrong: it derived
|
||||
// `.client` in BOTH flavours, while the pull build has one role and writes
|
||||
// MOBILEGL_LOG_FILE_PATH unchanged. In the verify lane it therefore opened a file that never
|
||||
// existed and every reader reported "the library never logged" - a product failure that had
|
||||
// not happened. Keep this `#if` and Log.cpp's RoleLogPath in step.
|
||||
inline std::string RoleLogPath(const char* roleSuffix) {
|
||||
const char* base = std::getenv("MOBILEGL_LOG_FILE_PATH");
|
||||
if (base == nullptr || *base == '\0') return {};
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
std::string path(base);
|
||||
const std::string::size_type slash = path.find_last_of("/\\");
|
||||
const std::string::size_type dot = path.find_last_of('.');
|
||||
@@ -55,15 +63,27 @@ namespace MGITest::PipeStatsWindow {
|
||||
return path + "." + roleSuffix;
|
||||
}
|
||||
return path.substr(0, dot) + "." + roleSuffix + path.substr(dot);
|
||||
#else
|
||||
(void)roleSuffix;
|
||||
return std::string(base);
|
||||
#endif
|
||||
}
|
||||
|
||||
// The lane's private CLIENT log path, or empty when the lane configured none. Every existing
|
||||
// caller wants this one: they read markers the CLIENT emits - the transport resolution line,
|
||||
// PipeStats summaries, the arming diagnostics.
|
||||
// The lane's private CLIENT log path, or empty when the lane configured none. In the pull
|
||||
// build this IS the whole log.
|
||||
inline std::string LibraryLogPath() { return RoleLogPath("client"); }
|
||||
|
||||
// The server role's half, for a caller that wants a line only the applier writes.
|
||||
inline std::string ServerLibraryLogPath() { return RoleLogPath("server"); }
|
||||
// The server role's half, or EMPTY when this build has no separate server half. Empty rather
|
||||
// than "the same path again": every caller below concatenates the two, and a pull build that
|
||||
// named one file twice would show each line twice - which reads as a doubled counter or a
|
||||
// repeated diagnostic rather than as a path mistake.
|
||||
inline std::string ServerLibraryLogPath() {
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
return RoleLogPath("server");
|
||||
#else
|
||||
return {};
|
||||
#endif
|
||||
}
|
||||
|
||||
inline std::string ReadWholeFile(const std::string& path) {
|
||||
if (path.empty()) return {};
|
||||
@@ -72,6 +92,51 @@ namespace MGITest::PipeStatsWindow {
|
||||
return std::string((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
|
||||
}
|
||||
|
||||
inline std::string ReadFileSince(const std::string& path, std::uintmax_t offset) {
|
||||
if (path.empty()) return {};
|
||||
std::ifstream file(path, std::ios::binary);
|
||||
if (!file.good()) return {};
|
||||
file.seekg(static_cast<std::streamoff>(offset));
|
||||
return std::string((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
|
||||
}
|
||||
|
||||
// A "the log is this long right now" snapshot, ONE OFFSET PER ROLE.
|
||||
//
|
||||
// The scenarios that assert on arming take a mark before the workload and read what was
|
||||
// appended after it, so that only bytes this case caused can satisfy - or refute - the claim.
|
||||
// The roles are separate files, so this cannot be one scalar: a single offset applied to the
|
||||
// concatenation would slide by however much the OTHER role happened to write, and the read
|
||||
// would start mid-line in the wrong file.
|
||||
struct LogMark {
|
||||
std::uintmax_t client = 0;
|
||||
std::uintmax_t server = 0;
|
||||
};
|
||||
|
||||
inline std::uintmax_t FileSizeOrZero(const std::string& path) {
|
||||
if (path.empty()) return 0;
|
||||
std::ifstream file(path, std::ios::binary | std::ios::ate);
|
||||
if (!file.good()) return 0;
|
||||
const std::streamoff size = file.tellg();
|
||||
return size < 0 ? 0 : static_cast<std::uintmax_t>(size);
|
||||
}
|
||||
|
||||
inline LogMark MarkLaneLog() {
|
||||
return LogMark{FileSizeOrZero(LibraryLogPath()), FileSizeOrZero(ServerLibraryLogPath())};
|
||||
}
|
||||
|
||||
// BOTH ROLES, and for the arming diagnostics the SERVER's is the one that matters. Those lines
|
||||
// are emitted by the BACKEND - "demoted to an ordinary varying", the reroute and emulation
|
||||
// banners - and under inproc the backend runs on the apply thread, which is the server role.
|
||||
// Reading only the client's half finds nothing and reports "the emulation is not armed",
|
||||
// which is the most expensive possible way to be wrong: it accuses the product of a defect
|
||||
// that the reader itself invented.
|
||||
inline std::string ReadLaneLogSince(const LogMark& mark) {
|
||||
return ReadFileSince(LibraryLogPath(), mark.client)
|
||||
+ ReadFileSince(ServerLibraryLogPath(), mark.server);
|
||||
}
|
||||
|
||||
inline std::string ReadLaneLog() { return ReadLaneLogSince(LogMark{}); }
|
||||
|
||||
// The last summary line in the log, verbatim. `found` is false when the library never emitted
|
||||
// one, which is a different failure from "the counter read zero" and has to be reported as
|
||||
// one: it means the stats channel never reached the process, not that the workload did
|
||||
|
||||
Reference in New Issue
Block a user