mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-17 06:53:22 +09:00
[MG_Pipe, MG_Impl, MG_Remote, MG_State, MG_Test] (Disaggregated): P5e pg - the archive becomes server-owned and the bindings get a record
- MGPipeShaderCsoRecord gains Archive, a SharedPtr<const ProgramArchive> the create
ADOPTS under a transport. Before this the applier stored the descriptor and the two
companion pointers named the frontend's own LinkArtifacts/SpirvArtifacts, which
ProgramObject::Link() replaces in place - so every reflection read on the apply thread
was torn or stale by construction the moment the client runs ahead (gap G-A).
- MGPipeApplyCreateShaderState takes the archive as a fourth argument, undefaulted for
PipeRoute.h's stated reason: a caller that has one and forgets it would compile, and
the failure would be silent. Null on the monolith arm, which keeps its frontend arms
token for token (ruling 1 / ID-81).
- ProgramArtifactsCodec gains ProgramArchive and the FRAME. SpirvArtifacts carries no
stage list and MGPProgramDesc::StageMask cannot stand in for one: it is a bit set, and
GL lets two shader objects share a stage, so a list rebuilt from it can be shorter than
generatedSpirv - which the backend pairs with it by one running index.
- Codec completeness, as CONTRACT-P5E §5.5 asks: the skipped member is named
(LinkArtifacts::program, the live glslang TProgram) and proven unread by either backend
twin; the libc++ caveat at the size echo is read as what it is - a cross-toolchain
check, exact for an in-process split - and both verdicts are written where they were
asked for.
- set_program_bindings (opcode 80) lands end to end: EmitProgramBindings on the client,
the FIFTH ROUTE ESCAPE (three tails in three index spaces plus a parallel name array -
no generated row can express it, so op 80's gMGPipeContext slot stays null as
PipeCatalogueTest pins), the wire emitter, the decoder arm that resolves and
NUL-checks every name span, and the applier body that copies the names into the record
(rule C) and advances BindingsSerial.
- The record is emitted AFTER create_shader_state, not before as the draft note said: a
re-issued create clears all three tails because they index into the archive it just
replaced, so bindings published ahead of it are wiped by the create that follows.
- MGPProgramDesc::LinkStatus is filled, and ID-88 is VERIFIED rather than assumed:
ProgramObject::Link()'s prologue bumps m_linkVersion and assigns m_artifacts = {} -
"the complete not-linked state" - before the body runs, and every ProgramLinkTask
failure arm leaves linkStatus false. A failed relink therefore reports unlinked, the
re-issue carries LinkStatus = 0, and nothing needs an object_death.
- ID-87's measurement gets its instrument: the archive's byte count is added to
PipeStats' CsoBlobBytes where the bytes actually exist, one sample per link.
This commit is contained in:
@@ -44,6 +44,9 @@
|
||||
#include <MG_Impl/Pipe/SlotAllocator.h>
|
||||
#include <MG_State/GLState/ProgramState/ProgramArtifactsCodec.h>
|
||||
#include <MG_Util/Debug/Log.h>
|
||||
// P5e (pg): ID-87 asks this package for bytes-per-link measured rather than argued, and the
|
||||
// archive's byte count exists exactly once - here, where it is serialised.
|
||||
#include <MG_Util/Metrics/PipeStats.h>
|
||||
|
||||
#include <atomic>
|
||||
#include <cstdlib>
|
||||
@@ -487,9 +490,11 @@ namespace MobileGL::MG_Remote::Client {
|
||||
// Spirv[i] is Fatal on the far side rather than ignored.
|
||||
void Wire_Escape_CreateShaderState(const MG_Pipe::MGPProgramDesc* desc,
|
||||
const MG_State::GLState::LinkArtifacts* link,
|
||||
const MG_State::GLState::SpirvArtifacts* spirv) {
|
||||
const MG_State::GLState::SpirvArtifacts* spirv,
|
||||
const Uint32* linkedStages, Uint32 linkedStageCount) {
|
||||
if (RunsAsTheServerRole()) {
|
||||
MG_Pipe::MGPipeMonolithEscapes().CreateShaderState(desc, link, spirv);
|
||||
MG_Pipe::MGPipeMonolithEscapes().CreateShaderState(desc, link, spirv, linkedStages,
|
||||
linkedStageCount);
|
||||
return;
|
||||
}
|
||||
ClientSession& session = RequireSession("CreateShaderState");
|
||||
@@ -501,11 +506,23 @@ namespace MobileGL::MG_Remote::Client {
|
||||
"code");
|
||||
std::abort();
|
||||
}
|
||||
// EncodeProgramArtifacts APPENDS and never fails - everything it walks is owned
|
||||
// EncodeProgramArchive APPENDS and never fails - everything it walks is owned
|
||||
// plain data - so an empty archive means the two structs themselves were empty,
|
||||
// which is a linked program with no artefacts and is not a codec question.
|
||||
//
|
||||
// P5e (pg): THE FRAMED form, so the record's own copy on the far side can pair each
|
||||
// module with its stage. The bare EncodeProgramArtifacts is still what the verify
|
||||
// build's round-trip pin uses; this is the one that crosses.
|
||||
Vector<Uint8> archive;
|
||||
MG_State::GLState::EncodeProgramArtifacts(*link, *spirv, archive);
|
||||
Vector<Uint32> stages(linkedStages, linkedStages + linkedStageCount);
|
||||
MG_State::GLState::EncodeProgramArchive(*link, *spirv, stages, archive);
|
||||
if (MG_Util::PipeStats::Enabled()) {
|
||||
// ID-87's measurement, taken where the bytes actually exist rather than
|
||||
// estimated: one sample per link, so the steady-state cost is (links this
|
||||
// frame) x (bytes per link) and both halves are countable from the stats line.
|
||||
MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::CsoBlobBytes,
|
||||
static_cast<Uint64>(archive.size()));
|
||||
}
|
||||
if (archive.empty()) {
|
||||
MGLOG_F("MGPipe: Fatal{ArchiveEmpty, \"create_shader_state\"} - the program's "
|
||||
"artefacts serialised to nothing");
|
||||
@@ -519,6 +536,71 @@ namespace MobileGL::MG_Remote::Client {
|
||||
++g_emitted;
|
||||
}
|
||||
|
||||
// set_program_bindings (P5e, pg). THE FIFTH ESCAPE, for PipeRoute.h's reason: three
|
||||
// tails in three index spaces plus a parallel name array, which no generated
|
||||
// (payload, varTail, varTailCount) row can express.
|
||||
//
|
||||
// THE NAMES ARE STAGED ONE BY ONE and each element's own MGHostSpan names its run, so
|
||||
// the third tail is self-describing the way set_storage_block_binding's single name
|
||||
// already is. Staged rather than packed into one run with offsets, because the honesty
|
||||
// pass the decoder runs is per span and a packed run would have to be re-split there
|
||||
// against arithmetic nothing on the wire declares.
|
||||
void Wire_Escape_SetProgramBindings(const MG_Pipe::MGPProgramBindings* hdr,
|
||||
const Int32* blockBindings,
|
||||
const MG_Pipe::MGPProgramSamplerUnit* samplerUnits,
|
||||
const MG_Pipe::MGPProgramStorageOverride* storageOverrides,
|
||||
const char* const* storageOverrideNames) {
|
||||
if (RunsAsTheServerRole()) {
|
||||
MG_Pipe::MGPipeMonolithEscapes().SetProgramBindings(hdr, blockBindings, samplerUnits,
|
||||
storageOverrides,
|
||||
storageOverrideNames);
|
||||
return;
|
||||
}
|
||||
ClientSession& session = RequireSession("SetProgramBindings");
|
||||
MG_Pipe::MGPProgramBindings record = *hdr;
|
||||
|
||||
// The override tail is COPIED before it is emitted, because the span is the one
|
||||
// field the client must write after the caller is done with it - the same reason
|
||||
// MGP_WIRE_BLOB copies its payload.
|
||||
Vector<MG_Pipe::MGPProgramStorageOverride> overrides;
|
||||
overrides.reserve(record.StorageOverrideCount);
|
||||
for (Uint32 i = 0; i < record.StorageOverrideCount; ++i) {
|
||||
MG_Pipe::MGPProgramStorageOverride entry = storageOverrides[i];
|
||||
const char* const name = storageOverrideNames[i];
|
||||
// Size = strlen + 1: THE NUL TRAVELS, exactly as set_storage_block_binding's
|
||||
// name does (contract table 0's block-name row), and the decoder refuses a run
|
||||
// whose last byte is not NUL.
|
||||
const Uint64 nameBytes = static_cast<Uint64>(std::strlen(name)) + 1ull;
|
||||
const MG_Pipe::MGPBlobRef staged = session.Encoder().StageBytes(name, nameBytes);
|
||||
// A HOST SPAN AND NOT A BLOBREF, which is what the row's kHostSpan flag means:
|
||||
// the same run, described in the shape the decoder's honesty pass reads. Ptr
|
||||
// stays null - rule B, "the encoder writes nullptr and names SEG_STAGE" - so
|
||||
// the name is unreachable on a second process except through the segment table,
|
||||
// which is the whole point of the flag.
|
||||
entry.Name = MG_Pipe::MGHostSpan{};
|
||||
entry.Name.Ptr = nullptr;
|
||||
entry.Name.Seg = staged.Seg;
|
||||
entry.Name.Offset = staged.Offset;
|
||||
entry.Name.Size = staged.Size;
|
||||
overrides.push_back(entry);
|
||||
}
|
||||
|
||||
const Wire::WireTail tails[3] = {
|
||||
{blockBindings, static_cast<Uint64>(record.BlockBindingCount) * sizeof(Int32)},
|
||||
{samplerUnits, static_cast<Uint64>(record.SamplerUnitCount) *
|
||||
sizeof(MG_Pipe::MGPProgramSamplerUnit)},
|
||||
{overrides.empty() ? nullptr : overrides.data(),
|
||||
static_cast<Uint64>(record.StorageOverrideCount) *
|
||||
sizeof(MG_Pipe::MGPProgramStorageOverride)},
|
||||
};
|
||||
// ALWAYS THREE, even when a count is 0 - the decoder derives the third tail's
|
||||
// offset from the first two, so declaring fewer would put the same bytes somewhere
|
||||
// else (PipeWireCodec.cpp's layout arm says this from the other side).
|
||||
session.EmitAndWaitTails(MGPWireOp::SetProgramBindings, &record, sizeof(record), tails, 3,
|
||||
nullptr, 0, nullptr);
|
||||
++g_emitted;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// =====================================================================================
|
||||
@@ -664,6 +746,7 @@ namespace MobileGL::MG_Remote::Client {
|
||||
gMGPipeRouteEscapes.ResourceFlushRange = &Wire_Escape_ResourceFlushRange;
|
||||
gMGPipeRouteEscapes.MapPersistent = &Wire_Escape_MapPersistent;
|
||||
gMGPipeRouteEscapes.CreateShaderState = &Wire_Escape_CreateShaderState;
|
||||
gMGPipeRouteEscapes.SetProgramBindings = &Wire_Escape_SetProgramBindings;
|
||||
|
||||
MGPipeNoteInstalledArm(MGPipeRouteArm::kClientWire);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user