mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-16 14:33:24 +09:00
[Merge] (P11): dev@c14283ee - scattered sub-image writes upload exactly their texels, Magma submits a frame's recording every 16384 draws with backpressure, and Magma grows descriptor pools geometrically and trims a quiet slot whole; the handle arm notes driver-side writes by handle and the wire arm splits recordings and keeps the trim's epoch peak across descriptor rewinds
This commit is contained in:
@@ -6457,20 +6457,24 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
#endif
|
||||
|
||||
// Replaces one level's shadow bytes with what the driver texture holds for it, then copies
|
||||
// back the client writes the driver has not been sent yet (the level's pending rects, the
|
||||
// same boxes a plain sync would upload over the driver's copy). Returns false, leaving the
|
||||
// shadow untouched, when the driver's copy cannot stand in for the shadow: the client owns
|
||||
// every byte of the level, the level is stored compressed, the driver has no image at this
|
||||
// level and extent (defined after the last sync), or the readback cannot be served (a
|
||||
// multisample image, a format the driver will not attach to a framebuffer).
|
||||
// back the client writes the driver has not been sent yet - exactly the texels written
|
||||
// (the level's dirty footprint), not the union box or the rect list, which also span texels
|
||||
// the client never wrote and which only the driver's copy holds correctly. Returns false,
|
||||
// leaving the shadow untouched, when the driver's copy cannot stand in for the shadow: the
|
||||
// client wrote every texel of the level, the level is stored compressed, the driver has no
|
||||
// image at this level and extent (defined after the last sync), or the readback cannot be
|
||||
// served (a multisample image, a format the driver will not attach to a framebuffer).
|
||||
//
|
||||
// P11 M, `pipePending` (push builds): THE CLIENT WRITES THE DRIVER HAS NOT BEEN SENT MAY
|
||||
// LIVE IN THE APPLIER'S PENDING SET INSTEAD. On the texture handle arm the client clears its
|
||||
// own dirty flags when it emits a level (D-D5), so the frontend model below answers "clean"
|
||||
// for a write that is still only in the shadow; the entry the applier accumulated for this
|
||||
// (uploadTarget, level) names the same shadow-grid boxes. Both are merged over the
|
||||
// snapshot, and an entry whose union box covers the level owns every byte of it, exactly as
|
||||
// a covering dirty region does. Null on the pull build's arm and the legacy arm.
|
||||
// snapshot. Only a box-only entry whose box IS the level owns every byte of it (dev's rule:
|
||||
// a union box spanning the level with gaps in it is not a whole-level write); an entry with
|
||||
// regions never short-circuits, since accumulated regions may overlap and their texels do
|
||||
// not add up - the readback and the merge below give the same bytes when they do cover it.
|
||||
// Null on the pull build's arm and the legacy arm.
|
||||
static Bool AdoptDriverLevelIntoShadow(GLuint backendTextureId, BackendTextureObject& backendTexture,
|
||||
const MG_State::GLState::ITextureObject& stateTextureObject,
|
||||
MG_State::GLState::TextureObjectMipmap& mipmapObject,
|
||||
@@ -6482,11 +6486,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
) {
|
||||
const IntVec3 texelSize = mipmapObject.GetMipmapTexelSize(uploadTarget, level);
|
||||
const IntVec3 extent{texelSize.x(), texelSize.y(), std::max(texelSize.z(), 1)};
|
||||
const Bool dirty = mipmapObject.IsStorageDirty(uploadTarget, level);
|
||||
const MG_State::GLState::MipmapDirtyRegion dirtyRegion =
|
||||
dirty ? mipmapObject.GetStorageDirtyRegion(uploadTarget, level)
|
||||
: MG_State::GLState::MipmapDirtyRegion{};
|
||||
if (dirty && dirtyRegion.CoversWholeLevel(extent)) return false;
|
||||
const SizeT texelCount =
|
||||
static_cast<SizeT>(extent.x()) * static_cast<SizeT>(extent.y()) * static_cast<SizeT>(extent.z());
|
||||
Vector<MG_State::GLState::MipmapDirtyRegion> pending;
|
||||
mipmapObject.GetStorageDirtyFootprint(uploadTarget, level, pending);
|
||||
// Disjoint boxes, so their texels add up; a union box spanning the level is not enough.
|
||||
SizeT pendingTexels = 0;
|
||||
for (const auto& box : pending) {
|
||||
pendingTexels += box.TexelCount();
|
||||
}
|
||||
if (!pending.empty() && pendingTexels >= texelCount) return false;
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
// Every box the entry names, checked against the level before anything is read: a box
|
||||
// outside it is a corrupt record, and the answer is the pre-readback one (keep the
|
||||
@@ -6511,8 +6520,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (box.X == 0 && box.Y == 0 && box.Z == 0 && box.W == static_cast<Uint32>(extent.x()) &&
|
||||
box.H == static_cast<Uint32>(extent.y()) && box.D == static_cast<Uint32>(extent.z())) {
|
||||
if (pipePending->Regions.empty() && box.X == 0 && box.Y == 0 && box.Z == 0 &&
|
||||
box.W == static_cast<Uint32>(extent.x()) && box.H == static_cast<Uint32>(extent.y()) &&
|
||||
box.D == static_cast<Uint32>(extent.z())) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -6546,28 +6556,18 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
return false;
|
||||
}
|
||||
const SizeT shadowBytes = mipmapObject.GetMipmapByteSize(uploadTarget, level);
|
||||
const SizeT texelCount =
|
||||
static_cast<SizeT>(extent.x()) * static_cast<SizeT>(extent.y()) * static_cast<SizeT>(extent.z());
|
||||
auto* shadow = static_cast<Uint8*>(mipmapObject.MapMipmapData(uploadTarget, level));
|
||||
if (shadow == nullptr || snapshot.size() != shadowBytes || texelCount == 0 || shadowBytes % texelCount) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (dirty) {
|
||||
// The rects index the SHADOW's texel grid (a 1D array's layers are its rows), which
|
||||
if (!pending.empty()) {
|
||||
// The boxes index the SHADOW's texel grid (a 1D array's layers are its rows), which
|
||||
// is also the snapshot's byte order.
|
||||
const SizeT bpp = shadowBytes / texelCount;
|
||||
const SizeT rowBytes = static_cast<SizeT>(extent.x()) * bpp;
|
||||
const SizeT sliceBytes = static_cast<SizeT>(extent.y()) * rowBytes;
|
||||
constexpr SizeT kMaxPending = MG_State::GLState::MipmapStorage::kMaxDirtyRects;
|
||||
MG_State::GLState::MipmapDirtyRegion pending[kMaxPending];
|
||||
SizeT pendingCount = mipmapObject.GetStorageDirtyRects(uploadTarget, level, pending, kMaxPending);
|
||||
if (pendingCount == 0) {
|
||||
pending[0] = dirtyRegion;
|
||||
pendingCount = 1;
|
||||
}
|
||||
for (SizeT i = 0; i < pendingCount; ++i) {
|
||||
const auto& box = pending[i];
|
||||
for (const auto& box : pending) {
|
||||
if (box.Empty()) continue;
|
||||
const SizeT spanBytes = static_cast<SizeT>(box.hi.x() - box.lo.x()) * bpp;
|
||||
for (Int z = box.lo.z(); z < box.hi.z(); ++z) {
|
||||
@@ -8758,6 +8758,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
ApplyImageBindableStorageWidening(imageWidening, &glInternalFormat, &glFormat, &glType);
|
||||
const auto& uploadTargets = MGB_UPLOAD_TARGETS(textureMipmapObject);
|
||||
ScopedDefaultUnpackState unpackState;
|
||||
// Per-level scratch of the exact-footprint path, hoisted to reuse capacity.
|
||||
Vector<MG_State::GLState::MipmapDirtyRegion> dirtyFootprint;
|
||||
Vector<UnpackStagingBlock> stagingBlockOverflow;
|
||||
for (auto& uploadTarget : uploadTargets) {
|
||||
for (SizeT level = 0; level < mipmapCount; ++level) {
|
||||
if (!MGB_LEVEL_NEEDS_UPLOAD(textureMipmapObject, uploadTarget, level)) {
|
||||
@@ -8890,13 +8893,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
const SizeT texelCount = static_cast<SizeT>(texelSize.x()) *
|
||||
static_cast<SizeT>(texelSize.y()) *
|
||||
static_cast<SizeT>(std::max(texelSize.z(), 1));
|
||||
const Bool subRectEligible =
|
||||
!dirtyRegion.Empty() && !dirtyRegion.CoversWholeLevel(texelSize) && texelCount > 0 &&
|
||||
uploadBytes > 0 && uploadBytes % texelCount == 0 &&
|
||||
// Whether a box of the level can be addressed at all: whole texels in
|
||||
// the upload bytes, and an ES image shaped like the shadow.
|
||||
const Bool regionsAddressable =
|
||||
!dirtyRegion.Empty() && texelCount > 0 && uploadBytes > 0 &&
|
||||
uploadBytes % texelCount == 0 &&
|
||||
(layersAsRows ? std::max(texelSize.z(), 1) == 1
|
||||
: uploadSize.x() == texelSize.x() && uploadSize.y() == texelSize.y() &&
|
||||
std::max(uploadSize.z(), 1) == std::max(texelSize.z(), 1));
|
||||
const SizeT bpp = subRectEligible ? uploadBytes / texelCount : 0;
|
||||
const Bool subRectEligible = regionsAddressable && !dirtyRegion.CoversWholeLevel(texelSize);
|
||||
const SizeT bpp = regionsAddressable ? uploadBytes / texelCount : 0;
|
||||
const IntVec3 regionSize = {dirtyRegion.hi.x() - dirtyRegion.lo.x(),
|
||||
dirtyRegion.hi.y() - dirtyRegion.lo.y(),
|
||||
dirtyRegion.hi.z() - dirtyRegion.lo.z()};
|
||||
@@ -9065,6 +9071,50 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
dirtyRectCount = 0;
|
||||
}
|
||||
}
|
||||
// Everything above - the union box, the ring's one-box rule, the rect
|
||||
// list with its merges, fold and 3/4 cut-off - may upload shadow texels
|
||||
// the client did not write, which is only harmless while the driver
|
||||
// still holds those texels as they were last uploaded. Once it may hold
|
||||
// GPU writes, the level goes up as exactly the texels written, one box
|
||||
// (one ring job) each, whatever that costs: more boxes, and a union box
|
||||
// that spans the whole level no longer means a whole-level upload.
|
||||
const MG_State::GLState::MipmapDirtyRegion* uploadRects = dirtyRects;
|
||||
SizeT uploadRectCount = dirtyRectCount;
|
||||
if (m_driverMayHoldGpuWrites && regionsAddressable) {
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
if (pendingUpload != nullptr) {
|
||||
// The handle arm's footprint is the record's region list, all
|
||||
// of it and in order (MGB_RECT_SRC_PTR indexes the regions by
|
||||
// position); a box-only entry is its union box.
|
||||
dirtyFootprint.clear();
|
||||
for (const auto& region : pendingUpload->Regions) {
|
||||
dirtyFootprint.push_back(MG_State::GLState::MipmapDirtyRegion{
|
||||
IntVec3{region.X, region.Y, region.Z},
|
||||
IntVec3{region.X + static_cast<Int32>(region.W),
|
||||
region.Y + static_cast<Int32>(region.H),
|
||||
region.Z + static_cast<Int32>(region.D)}});
|
||||
}
|
||||
} else
|
||||
#endif
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
// With an active transport and no record behind the level, the
|
||||
// server's own whole-level GPU-dirty mark is the whole story (the
|
||||
// same reason the rect list above is not read here).
|
||||
if (MGB_STAGED_TEXTURE_LIVE) {
|
||||
dirtyFootprint.clear();
|
||||
} else
|
||||
#endif
|
||||
textureMipmapObject->GetStorageDirtyFootprint(uploadTarget, level, dirtyFootprint);
|
||||
// One box is the union box itself, which the branches below already
|
||||
// upload exactly (as the whole level when it is the whole level).
|
||||
if (dirtyFootprint.size() >= 2) {
|
||||
uploadRects = dirtyFootprint.data();
|
||||
uploadRectCount = dirtyFootprint.size();
|
||||
} else {
|
||||
uploadRectCount = 0;
|
||||
}
|
||||
}
|
||||
const Bool perRectUpload = regionsAddressable && uploadRectCount >= 2;
|
||||
const auto rectUploadPtr = [&](const MG_State::GLState::MipmapDirtyRegion& rect) {
|
||||
return static_cast<const Uint8*>(uploadData) +
|
||||
static_cast<SizeT>(rect.lo.z()) * levelSliceBytes +
|
||||
@@ -9129,15 +9179,21 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// client-pointer path makes the driver walk, which strides over
|
||||
// the whole level width.
|
||||
UnpackStagingBlock
|
||||
stagingBlocks[MG_State::GLState::MipmapStorage::kMaxDirtyRects];
|
||||
stagingBlockArray[MG_State::GLState::MipmapStorage::kMaxDirtyRects];
|
||||
UnpackStagingBlock* stagingBlocks = stagingBlockArray;
|
||||
SizeT stagingBlockCount = 0;
|
||||
const Bool ringUsable = BufferImpl::UnpackRingAvailable();
|
||||
if (!ringUsable) {
|
||||
// Nothing to plan: every branch below keeps the client
|
||||
// pointer and its ROW_LENGTH striding, unchanged.
|
||||
} else if (subRectEligible && dirtyRectCount >= 2) {
|
||||
for (SizeT r = 0; r < dirtyRectCount; ++r) {
|
||||
const auto& rect = dirtyRects[r];
|
||||
} else if (perRectUpload) {
|
||||
// Only an exact footprint outgrows the array (see uploadRects).
|
||||
if (uploadRectCount > MG_State::GLState::MipmapStorage::kMaxDirtyRects) {
|
||||
stagingBlockOverflow.resize(uploadRectCount);
|
||||
stagingBlocks = stagingBlockOverflow.data();
|
||||
}
|
||||
for (SizeT r = 0; r < uploadRectCount; ++r) {
|
||||
const auto& rect = uploadRects[r];
|
||||
stagingBlocks[r] = {
|
||||
MGB_RECT_SRC_PTR(r, rect),
|
||||
static_cast<SizeT>(rect.hi.x() - rect.lo.x()) * bpp,
|
||||
@@ -9147,7 +9203,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
levelSliceBytes,
|
||||
0};
|
||||
}
|
||||
stagingBlockCount = dirtyRectCount;
|
||||
stagingBlockCount = uploadRectCount;
|
||||
} else if (subRectEligible) {
|
||||
stagingBlocks[0] = {regionPtr,
|
||||
static_cast<SizeT>(regionSize.x()) * bpp,
|
||||
@@ -9224,10 +9280,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
switch (MapToBackendTextureTarget(MGB_TEXTURE_TARGET(stateTextureObject))) {
|
||||
case TextureTarget::Texture2D:
|
||||
case TextureTarget::TextureCubeMap:
|
||||
if (subRectEligible && dirtyRectCount >= 2) {
|
||||
if (perRectUpload) {
|
||||
if (!ringStaged) g_GLESFuncs.glPixelStorei(GL_UNPACK_ROW_LENGTH, texelSize.x());
|
||||
for (SizeT r = 0; r < dirtyRectCount; ++r) {
|
||||
const auto& rect = dirtyRects[r];
|
||||
for (SizeT r = 0; r < uploadRectCount; ++r) {
|
||||
const auto& rect = uploadRects[r];
|
||||
g_GLESFuncs.glTexSubImage2D(
|
||||
glUploadTarget, static_cast<GLint>(level), rect.lo.x(),
|
||||
rect.lo.y(), static_cast<GLsizei>(rect.hi.x() - rect.lo.x()),
|
||||
@@ -9263,18 +9319,18 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// ES 3.2 has GL_TEXTURE_CUBE_MAP_ARRAY natively and it stores exactly
|
||||
// like a 2D array whose depth is 6 * the cube count.
|
||||
case TextureTarget::TextureCubeMapArray:
|
||||
if (subRectEligible && dirtyRectCount >= 2) {
|
||||
if (perRectUpload) {
|
||||
if (!ringStaged) {
|
||||
g_GLESFuncs.glPixelStorei(GL_UNPACK_ROW_LENGTH, texelSize.x());
|
||||
g_GLESFuncs.glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, imageHeight);
|
||||
}
|
||||
for (SizeT r = 0; r < dirtyRectCount; ++r) {
|
||||
const auto box = ToBackendBox(dirtyRects[r]);
|
||||
for (SizeT r = 0; r < uploadRectCount; ++r) {
|
||||
const auto box = ToBackendBox(uploadRects[r]);
|
||||
g_GLESFuncs.glTexSubImage3D(
|
||||
glUploadTarget, static_cast<GLint>(level), box.x, box.y, box.z,
|
||||
box.w, box.h, box.d, glFormat, glType,
|
||||
ringStaged ? UnpackRingPixelOffset(stagingBlocks[r].offset)
|
||||
: static_cast<const void*>(MGB_RECT_SRC_PTR(r, dirtyRects[r])));
|
||||
: static_cast<const void*>(MGB_RECT_SRC_PTR(r, uploadRects[r])));
|
||||
}
|
||||
if (!ringStaged) {
|
||||
g_GLESFuncs.glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
||||
@@ -10273,6 +10329,21 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
g_boundTexturesCache;
|
||||
TwinRegistry<MG_State::GLState::ITextureObject, BackendTextureObject, MG_Pipe::MGPipeKind::Texture> g_backendTextureObjects;
|
||||
|
||||
void NoteDriverSideTextureWrite(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject) {
|
||||
SharedPtr<MG_State::GLState::ITextureObject> storage = textureObject;
|
||||
// Bounded: GL resolves a view of a view to the original storage, so this takes one step.
|
||||
for (Uint hop = 0; storage && storage->IsTextureView() && hop < 4; ++hop) {
|
||||
storage = storage->GetViewStorageOwner();
|
||||
}
|
||||
if (!storage) return;
|
||||
auto* slot = g_backendTextureObjects.Find(storage.get());
|
||||
auto& backendObj = slot ? *slot : g_backendTextureObjects.GetOrCreate(storage);
|
||||
if (!backendObj) {
|
||||
backendObj = MakeShared<BackendTextureObject>();
|
||||
}
|
||||
backendObj->NoteDriverSideWrite();
|
||||
}
|
||||
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
// P5e (id), CONTRACT-P5E §4.1. See Managers.h for the contract.
|
||||
BackendTextureObject* ResolveTextureTwin(MG_Pipe::MGPipeHandle res) {
|
||||
@@ -10293,6 +10364,18 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
if (!*slot) *slot = MakeShared<BackendTextureObject>();
|
||||
return slot->get();
|
||||
}
|
||||
|
||||
void NoteDriverSideTextureWriteByHandle(MG_Pipe::MGPipeHandle res) {
|
||||
// The storage owner's handle, one hop per view like the frontend walk above (the
|
||||
// client composes a view of a view onto its root, so one hop is the real shape).
|
||||
MG_Pipe::MGPipeHandle storage = res;
|
||||
for (Uint hop = 0; hop < 4 && !MG_Pipe::MGPipeHandleIsNull(storage); ++hop) {
|
||||
const auto* record = PipeTextureRecordForHandle(storage);
|
||||
if (record == nullptr || MG_Pipe::MGPipeHandleIsNull(record->Desc.ViewOf)) break;
|
||||
storage = record->Desc.ViewOf;
|
||||
}
|
||||
if (auto* twin = ResolveTextureTwin(storage)) twin->NoteDriverSideWrite();
|
||||
}
|
||||
#endif
|
||||
} // namespace TextureImpl
|
||||
|
||||
@@ -10477,6 +10560,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
return false;
|
||||
}
|
||||
backendTextureObject->SyncMipmapsToBackend(textureObject);
|
||||
// From here on every draw, clear and blit into this framebuffer can write the
|
||||
// texture behind the shadow's back.
|
||||
TextureImpl::NoteDriverSideTextureWrite(textureObject);
|
||||
if (attachmentObject.IsLayered()) {
|
||||
g_GLESFuncs.glFramebufferTexture(glFBOTarget, glBackendAttachment,
|
||||
backendTextureObject->GetBackendTextureId(),
|
||||
@@ -10856,6 +10942,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
if (MG_Config::Transport != MG_Config::TransportMode::Monolith) {
|
||||
backendTextureObject->SyncMipmapsToBackendByHandle(surface.Res);
|
||||
// From here on every draw, clear and blit into this framebuffer can write the
|
||||
// texture behind the staged shadow's back (the frontend arm's note, by handle).
|
||||
TextureImpl::NoteDriverSideTextureWriteByHandle(surface.Res);
|
||||
} else
|
||||
#endif
|
||||
{
|
||||
@@ -10872,6 +10961,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
return false;
|
||||
}
|
||||
backendTextureObject->SyncMipmapsToBackend(monolithTexture);
|
||||
// From here on every draw, clear and blit into this framebuffer can write the
|
||||
// texture behind the shadow's back.
|
||||
TextureImpl::NoteDriverSideTextureWrite(monolithTexture);
|
||||
}
|
||||
const auto uploadTarget = static_cast<TextureUploadTarget>(surface.UploadTarget);
|
||||
if (surface.Layered != 0) {
|
||||
|
||||
Reference in New Issue
Block a user