feat(render): unify physical residency accounting

tests/AcDream.App.Tests/Rendering/CompositeTextureArrayCachePolicyTests.cs

@@ -6,6 +6,40 @@ namespace AcDream.App.Tests.Rendering;
 
 public sealed class CompositeTextureArrayCachePolicyTests
 {
+    [Fact]
+    public void ResidencySnapshotSeparatesResidentRequestedAndRetiringStorage()
+    {
+        var backend = new FakeBackend(maximumLayers: 1);
+        var retirements = new DeferredRetirementQueue();
+        using var cache = CreateCache(
+            backend,
+            retirements,
+            unownedBudgetBytes: 0,
+            physicalBudgetBytes: 0);
+        cache.BeginFrame();
+        Assert.True(cache.TryAddAndAcquire(
+            1,
+            Key(1),
+            Texture(4, 4),
+            out _));
+
+        var resident = cache.CaptureResidency();
+        Assert.Equal(64, resident.Charges.GpuResidentBytes);
+        Assert.Equal(0, resident.Charges.RetiringBytes);
+        Assert.Equal(64, resident.CapacityBytes);
+        Assert.Equal(64, resident.UsedBytes);
+
+        cache.ReleaseOwner(1);
+        cache.Tick();
+        retirements.DrainAll();
+        cache.Tick();
+
+        var retired = cache.CaptureResidency();
+        Assert.Equal(0, retired.Charges.GpuResidentBytes);
+        Assert.Equal(0, retired.Charges.RetiringBytes);
+        Assert.Equal(0, retired.CapacityBytes);
+    }
+
     [Theory]
     [InlineData(16, 16, 64)]
     [InlineData(128, 128, 64)]

tests/AcDream.App.Tests/Rendering/Residency/ResidencyManagerTests.cs

@@ -343,6 +343,60 @@ public sealed class ResidencyManagerTests
         Assert.Equal(1, journal.Count);
     }
 
+    [Fact]
+    public void DomainSourcesAggregateWithoutCountingMappedAddressSpaceAsRam()
+    {
+        var manager = new ResidencyManager();
+        manager.RegisterDomainSource(new DelegateResidencyDomainSource(
+            ResidencyDomain.PreparedPackage,
+            () => new ResidencyDomainSnapshot(
+                ResidencyDomain.PreparedPackage,
+                EntryCount: 1,
+                OwnerCount: 1,
+                Charges: new ResidencyCharges(
+                    LogicalBytes: 64,
+                    PinnedBytes: 32,
+                    MappedVirtualBytes: 30_000))));
+        manager.RegisterDomainSource(new DelegateResidencyDomainSource(
+            ResidencyDomain.StandaloneTextures,
+            () => new ResidencyDomainSnapshot(
+                ResidencyDomain.StandaloneTextures,
+                EntryCount: 2,
+                OwnerCount: 1,
+                Charges: new ResidencyCharges(
+                    GpuResidentBytes: 128),
+                BudgetBytes: 256,
+                CapacityBytes: 128,
+                UsedBytes: 96,
+                LargestFreeBytes: 16)));
+
+        ResidencySnapshot snapshot = manager.CaptureSnapshot();
+
+        Assert.Equal(64, snapshot.TotalCharges.CommittedCpuBytes);
+        Assert.Equal(30_000, snapshot.TotalCharges.MappedVirtualBytes);
+        Assert.Equal(128, snapshot.TotalCharges.PhysicalGpuBytes);
+        Assert.Equal(
+            16,
+            snapshot.Get(ResidencyDomain.StandaloneTextures)
+                .FragmentedFreeBytes);
+    }
+
+    [Fact]
+    public void OnlyOneCanonicalSourceMayOwnADomain()
+    {
+        var manager = new ResidencyManager();
+        var first = new DelegateResidencyDomainSource(
+            ResidencyDomain.ObjectMeshes,
+            () => default);
+        manager.RegisterDomainSource(first);
+
+        Assert.Throws<InvalidOperationException>(() =>
+            manager.RegisterDomainSource(
+                new DelegateResidencyDomainSource(
+                    ResidencyDomain.ObjectMeshes,
+                    () => default)));
+    }
+
     private static AssetHandle<MeshAsset> Resident(
         ResidencyManager manager,
         ulong id,

tests/AcDream.App.Tests/Rendering/StandaloneBindlessTextureCacheTests.cs

@@ -52,6 +52,8 @@ public sealed class StandaloneBindlessTextureCacheTests
         cache.Tick();
 
         Assert.Equal(2, cache.EntryCount);
+        Assert.Equal(12, cache.AllocatedBytes);
+        Assert.Equal(4, cache.RetiringBytes);
         Assert.Equal(2, cache.UnownedEntryCount);
         Assert.Single(retirements.Actions);
         Assert.Empty(backend.Events);
@@ -60,6 +62,8 @@ public sealed class StandaloneBindlessTextureCacheTests
 
         retirements.Drain();
         Assert.Equal(["nonresident:1", "delete:1"], backend.Events);
+        Assert.Equal(8, cache.AllocatedBytes);
+        Assert.Equal(0, cache.RetiringBytes);
     }
 
     [Fact]
@@ -196,6 +200,32 @@ public sealed class StandaloneBindlessTextureCacheTests
             backend.Events);
     }
 
+    [Fact]
+    public void DisposePreservesAcceptedFenceRetirementAccountingUntilCompletion()
+    {
+        var backend = new FakeBackend();
+        var retirements = new DeferredRetirementQueue();
+        var cache = CreateCache(
+            backend,
+            retirements,
+            unownedBudgetBytes: 1_000,
+            maximumUnownedCount: 1);
+        AddAndRelease(cache, ownerId: 10, Resource(1, bytes: 4));
+        AddAndRelease(cache, ownerId: 20, Resource(2, bytes: 4));
+        cache.Tick();
+
+        Assert.Equal(8, cache.AllocatedBytes);
+        Assert.Equal(4, cache.RetiringBytes);
+
+        cache.Dispose();
+
+        Assert.Equal(4, cache.AllocatedBytes);
+        Assert.Equal(4, cache.RetiringBytes);
+        retirements.Drain();
+        Assert.Equal(0, cache.AllocatedBytes);
+        Assert.Equal(0, cache.RetiringBytes);
+    }
+
     [Fact]
     public void FailedResidencyReleaseNeverDeletesThatBackingTexture()
     {