Compact resource versioning

Author: kirill-titov-u

Packages/com.unity.render-pipelines.core/Editor/RenderGraph/RenderGraphTestsCore.cs

@@ -1,13 +1,11 @@
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
 using UnityEngine.Rendering.RenderGraphModule;
 
-#if UNITY_EDITOR
-using UnityEditor.Rendering;
-#endif
-
-namespace UnityEngine.Rendering.Tests
+namespace UnityEditor.Rendering.Tests
 {
     // TODO: Move this class to the Tests/Editor folder once the "IsolatedPackagesVerified" CI test correctly resolves all dependencies.
     // Currently, the URP package fails to locate the RenderGraphTestsCore class when it's placed under Tests/Editor,
@@ -130,9 +128,8 @@ public void Setup()
         {
             // Setting default global settings to the custom RG render pipeline type, no quality settings so we can rely on the default RP
             m_RenderGraphTestGlobalSettings = ScriptableObject.CreateInstance<RenderGraphTestGlobalSettings>();
-#if UNITY_EDITOR
             EditorGraphicsSettings.SetRenderPipelineGlobalSettingsAsset<RenderGraphTestPipelineInstance>(m_RenderGraphTestGlobalSettings);
-#endif
+
             // Saving old render pipelines to set them back after testing
             m_OldDefaultRenderPipeline = GraphicsSettings.defaultRenderPipeline;
             m_OldQualityRenderPipeline = QualitySettings.renderPipeline;
@@ -166,14 +163,20 @@ public void Cleanup()
             QualitySettings.renderPipeline = m_OldQualityRenderPipeline;
             m_OldQualityRenderPipeline = null;
 
-            m_RenderGraph.Cleanup();
+            try
+            {
+                m_RenderGraph.Cleanup();
+            }
+            catch (Exception e)
+            {
+                Debug.Log($"Tried to clean RenderGraph but exception was thrown: {e.Message}");
+            }
 
-            Object.DestroyImmediate(m_RenderGraphTestPipeline);
 
-#if UNITY_EDITOR
+            UnityEngine.Object.DestroyImmediate(m_RenderGraphTestPipeline);
             EditorGraphicsSettings.SetRenderPipelineGlobalSettingsAsset<RenderGraphTestPipelineInstance>(null);
-#endif
-            Object.DestroyImmediate(m_RenderGraphTestGlobalSettings);
+
+            UnityEngine.Object.DestroyImmediate(m_RenderGraphTestGlobalSettings);
 
             GameObject.DestroyImmediate(m_GameObject);
             m_GameObject = null;

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/ResourcesData.cs

@@ -24,22 +24,26 @@ public ResourceReaderData(int _passId, int _inputSlot)
     // RenderGraphResourceRegistry was identified as slow in the profiler
     internal struct ResourceUnversionedData
     {
-        public readonly bool isImported; // Imported graph resource
-        public bool isShared; // Shared graph resource
-        public int tag;
+        public int versionedDataOffset;     // Where this resource's versioned data starts in the packed array
+        public int versionedDataCount;      // Number of versions this resource actually has
+        public int readerDataOffset;        // Where this resource's reader data starts in the packed array
+        public int maxReadersPerVersion;    // Max readers across all versions of this resource
+
         public int lastUsePassID; // Index of last used pass. The resource (if not imported) is destroyed after this pass.
         public int lastWritePassID; // The last pass writing it. After this other passes may still read the resource
-        public int firstUsePassID; //First pas using the resource this may be reading or writing. If not imported the resource is allocated just before this pass.
+        public int firstUsePassID; // First pass using the resource this may be reading or writing. If not imported the resource is allocated just before this pass.
+        public int latestVersionNumber; // Mostly readonly, can be decremented only if all passes using the last version are culled
+
+        public readonly bool isImported; // Imported graph resource
         public bool memoryLess; // Never create the texture on GPU if it is allocated/freed within a renderpass
+        public int tag;
 
         public readonly int width;
         public readonly int height;
         public readonly int volumeDepth;
         public readonly int msaaSamples;
         public readonly GraphicsFormat graphicsFormat;
 
-        public int latestVersionNumber; // mostly readonly, can be decremented only if all passes using the last version are culled
-
         public readonly bool clear; // graph.m_Resources.GetTextureResourceDesc(fragment.resource).clearBuffer;
         public readonly bool discard; // graph.m_Resources.GetTextureResourceDesc(fragment.resource).discardBuffer;
         public readonly bool bindMS;
@@ -53,7 +57,6 @@ internal struct ResourceUnversionedData
         public ResourceUnversionedData(TextureResource rll, ref RenderTargetInfo info, ref TextureDesc desc, bool isResBackBuffer)
         {
             isImported = rll.imported;
-            isShared = false;
             tag = 0;
             firstUsePassID = -1;
             lastUsePassID = -1;
@@ -73,14 +76,18 @@ public ResourceUnversionedData(TextureResource rll, ref RenderTargetInfo info, r
             isBackBuffer = isResBackBuffer;
             textureUVOrigin = rll.textureUVOrigin;
             graphicsFormat = desc.format;
+
+            versionedDataOffset = 0;
+            versionedDataCount = 0;
+            readerDataOffset = 0;
+            maxReadersPerVersion = 0;
         }
 
         public ResourceUnversionedData(IRenderGraphResource rll, ref BufferDesc _, bool isResBackBuffer)
         {
             // We don't do anything with the BufferDesc for now. The compiler doesn't really need the details of the buffer like it does with textures
             // since for textures it needs the details to merge passes etc. Which is not relevant for buffers.
             isImported = rll.imported;
-            isShared = false;
             tag = 0;
             firstUsePassID = -1;
             lastUsePassID = -1;
@@ -100,14 +107,18 @@ public ResourceUnversionedData(IRenderGraphResource rll, ref BufferDesc _, bool
             isBackBuffer = isResBackBuffer;
             textureUVOrigin = TextureUVOriginSelection.Unknown;
             graphicsFormat = GraphicsFormat.None;
+
+            versionedDataOffset = 0;
+            versionedDataCount = 0;
+            readerDataOffset = 0;
+            maxReadersPerVersion = 0;
         }
 
         public ResourceUnversionedData(IRenderGraphResource rll, ref RayTracingAccelerationStructureDesc _, bool isResBackBuffer)
         {
             // We don't do anything with the RayTracingAccelerationStructureDesc for now. The compiler doesn't really need the details of the acceleration structures like it does with textures
             // since for textures it needs the details to merge passes etc. Which is not relevant for acceleration structures.
             isImported = rll.imported;
-            isShared = false;
             tag = 0;
             firstUsePassID = -1;
             lastUsePassID = -1;
@@ -127,6 +138,11 @@ public ResourceUnversionedData(IRenderGraphResource rll, ref RayTracingAccelerat
             isBackBuffer = isResBackBuffer;
             textureUVOrigin = TextureUVOriginSelection.Unknown;
             graphicsFormat = GraphicsFormat.None;
+
+            versionedDataOffset = 0;
+            versionedDataCount = 0;
+            readerDataOffset = 0;
+            maxReadersPerVersion = 0;
         }
 
         public void InitializeNullResource()
@@ -167,11 +183,12 @@ public void SetWritingPass(CompilerContextData ctx, in ResourceHandle h, int pas
         public void RegisterReadingPass(CompilerContextData ctx, in ResourceHandle h, int passId, int index)
         {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-            if (numReaders >= ctx.resources.MaxReaders[h.iType])
+            ref var unversioned = ref ctx.resources.unversionedData[h.iType].ElementAt(h.index);
+            if (numReaders >= unversioned.maxReadersPerVersion)
             {
                 string passName = ctx.GetPassName(passId);
                 string resourceName = ctx.GetResourceName(h);
-                throw new Exception($"Maximum '{ctx.resources.MaxReaders}' passes can use a single graph output as input. Pass {passName} is trying to read {resourceName}.");
+                throw new Exception($"Maximum '{unversioned.maxReadersPerVersion}' passes can use a single graph output as input. Pass {passName} is trying to read {resourceName}.");
             }
 #endif
             ctx.resources.readerData[h.iType][ctx.resources.IndexReader(h, numReaders)] = new ResourceReaderData(passId, index);
@@ -203,16 +220,14 @@ public void RemoveReadingPass(CompilerContextData ctx, in ResourceHandle h, int
     }
 
     // This class allows quick lookups from ResourceHandle -> ResourceUnversionedData/ResourceVersionData/ResourceReaderData
-    // This is implementing a fully allocated array, we assume there aren't too many resources & versions. This lookup is fast and doesn't
-    // require GC allocs to fill.
+    // Uses resource-level sparse allocation: each resource allocates only the versions it needs.
+    // Reader allocation uses total read count as conservative upper bound (not true per-version sparse).
+    // Allocation metadata is inlined in ResourceUnversionedData for optimal cache performance.
     internal class ResourcesData
     {
-        public NativeList<ResourceUnversionedData>[] unversionedData; // Flattened fixed size array storing info per resource id shared between all versions.
-        public NativeList<ResourceVersionedData>[] versionedData; // Flattened fixed size array storing up to MaxVersions versions per resource id.
-        public NativeList<ResourceReaderData>[] readerData; // Flattened fixed size array storing up to MaxReaders per resource id per version.
-
-        public int[] MaxVersions;
-        public int[] MaxReaders;
+        public NativeList<ResourceUnversionedData>[] unversionedData; // Per-resource data (one per resource, includes allocation metadata)
+        public NativeList<ResourceVersionedData>[] versionedData;     // Packed versioned data (sparse)
+        public NativeList<ResourceReaderData>[] readerData;           // Partially packed reader data (semi-sparse)
 
         public DynamicArray<Name>[] resourceNames;
 
@@ -222,8 +237,6 @@ public ResourcesData()
             versionedData = new NativeList<ResourceVersionedData>[(int)RenderGraphResourceType.Count];
             readerData = new NativeList<ResourceReaderData>[(int)RenderGraphResourceType.Count];
             resourceNames = new DynamicArray<Name>[(int)RenderGraphResourceType.Count];
-            MaxVersions = new int[(int)RenderGraphResourceType.Count];
-            MaxReaders = new int[(int)RenderGraphResourceType.Count];
 
             for (int t = 0; t < (int)RenderGraphResourceType.Count; t++)
                 resourceNames[t] = new DynamicArray<Name>(0); // T in NativeList<T> cannot contain managed types, so the names are stored separately
@@ -249,12 +262,10 @@ public void Clear()
         void AllocateAndResizeNativeListIfNeeded<T>(ref NativeList<T> nativeList, int size, NativeArrayOptions options) where T : unmanaged
         {
             // Allocate the first time or if Dispose() has been called through RenderGraph.Cleanup()
-            // Length remains 0, list is still empty
             if (!nativeList.IsCreated)
                 nativeList = new NativeList<T>(size, AllocatorManager.Persistent);
 
             // Resize the list (it will allocate if necessary)
-            // List is not empty anymore
             nativeList.Resize(size, options);
         }
 
@@ -265,9 +276,6 @@ public void Initialize(RenderGraphResourceRegistry resources)
                 RenderGraphResourceType resourceType = (RenderGraphResourceType) t;
                 var numResources = resources.GetResourceCount(resourceType);
 
-                uint maxReaders = 0;
-                uint maxWriters = 0;
-
                 // We don't clear the list as we reinitialize it right after
                 AllocateAndResizeNativeListIfNeeded(ref unversionedData[t], numResources, NativeArrayOptions.UninitializedMemory);
 
@@ -281,16 +289,19 @@ public void Initialize(RenderGraphResourceRegistry resources)
                     resourceNames[t][0] = new Name("");
                 }
 
-                // Fill the buffer with any existing external info requested for NRP RG process
+                // Compute allocation sizes and populate unversionedData in a single pass
+                int totalVersionedDataCount = 0;
+                int totalReaderDataCount = 0;
+
+                // Null resource at index 0 already initialized to 0 in constructors
+                // Process all resources in one pass for better cache locality
                 for (int r = 1; r < numResources; r++)
                 {
-                    // We cache these values here
-                    // as getting them over and over from other
-                    // graph data structures external to NRP RG is costly
                     var h = new ResourceHandle(r, resourceType, false);
                     var rll = resources.GetResourceLowLevel(h);
                     resourceNames[t][r] = new Name(rll.GetName());
 
+                    // Initialize unversionedData based on resource type
                     switch (t)
                     {
                         case (int)RenderGraphResourceType.Texture:
@@ -325,49 +336,57 @@ public void Initialize(RenderGraphResourceRegistry resources)
                             throw new Exception("Unsupported resource type: " + t);
                     }
 
-                    maxReaders = Math.Max(maxReaders, rll.readCount);
-                    maxWriters = Math.Max(maxWriters, rll.writeCount);
+                    // Compute allocation metadata for this resource
+                    // +1 for versions: v0 exists even without writes
+                    int numVersions = (int)rll.writeCount + 1;
+                    // +1 for readers: transient resources don't call IncrementReadCount, but BuildGraph adds 1 implicit read
+                    // Note: rll.readCount is total across all versions (not per-version), so this is a conservative upper bound
+                    int numReaders = (int)rll.readCount + 1;
+
+                    // Populate allocation metadata
+                    ref var unversioned = ref unversionedData[t].ElementAt(r);
+                    unversioned.versionedDataOffset = totalVersionedDataCount;
+                    unversioned.versionedDataCount = numVersions;
+                    unversioned.readerDataOffset = totalReaderDataCount;
+                    unversioned.maxReadersPerVersion = numReaders;
+
+                    totalVersionedDataCount += numVersions;
+                    totalReaderDataCount += numVersions * numReaders;
                 }
 
-                // The first resource is a null resource, so we need to add 1 to the count.
-                MaxReaders[t] = (int)maxReaders + 1;
-                MaxVersions[t]  = (int)maxWriters + 1;
-
-                // Clear the other caching structures, they will be filled later
-                AllocateAndResizeNativeListIfNeeded(ref versionedData[t], MaxVersions[t] * numResources, NativeArrayOptions.ClearMemory);
-                AllocateAndResizeNativeListIfNeeded(ref readerData[t], MaxVersions[t] * MaxReaders[t] * numResources, NativeArrayOptions.ClearMemory);
+                AllocateAndResizeNativeListIfNeeded(ref versionedData[t], totalVersionedDataCount, NativeArrayOptions.ClearMemory);
+                AllocateAndResizeNativeListIfNeeded(ref readerData[t], totalReaderDataCount, NativeArrayOptions.ClearMemory);
             }
         }
 
-        // Flatten array index
+        // Flatten array index using sparse allocation (uses inlined allocation metadata)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public int Index(in ResourceHandle h)
         {
+            ref var unversioned = ref unversionedData[h.iType].ElementAt(h.index);
 #if UNITY_EDITOR // Hot path
-            if (h.version < 0 || h.version >= MaxVersions[h.iType])
+            if (h.version < 0 || h.version >= unversioned.versionedDataCount)
                 throw new Exception("Invalid version: " + h.version);
 #endif
-            return h.index * MaxVersions[h.iType] + h.version;
+            return unversioned.versionedDataOffset + h.version;
         }
 
-        // Flatten array index
+        // Flatten array index for readers using sparse allocation (uses inlined allocation metadata)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public int IndexReader(in ResourceHandle h, int readerID)
         {
+            ref var unversioned = ref unversionedData[h.iType].ElementAt(h.index);
 #if UNITY_EDITOR // Hot path
-            if (h.version < 0 || h.version >= MaxVersions[h.iType])
+            if (h.version < 0 || h.version >= unversioned.versionedDataCount)
                 throw new Exception("Invalid version");
-            if (readerID < 0 || readerID >= MaxReaders[h.iType])
+            if (readerID < 0 || readerID >= unversioned.maxReadersPerVersion)
                 throw new Exception("Invalid reader");
 #endif
-            return (h.index * MaxVersions[h.iType] + h.version) * MaxReaders[h.iType] + readerID;
+            return unversioned.readerDataOffset + h.version * unversioned.maxReadersPerVersion + readerID;
         }
 
         // Lookup data for a given handle
-        public ref ResourceVersionedData this[ResourceHandle h]
-        {
-            get { return ref versionedData[h.iType].ElementAt(Index(h)); }
-        }
+        public ref ResourceVersionedData this[ResourceHandle h] => ref versionedData[h.iType].ElementAt(Index(h));
 
         public void Dispose()
         {

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphDefaultResources.cs

@@ -80,6 +80,9 @@ internal void InitializeForRendering(RenderGraph renderGraph)
             whiteTexture = renderGraph.ImportTexture(m_WhiteTexture2D, true);
             defaultShadowTexture = renderGraph.ImportTexture(m_ShadowTexture2D, true);
 
+            if (!TextureXR.initialized)
+                return;
+
             clearTextureXR = renderGraph.ImportTexture(TextureXR.GetClearTexture(), true);
             magentaTextureXR = renderGraph.ImportTexture(TextureXR.GetMagentaTexture(), true);
             blackTextureXR = renderGraph.ImportTexture(TextureXR.GetBlackTexture(), true);