mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-18 15:33:22 +09:00
Conflict: VulkanRenderer.cpp's disaggregated include block took both halves.
Merge coordination (integrator, with the evidence inline):
- hd's Fatal{RoleViolation, MGPipeSlots} guard as landed was kind-blind: it fired on the
G6 frontend-keyed twin registry (texture/VAO/program/sampler resolver probes - P3b/P4b's
to rekey) and on the families whose handle-carrying records the client does not emit
until P4b (the buffer binding-point ensures, the GPU-written announcement). Integration-
split went 104/107 red at the first Clear. Two NAMED, scoped exemptions keep the guard's
teeth for every other caller (SlotAllocator.{h,cpp}): MGPipeReverseAnnouncementScope
(buffer ensure + announcement family, P4b/P7) and MGPipeFrontendKeyedRegistryScope
(the G6 registry family, P3b/P4b; also the mailbox death switch until ct's object_death
record retires it). ~30 resolver sites wrapped, each naming its debt in the comment.
- ScopedRestartIndexSubstitution needed NO exemption: the EBO resolves from the record's
IndexBuffer.Res and the bytes read from the server staged shadow - CONTRACT-P5B d1's
own sentence, implemented.
- Magma's named blit takes a G6 consume arm (frontend FBOs resolved by lifetime id inside
the scope, VerbBlitNamedConsumed set, loud refusal kept for a failed resolution), so the
two DirectVulkan.Split.NamedBlit correctness cases stay green; Magma's hidden blit and
depth-mipmap resources' teardown probes are wrapped and named (P7: give them non-frontend
storage).
- MG_State gains GLContext::FindFramebufferObjectByLifetimeId (behaviour-neutral accessor
for the arm above).
Gates on the merged tree: unit 2166/2166; integration-split 107/107 (2 design skips);
hd's RemoteGuards death tests still abort the unwrapped paths by name; PrimitiveRestart
7/7; the two Magma named-blit cases render. CONTRACT-P5C sections 3, 5.4.
210 lines
12 KiB
C++
210 lines
12 KiB
C++
// MobileGL - MobileGL/MG_Impl/Pipe/SlotAllocator.h
|
|
// Copyright (c) 2025-2026 MobileGL-Dev
|
|
// Licensed under the GNU Lesser General Public License v3.0:
|
|
// https://www.gnu.org/licenses/gpl-3.0.txt
|
|
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
|
// SPDX-License-Identifier: LGPL-3.0-only
|
|
// End of Source File Header
|
|
|
|
#pragma once
|
|
#include <Includes.h>
|
|
|
|
#include <MG_Pipe/MGPipeHandles.h>
|
|
|
|
// The CLIENT's slot allocator: the thing that mints every MGPipeHandle in the system
|
|
// (ARCHITECTURE.md 4.2 - no create_* call in the catalogue returns a server-cast handle,
|
|
// which is what lets the whole catalogue be remoted with zero creation round trips).
|
|
//
|
|
// Per kind: a free list plus a high-water mark, so slots stay DENSE and the server's object
|
|
// table is an array rather than a hash map. It has nothing to do with MG_State's
|
|
// IndexGenerator - that container's LIFO GL-name reuse is the very problem {slot, gen}
|
|
// exists to close, and the whole point of the identity is that an ABA on the GL name, on
|
|
// the heap address or on the lifetime id cannot reproduce a handle.
|
|
//
|
|
// Gen increments ONLY when a slot is reused, never on a respecify: a glBufferData on a live
|
|
// buffer keeps the same {slot, gen}, because the object is the same object. Two generations
|
|
// exist in the design and they are strictly separate - this is the client's answer to "is
|
|
// this still the same GL object"; MGGen is the server's epoch for "did I recast my driver
|
|
// object", and no MGPipe call may require the client to know it.
|
|
//
|
|
// The lifetimeId -> slot map is what keeps a GL NAME out of every key (ARCHITECTURE.md 4.2):
|
|
// the frontend object's lifetime id is the client's own identity for it, so the backend key
|
|
// is the handle and the frontend key is the lifetime id, and neither is a recyclable name.
|
|
//
|
|
// Lives in MG_Impl (the client side, unrestricted) and is compiled only under
|
|
// MOBILEGL_PIPE_PUSH. It is in the P2 CONTRACT commit rather than in a Track H package
|
|
// because both Track H slices - Espryt 0b and Magma subsystem 4 - key off it.
|
|
namespace MobileGL::MG_Pipe {
|
|
|
|
class MGPipeSlotAllocator {
|
|
public:
|
|
static constexpr SizeT kKindCount = static_cast<SizeT>(MGPipeKind::KindCount);
|
|
|
|
// A fresh {slot, gen} of this kind, from the free list if one is waiting and from the
|
|
// high-water mark otherwise. Never returns slot 0 (reserved: null, and the default
|
|
// framebuffer for kind Framebuffer), and never returns a ShaderCso slot inside the
|
|
// composite band, which the program-pipeline resolver mints out of separately.
|
|
MGPipeHandle Allocate(MGPipeKind kind);
|
|
// Allocate and remember `lifetimeId` as this handle's frontend identity.
|
|
MGPipeHandle AllocateFor(MGPipeKind kind, Uint64 lifetimeId);
|
|
|
|
// P4a, D-H7: THE ONE ENTRY POINT INTO THE ShaderCso COMPOSITE BAND, and the only one
|
|
// there will ever be. Allocate() above refuses that band on purpose, so a program
|
|
// pipeline's flattened composite - minted client-side from the stage programs bound to
|
|
// the pipeline object, and indistinguishable from an ordinary program to the server -
|
|
// needs a door of its own rather than a flag on the handle. The kind is implied: only
|
|
// ShaderCso has a band.
|
|
//
|
|
// It behaves exactly like AllocateFor in every other respect (free list first, then
|
|
// the band's own high-water mark; Gen moves only on reuse; the lifetimeId -> slot map
|
|
// is written) and it carries the band's own exhaustion assert, so exhausting the
|
|
// composite space is a NAMED Fatal rather than silent slot theft from ordinary
|
|
// programs. Returns kMGPipeNullHandle when the band is full.
|
|
//
|
|
// Freed through the ordinary Free(MGPipeKind::ShaderCso, handle): a composite's slot
|
|
// has two independent release paths - the pipeline cache's LRU eviction and the
|
|
// composite ProgramObject's own destructor - and Free refusing a slot that is not live
|
|
// at that generation is what makes the second one a proven no-op.
|
|
MGPipeHandle AllocateComposite(Uint64 lifetimeId);
|
|
// The handle a lifetime id was allocated for, or kMGPipeNullHandle. A recycled heap
|
|
// address does NOT reproduce a mapping: MG_State hands out a fresh lifetime id per
|
|
// object, so the map key is unique for the life of the process.
|
|
MGPipeHandle FindByLifetimeId(MGPipeKind kind, Uint64 lifetimeId) const;
|
|
// FindByLifetimeId, then AllocateFor when it misses. The ordinary client path.
|
|
MGPipeHandle Acquire(MGPipeKind kind, Uint64 lifetimeId);
|
|
|
|
// Returns the slot to the free list. The Gen bump happens on the NEXT handout of that
|
|
// slot, not here, so a handle that is freed twice cannot skip a generation and the
|
|
// "gen moves only on reuse" contract holds for an object that is never reused.
|
|
void Free(MGPipeKind kind, MGPipeHandle handle);
|
|
|
|
Bool IsLive(MGPipeKind kind, MGPipeHandle handle) const;
|
|
// 0 for a slot that was never handed out; the generation of the LAST handout
|
|
// otherwise, live or not.
|
|
Uint32 GenOfSlot(MGPipeKind kind, Uint32 slot) const;
|
|
Uint64 LifetimeIdOfSlot(MGPipeKind kind, Uint32 slot) const;
|
|
// One past the highest ORDINARY slot ever handed out of this kind. For every kind but
|
|
// ShaderCso that is the whole story; for ShaderCso the composite band is a second,
|
|
// separately dense space and CompositeHighWater() below answers it.
|
|
//
|
|
// THE TWO SPACES ARE REPORTED SEPARATELY, and that is the point rather than a detail.
|
|
// Folding the band into this number pins it at ~983k from the first composite mint
|
|
// onward, and every later assertion of the "the high-water mark did not move over N
|
|
// churn rounds" shape - the one that catches a dense table that never shrinks, which
|
|
// is the ~1.3 KB-per-record leak C-1 produced - becomes vacuously true for ordinary
|
|
// ShaderCso slots for the rest of the process. A leak case per space is two real
|
|
// assertions; one merged number is one real assertion and one that cannot go red.
|
|
//
|
|
// It is also NOT a table size for kind ShaderCso even now: the band is sparse against
|
|
// the ordinary space by design, so a consumer indexing by slot must test
|
|
// MGPipeIsCompositeShaderSlot(slot) first and keep the band in a table of its own,
|
|
// exactly as this allocator does.
|
|
Uint32 HighWater(MGPipeKind kind) const;
|
|
// One past the highest COMPOSITE slot ever handed out, i.e.
|
|
// kMGPipeShaderCsoCompositeSlotBase + (band slots ever handed out), and exactly the
|
|
// base when none ever was. Kind ShaderCso is the only kind with a band, so it is
|
|
// implied - as it is for AllocateComposite. A LEAKED COMPOSITE MOVES THIS and moves
|
|
// nothing else, which is what the composite's own leak case asserts on.
|
|
Uint32 CompositeHighWater() const;
|
|
// Live slots of this kind, ORDINARY AND COMPOSITE TOGETHER for ShaderCso: a live
|
|
// composite is a live ShaderCso, the applier's two record tables are one object class,
|
|
// and a caller asking "how many shader CSOs does this client hold" wants both. The
|
|
// band's own count is CompositeLiveCount(); the ordinary space's is the difference.
|
|
Uint32 LiveCount(MGPipeKind kind) const;
|
|
Uint32 CompositeLiveCount() const;
|
|
// Slots waiting on a free list. Also BOTH SPACES for ShaderCso, for LiveCount's
|
|
// reason and with the same caveat: a caller that needs to know WHICH space a slot went
|
|
// back to reads CompositeFreeCount() and subtracts.
|
|
Uint32 FreeCount(MGPipeKind kind) const;
|
|
Uint32 CompositeFreeCount() const;
|
|
|
|
// Context teardown / server reset / a unit test's fixture.
|
|
void Reset();
|
|
|
|
private:
|
|
struct SlotState {
|
|
Uint32 Gen = 0;
|
|
Bool Live = false;
|
|
Bool EverHandedOut = false;
|
|
Uint64 LifetimeId = 0;
|
|
};
|
|
|
|
struct KindState {
|
|
// Indexed by slot; [0] is the reserved slot and is never live.
|
|
Vector<SlotState> Slots;
|
|
Vector<Uint32> FreeList;
|
|
// P4a: the ShaderCso COMPOSITE band, indexed by (slot - the band's base) and
|
|
// EMPTY for every other kind. A SECOND VECTOR RATHER THAN MORE OF THE FIRST, and
|
|
// it is not a micro-optimisation: the band starts at 983040, so minting one
|
|
// composite into the slot-indexed vector above would allocate ~983k SlotStates -
|
|
// ~23 MB - for a single program pipeline, and a consumer that sized a table off
|
|
// HighWater would pay the same shape again with a far bigger record. Both spaces
|
|
// stay dense against their own high-water mark, which is the property this
|
|
// allocator exists to give the server.
|
|
Vector<SlotState> BandSlots;
|
|
Vector<Uint32> BandFreeList;
|
|
UnorderedMap<Uint64, Uint32> ByLifetimeId;
|
|
Uint32 LiveCount = 0;
|
|
// The band's share of LiveCount above, so the two spaces can be reported apart
|
|
// without walking either table. Always 0 for every kind but ShaderCso.
|
|
Uint32 BandLiveCount = 0;
|
|
};
|
|
|
|
KindState& StateOf(MGPipeKind kind);
|
|
const KindState& StateOf(MGPipeKind kind) const;
|
|
// The SlotState a (kind, slot) names, in whichever of the two vectors holds it, or
|
|
// null when the slot has never been handed out. One resolver, so a caller that forgets
|
|
// the band cannot exist.
|
|
static SlotState* EntryOf(KindState& state, MGPipeKind kind, Uint32 slot);
|
|
static const SlotState* EntryOf(const KindState& state, MGPipeKind kind, Uint32 slot);
|
|
|
|
Array<KindState, kKindCount> m_kinds{};
|
|
};
|
|
|
|
// The monolith's one client allocator. Under split there is one per client context.
|
|
MGPipeSlotAllocator& MGPipeSlots();
|
|
|
|
#if MOBILEGL_BUILD_DISAGGREGATED
|
|
// P5c (hd, CONTRACT-P5C §3.1 / §6 layer 1): with an active transport this allocator is a
|
|
// CLIENT-only surface. Acquire, FindByLifetimeId and Free called from the apply thread -
|
|
// i.e. a server that resolves or mints handles off a frontend object's lifetime id (T2),
|
|
// which is memory that will not exist on its side of a real split - are
|
|
// Fatal{RoleViolation, "MGPipeSlots"}. Compiled out entirely outside split builds, so the
|
|
// pull build's bytes do not move (G1).
|
|
void MGPipeRefuseAllocatorFromApplyThread(const char* entry);
|
|
|
|
// The NAMED EXEMPTION to the rule above (CONTRACT-P5C §3.1): the family of sites whose
|
|
// handle-carrying records the client does not EMIT yet. set_shader_buffers and
|
|
// set_stream_output_targets exist in the catalogue but are P4b's to emit
|
|
// (SetHashSuppressor.h says so), so the buffer binding-point ensures and the GPU-written
|
|
// announcement they feed have no record handle to resolve from today. Inside this scope
|
|
// ONE read-only lifetime-id probe stays legal; the scope is the debt's measurable,
|
|
// greppable form, and it retires with P4b's emission (Espryt) and P7's server-side
|
|
// binding table (Magma). Every other apply-thread allocator access stays Fatal.
|
|
class MGPipeReverseAnnouncementScope {
|
|
public:
|
|
MGPipeReverseAnnouncementScope();
|
|
~MGPipeReverseAnnouncementScope();
|
|
MGPipeReverseAnnouncementScope(const MGPipeReverseAnnouncementScope&) = delete;
|
|
MGPipeReverseAnnouncementScope& operator=(const MGPipeReverseAnnouncementScope&) = delete;
|
|
static Bool Active();
|
|
};
|
|
|
|
// The SECOND named exemption family (CONTRACT-P5C §5.4): the frontend-keyed twin
|
|
// registry (audit row G6). The texture / sampler-view / FBO-legacy HandleOf probes are
|
|
// how the server answers "which twin is this frontend object" while the registry is
|
|
// keyed by frontend identity - server-PRIVATE state whose rekey onto handles is
|
|
// P3b/P4b's, not P5c's. A probe inside this scope stays a read-only, barrier-held debt;
|
|
// wrapping a NEW site in it is the greppable act of naming that debt, and an unwrapped
|
|
// probe from the apply thread is still Fatal{RoleViolation, "MGPipeSlots"}.
|
|
class MGPipeFrontendKeyedRegistryScope {
|
|
public:
|
|
MGPipeFrontendKeyedRegistryScope();
|
|
~MGPipeFrontendKeyedRegistryScope();
|
|
MGPipeFrontendKeyedRegistryScope(const MGPipeFrontendKeyedRegistryScope&) = delete;
|
|
MGPipeFrontendKeyedRegistryScope& operator=(const MGPipeFrontendKeyedRegistryScope&) = delete;
|
|
static Bool Active();
|
|
};
|
|
#endif
|
|
} // namespace MobileGL::MG_Pipe
|