fix(rendering): bound portal resource lifetime

Separate logical ownership, render publication, and GPU retirement across live entities, landblocks, particles, textures, mesh arenas, portal/UI teardown, and per-frame scratch storage. Add bounded DAT/texture caches, upload budgets, three-frame fence retirement, exact-incarnation appearance reconciliation, frame pacing, and extensive lifetime conformance coverage.\n\nThe seven-destination connected route now cuts peak working/private memory roughly in half, returns Caul to 125-153 FPS locally, and produces no WER or AMD reset.\n\nCo-authored-by: OpenAI Codex <codex@openai.com>
2026-07-18 21:35:16 +02:00 · 2026-07-18 21:35:16 +02:00 · 749e8ceeb1
commit 749e8ceeb1
parent 3971997689
225 changed files with 29107 additions and 3914 deletions
--- a/tests/AcDream.App.Tests/Rendering/GpuResourceRetirementTransactionTests.cs
+++ b/tests/AcDream.App.Tests/Rendering/GpuResourceRetirementTransactionTests.cs
@ -0,0 +1,372 @@
+using AcDream.App.Rendering;
+using AcDream.App.Rendering.Wb;
+using Silk.NET.OpenGL;
+
+namespace AcDream.App.Tests.Rendering;
+
+public sealed class GpuResourceRetirementTransactionTests
+{
+    [Theory]
+    [InlineData(0)]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(3)]
+    public void Release_RetryResumesAtFirstUncommittedStage(int failingStage)
+    {
+        int[] calls = new int[4];
+        bool failed = false;
+        Action[] stages = Enumerable.Range(0, calls.Length)
+            .Select<int, Action>(stage => () =>
+            {
+                calls[stage]++;
+                if (stage == failingStage && !failed)
+                {
+                    failed = true;
+                    throw new InvalidOperationException($"stage {stage}");
+                }
+            })
+            .ToArray();
+        var release = new RetryableGpuResourceRelease(stages);
+
+        Assert.Throws<InvalidOperationException>(release.Run);
+        Assert.Equal(failingStage, release.CompletedStageCount);
+
+        release.Run();
+
+        Assert.True(release.IsComplete);
+        for (int stage = 0; stage < calls.Length; stage++)
+            Assert.Equal(stage == failingStage ? 2 : 1, calls[stage]);
+    }
+
+    [Fact]
+    public void Ledger_QueueInsertionFailureRetainsReleaseForPublicationRetry()
+    {
+        var queue = new FailBeforeAcceptQueue();
+        var ledger = new GpuRetirementLedger(queue);
+        int releases = 0;
+
+        Assert.Throws<InvalidOperationException>(() =>
+            ledger.Retire(new RetryableGpuResourceRelease(() => releases++)));
+        Assert.Equal(1, ledger.AwaitingPublicationCount);
+        Assert.Equal(0, releases);
+
+        ledger.RetryPendingPublications();
+        Assert.Equal(0, ledger.AwaitingPublicationCount);
+        Assert.Single(queue.Actions);
+
+        queue.Actions.Single()();
+        Assert.Equal(1, releases);
+    }
+
+    [Fact]
+    public void Ledger_ImmediateCallbackFailureRetainsCommittedStageCursor()
+    {
+        var ledger = new GpuRetirementLedger(ImmediateGpuResourceRetirementQueue.Instance);
+        int first = 0;
+        int second = 0;
+        bool failSecond = true;
+        var release = new RetryableGpuResourceRelease(
+            () => first++,
+            () =>
+            {
+                second++;
+                if (failSecond)
+                {
+                    failSecond = false;
+                    throw new InvalidOperationException("second stage");
+                }
+            });
+
+        Assert.Throws<InvalidOperationException>(() => ledger.Retire(release));
+        Assert.Equal(1, ledger.AwaitingPublicationCount);
+        Assert.Equal(1, release.CompletedStageCount);
+
+        ledger.RetryPendingPublications();
+        Assert.Equal(0, ledger.AwaitingPublicationCount);
+        Assert.Equal(1, first);
+        Assert.Equal(2, second);
+    }
+
+    [Fact]
+    public void Release_ReentrantDrainDoesNotReplayActiveStage()
+    {
+        RetryableGpuResourceRelease? release = null;
+        int active = 0;
+        int tail = 0;
+        release = new RetryableGpuResourceRelease(
+            () =>
+            {
+                active++;
+                release!.Run();
+            },
+            () => tail++);
+
+        release.Run();
+
+        Assert.True(release.IsComplete);
+        Assert.Equal(1, active);
+        Assert.Equal(1, tail);
+    }
+
+    [Fact]
+    public void Release_PostMutationValidationFailureDoesNotReplayMutationStage()
+    {
+        int mutations = 0;
+        int validations = 0;
+        int accounting = 0;
+        var release = new RetryableGpuResourceRelease(
+            () => mutations++,
+            () =>
+            {
+                validations++;
+                if (validations == 1)
+                    throw new InvalidOperationException("post-mutation validation");
+            },
+            () => accounting++);
+
+        Assert.Throws<InvalidOperationException>(release.Run);
+        release.Run();
+
+        Assert.Equal(1, mutations);
+        Assert.Equal(2, validations);
+        Assert.Equal(1, accounting);
+        Assert.True(release.IsComplete);
+    }
+
+    [Fact]
+    public void Ledger_RetryAttemptsEveryPendingPublicationDespiteOneFailure()
+    {
+        var queue = new FailFirstNQueue(3);
+        var ledger = new GpuRetirementLedger(queue);
+        Assert.Throws<InvalidOperationException>(() =>
+            ledger.Retire(new RetryableGpuResourceRelease(() => { })));
+        Assert.Throws<InvalidOperationException>(() =>
+            ledger.Retire(new RetryableGpuResourceRelease(() => { })));
+
+        AggregateException error = Assert.Throws<AggregateException>(
+            ledger.RetryPendingPublications);
+
+        Assert.Single(error.InnerExceptions);
+        Assert.Equal(1, ledger.AwaitingPublicationCount);
+        Assert.Single(queue.Actions);
+
+        ledger.RetryPendingPublications();
+        Assert.Equal(0, ledger.AwaitingPublicationCount);
+        Assert.Equal(2, queue.Actions.Count);
+    }
+
+    [Fact]
+    public void Ledger_RetrySpecificPublicationDoesNotRepublishOtherRelease()
+    {
+        var queue = new FailFirstNQueue(2);
+        var ledger = new GpuRetirementLedger(queue);
+        var first = new RetryableGpuResourceRelease(() => { });
+        var second = new RetryableGpuResourceRelease(() => { });
+        Assert.Throws<InvalidOperationException>(() => ledger.Retire(first));
+        Assert.Throws<InvalidOperationException>(() => ledger.Retire(second));
+
+        ledger.RetryPendingPublication(first);
+
+        Assert.Equal(1, ledger.AwaitingPublicationCount);
+        Assert.Single(queue.Actions);
+        ledger.RetryPendingPublication(second);
+        Assert.Equal(0, ledger.AwaitingPublicationCount);
+        Assert.Equal(2, queue.Actions.Count);
+    }
+
+    [Fact]
+    public void Ledger_BatchOwnsEveryReleaseBeforePublishingFirst()
+    {
+        var queue = new FailFirstNQueue(1);
+        var ledger = new GpuRetirementLedger(queue);
+        var first = new RetryableGpuResourceRelease(() => { });
+        var second = new RetryableGpuResourceRelease(() => { });
+
+        Assert.Throws<AggregateException>(() => ledger.RetireMany([first, second]));
+
+        Assert.Equal(1, ledger.AwaitingPublicationCount);
+        Assert.Single(queue.Actions);
+        ledger.RetryPendingPublications();
+        Assert.Equal(2, queue.Actions.Count);
+    }
+
+    [Fact]
+    public void GlQueue_PersistentNextPassRetryDoesNotStarveOrdinaryWork()
+    {
+        var device = new QueueOnlyGraphicsDevice();
+        int retryCalls = 0;
+        int ordinaryCalls = 0;
+        Action<GL>? retry = null;
+        retry = _ =>
+        {
+            retryCalls++;
+            device.QueueGLActionForNextPass(retry!);
+        };
+        device.QueueGLActionForNextPass(retry);
+        device.QueueGLAction(_ => ordinaryCalls++);
+
+        device.ProcessGLQueue();
+
+        Assert.Equal(1, retryCalls);
+        Assert.Equal(1, ordinaryCalls);
+        Assert.True(device.HasPendingGLWork);
+    }
+
+    [Fact]
+    public void GlQueue_ReportsPendingWorkUntilBothGenerationsDrain()
+    {
+        var device = new QueueOnlyGraphicsDevice();
+        device.QueueGLAction(_ => { });
+
+        Assert.True(device.HasPendingGLWork);
+        device.ProcessGLQueue();
+
+        Assert.False(device.HasPendingGLWork);
+    }
+
+    [Fact]
+    public void MigrationAbortTicket_RetainsBufferUntilEveryReleaseStageConverges()
+    {
+        int deleteCalls = 0;
+        int accountingCalls = 0;
+        bool failAccounting = true;
+        var ticket = new GlobalMeshMigrationAbortTicket(
+            buffer: 37,
+            capacityBytes: 4096,
+            new RetryableGpuResourceRelease(
+                () => deleteCalls++,
+                () =>
+                {
+                    if (failAccounting)
+                    {
+                        failAccounting = false;
+                        throw new InvalidOperationException("injected accounting failure");
+                    }
+                    accountingCalls++;
+                }));
+
+        Assert.Throws<InvalidOperationException>(ticket.Advance);
+        Assert.False(ticket.IsComplete);
+        Assert.Equal((uint)37, ticket.Buffer);
+        Assert.Equal(4096, ticket.CapacityBytes);
+        Assert.Equal(1, deleteCalls);
+        Assert.Equal(0, accountingCalls);
+
+        ticket.Advance();
+        ticket.Advance();
+
+        Assert.True(ticket.IsComplete);
+        Assert.Equal(1, deleteCalls);
+        Assert.Equal(1, accountingCalls);
+    }
+
+    [Fact]
+    public void MigrationAbortTicket_DeleteValidationFailureRetriesBeforeAccounting()
+    {
+        int deleteCalls = 0;
+        int accountingCalls = 0;
+        bool failDeleteValidation = true;
+        var ticket = new GlobalMeshMigrationAbortTicket(
+            buffer: 41,
+            capacityBytes: 8192,
+            new RetryableGpuResourceRelease(
+                () =>
+                {
+                    deleteCalls++;
+                    if (failDeleteValidation)
+                    {
+                        failDeleteValidation = false;
+                        throw new InvalidOperationException("injected GL delete validation failure");
+                    }
+                },
+                () => accountingCalls++));
+
+        Assert.Throws<InvalidOperationException>(ticket.Advance);
+        Assert.False(ticket.IsComplete);
+        Assert.Equal(1, deleteCalls);
+        Assert.Equal(0, accountingCalls);
+
+        ticket.Advance();
+
+        Assert.True(ticket.IsComplete);
+        Assert.Equal(2, deleteCalls);
+        Assert.Equal(1, accountingCalls);
+    }
+
+    [Fact]
+    public void GlobalMeshVaoAccounting_CreateAndRetryableDeleteBalanceExactlyOnce()
+    {
+        int baseline = GpuMemoryTracker.VaoCount;
+        bool allocationOutstanding = true;
+        GlobalMeshVaoAccounting.TrackAllocation();
+        try
+        {
+            Assert.Equal(baseline + 1, GpuMemoryTracker.VaoCount);
+            var release = new RetryableGpuResourceRelease(
+                () => { },
+                () =>
+                {
+                    GlobalMeshVaoAccounting.TrackDeallocation();
+                    allocationOutstanding = false;
+                });
+
+            release.Run();
+            release.Run();
+
+            Assert.Equal(baseline, GpuMemoryTracker.VaoCount);
+        }
+        finally
+        {
+            if (allocationOutstanding)
+                GlobalMeshVaoAccounting.TrackDeallocation();
+        }
+    }
+
+    [Fact]
+    public void GlobalMeshVaoAccounting_InitializationRollbackReturnsToBaseline()
+    {
+        int baseline = GpuMemoryTracker.VaoCount;
+        GlobalMeshVaoAccounting.TrackAllocation();
+
+        GlobalMeshVaoAccounting.TrackDeallocation();
+
+        Assert.Equal(baseline, GpuMemoryTracker.VaoCount);
+    }
+
+    private sealed class FailBeforeAcceptQueue : IGpuResourceRetirementQueue
+    {
+        private bool _fail = true;
+        public List<Action> Actions { get; } = [];
+
+        public void Retire(Action release)
+        {
+            if (_fail)
+            {
+                _fail = false;
+                throw new InvalidOperationException("queue insertion");
+            }
+            Actions.Add(release);
+        }
+    }
+
+    private sealed class FailFirstNQueue(int failures) : IGpuResourceRetirementQueue
+    {
+        private int _remaining = failures;
+        public List<Action> Actions { get; } = [];
+
+        public void Retire(Action release)
+        {
+            if (_remaining-- > 0)
+                throw new InvalidOperationException("synthetic queue publication failure");
+            Actions.Add(release);
+        }
+    }
+
+    private sealed class QueueOnlyGraphicsDevice : OpenGLGraphicsDevice
+    {
+        public QueueOnlyGraphicsDevice()
+            : base()
+        {
+        }
+    }
+}