Profiler/renderpipeline/stage 5 remaining

Author: alexey-zakharov

Packages/com.unity.render-pipelines.core/Runtime/Debugging/ProfilingScope.cs

@@ -392,7 +392,7 @@ public ProfilingScope(ProfilingSampler sampler)
         /// with this sample. The Profiler displays it in the sample hierarchy.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining | (MethodImplOptions)512)]
         public ProfilingScope(ProfilingSampler sampler, Object contextObject)
-            : this(null, sampler, contextObject)
+            : this((CommandBuffer)null, sampler, contextObject)
         {
         }
 
@@ -458,6 +458,26 @@ public ProfilingScope(BaseCommandBuffer cmd, ProfilingSampler sampler)
 #endif
         }
 
+        /// <summary>
+        /// Creates a profiling scope that records markers into <paramref name="cmd"/> as well as inline on the CPU,
+        /// and associates a Unity Object with the sample for identification in the Profiler.
+        /// </summary>
+        /// <remarks>
+        /// Do not use with a named <see cref="CommandBuffer"/>. A named command buffer inserts its own
+        /// scope marker on execution, which orphans the markers added here: the begin and end appear
+        /// inside different named-buffer execution brackets and will be mismatched in the Profiler timeline.
+        /// </remarks>
+        /// <param name="cmd">BaseCommandBuffer (e.g. RasterCommandBuffer, UnsafeCommandBuffer) to receive the GPU-visible begin/end markers.</param>
+        /// <param name="sampler">The sampler that provides the underlying marker.
+        /// May be <c>null</c>; the scope is a no-op in that case.</param>
+        /// <param name="contextObject">Unity Object (e.g. Texture, Mesh, Material) to associate
+        /// with this sample. The Profiler displays it in the sample hierarchy.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining | (MethodImplOptions)512)]
+        public ProfilingScope(BaseCommandBuffer cmd, ProfilingSampler sampler, Object contextObject)
+            : this(cmd.m_WrappedCommandBuffer, sampler, contextObject)
+        {
+        }
+
         /// <summary>
         /// Ends the profiling scope by calling <see cref="ProfilingSampler.End"/>. Safe to call multiple times.
         /// </summary>

Packages/com.unity.render-pipelines.core/Runtime/Lighting/ProbeVolume/ProbeBrickPool.cs

@@ -384,7 +384,7 @@ internal void Update(CommandBuffer cmd, CellStreamingScratchBuffer dataBuffer, C
             List<BrickChunkAlloc> dstLocations, bool updateSharedData, Texture validityTexture, ProbeVolumeSHBands bands,
             bool skyOcclusion, Texture skyOcclusionTexture, bool skyShadingDirections, Texture skyShadingDirectionsTexture, bool probeOcclusion)
         {
-            using (new ProfilingScope(cmd, CoreProfilingSamplers.APVDiskStreamingUpdatePool))
+            using (new ProfilingScope(cmd, CoreProfilingSamplers.APVDiskStreamingUpdatePool, m_Pool.TexL0_L1rx))
             {
                 int chunkCount = dstLocations.Count;
 

Packages/com.unity.render-pipelines.core/Runtime/Lighting/ProbeVolume/ProbeReferenceVolume.Streaming.cs

@@ -805,7 +805,7 @@ public void UpdateCellStreaming(CommandBuffer cmd, Camera camera, ProbeVolumesOp
             // Handle cell streaming for blending
             if (supportScenarioBlending)
             {
-                using (new ProfilingScope(cmd, CoreProfilingSamplers.APVScenarioBlendingUpdate))
+                using (new ProfilingScope(cmd, CoreProfilingSamplers.APVScenarioBlendingUpdate, camera))
                     UpdateBlendingCellStreaming(cmd);
             }
         }

Packages/com.unity.render-pipelines.core/Runtime/PathTracing/LightmapIntegration.cs

@@ -377,9 +377,9 @@ public void Accumulate(
                 _accumulationShader.SetIntParam(cmd, LightmapIntegratorShaderIDs.SampleOffset, (int)currentSampleCountPerTexel);
                 _accumulationShader.SetIntParam(cmd, LightmapIntegratorShaderIDs.MaxLocalSampleCount, (int)sampleCountToTakePerTexel);
 
-                cmd.BeginSample("Accumulation (Expanded)");
+                cmd.BeginSample(LightmapIntegratorShaderIDs.k_AccumulationExpanded);
                 _accumulationShader.Dispatch(cmd, traceScratchBuffer, _accumulationDispatchBuffer);
-                cmd.EndSample("Accumulation (Expanded)");
+                cmd.EndSample(LightmapIntegratorShaderIDs.k_AccumulationExpanded);
             }
         }
 

Packages/com.unity.render-pipelines.core/Runtime/PathTracing/LightmapIntegrationHelpers.cs

@@ -68,6 +68,22 @@ internal static class ShaderIDs
             internal static int CopyTextureAdditiveKernel;
             internal static int MaskAlphaChannelKernel;
 
+            /// <summary>
+            /// Profiles the additive texture copy compute dispatch that blends a source region
+            /// into a destination region of a lightmap during accumulation.
+            /// </summary>
+            static readonly ProfilerMarker k_CopyTextureAdditive =
+                new ProfilerMarker(ProfilerCategory.Render, "CopyTextureAdditive",
+                    MarkerFlags.Default | MarkerFlags.SampleGPU);
+
+            /// <summary>
+            /// Profiles the alpha channel mask compute dispatch that clears or fills the alpha
+            /// channel of a lightmap texture to mark valid texel coverage.
+            /// </summary>
+            static readonly ProfilerMarker k_MaskAlphaChannel =
+                new ProfilerMarker(ProfilerCategory.Render, "MaskAlphaChannel",
+                    MarkerFlags.Default | MarkerFlags.SampleGPU);
+
 #if UNITY_EDITOR
             [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterAssembliesLoaded)]
             static void ResetStaticsOnLoad()
@@ -109,7 +125,7 @@ public void Load()
             public void CopyTextureAdditive(CommandBuffer cmd, RenderTargetIdentifier source, RenderTargetIdentifier destination,
                 int width, int height, int sourceX = 0, int sourceY = 0, int destinationX = 0, int destinationY = 0)
             {
-                cmd.BeginSample("CopyTextureAdditive");
+                cmd.BeginSample(k_CopyTextureAdditive);
                 cmd.SetComputeTextureParam(ComputeHelperShader, CopyTextureAdditiveKernel, ShaderIDs.SourceTexture, source);
                 cmd.SetComputeTextureParam(ComputeHelperShader, CopyTextureAdditiveKernel, ShaderIDs.DestinationTexture, destination);
                 cmd.SetComputeIntParam(ComputeHelperShader, ShaderIDs.SourceWidth, width);
@@ -120,18 +136,18 @@ public void CopyTextureAdditive(CommandBuffer cmd, RenderTargetIdentifier source
                 cmd.SetComputeIntParam(ComputeHelperShader, ShaderIDs.DestinationY, destinationY);
                 ComputeHelperShader.GetKernelThreadGroupSizes(CopyTextureAdditiveKernel, out uint groupX, out uint groupY, out _);
                 cmd.DispatchCompute(ComputeHelperShader, CopyTextureAdditiveKernel, GraphicsHelpers.DivUp(width, groupX), GraphicsHelpers.DivUp(height, groupY), 1);
-                cmd.EndSample("CopyTextureAdditive");
+                cmd.EndSample(k_CopyTextureAdditive);
             }
 
             public void MaskAlphaChannel(CommandBuffer cmd, RenderTargetIdentifier texture, int width, int height)
             {
-                cmd.BeginSample("MaskAlphaChannel");
+                cmd.BeginSample(k_MaskAlphaChannel);
                 cmd.SetComputeTextureParam(ComputeHelperShader, MaskAlphaChannelKernel, ShaderIDs.TextureInOut, texture);
                 cmd.SetComputeIntParam(ComputeHelperShader, ShaderIDs.TextureWidth, width);
                 cmd.SetComputeIntParam(ComputeHelperShader, ShaderIDs.TextureHeight, height);
                 ComputeHelperShader.GetKernelThreadGroupSizes(MaskAlphaChannelKernel, out uint groupX, out uint groupY, out _);
                 cmd.DispatchCompute(ComputeHelperShader, MaskAlphaChannelKernel, GraphicsHelpers.DivUp(width, groupX), GraphicsHelpers.DivUp(height, groupY), 1);
-                cmd.EndSample("MaskAlphaChannel");
+                cmd.EndSample(k_MaskAlphaChannel);
             }
         }
 

Packages/com.unity.render-pipelines.core/Tests/Runtime/Debugging/ProfilingSamplerTests.cs

@@ -44,20 +44,24 @@ public void Create_ReturnsNonNull()
             var sampler = ProfilingSampler.Create("CreatedMarker", MarkerFlags.Default);
             Assert.IsNotNull(sampler);
             Assert.IsTrue(sampler.IsValid());
+#if USE_RECORDER
             Assert.IsFalse(sampler.m_Recorder.Valid);
             Assert.IsFalse(sampler.m_GpuRecorder.Valid);
             Assert.IsFalse(sampler.m_InlineRecorder.Valid);
+#endif
         }
 
         [Test]
         public void CreateWithFlags_IsValid()
         {
             var sampler = ProfilingSampler.Create("FlagsMarker", MarkerFlags.VerbosityAdvanced);
             Assert.IsTrue(sampler.IsValid());
+#if USE_RECORDER
             // Recorders are allocated lazily; none should be valid before enableRecording = true.
             Assert.IsFalse(sampler.m_Recorder.Valid);
             Assert.IsFalse(sampler.m_GpuRecorder.Valid);
             Assert.IsFalse(sampler.m_InlineRecorder.Valid);
+#endif
         }
 
         [Test]
@@ -113,6 +117,7 @@ public IEnumerator TimingProperties_ReturnZero_WhenNotRecording()
             Assert.AreEqual(0,    m_Sampler.inlineCpuSampleCount);
         }
 
+#if USE_RECORDER
         // Bits 10-12 all zero → SampleGPU auto-added → GpuRecorder is created on first enableRecording = true
         [Test]
         public void SampleGPU_AutoAdded_ForUserFacingMarker()
@@ -245,5 +250,6 @@ public void Dispose_CalledTwice_DoesNotThrow()
                 sampler.Dispose(); // recorders are no longer .Valid after first dispose
             });
         }
+#endif
     }
 }

Packages/com.unity.render-pipelines.universal/Runtime/Passes/ColorGradingLutPass.cs

@@ -115,7 +115,7 @@ private static void ExecutePass(RasterCommandBuffer cmd, PassData passData, RTHa
             var lutBuilderHdr = passData.lutBuilderHdr;
             var allowColorGradingACESHDR = passData.allowColorGradingACESHDR;
 
-            using (new ProfilingScope(cmd, URPProfilingSamplers.ColorGradingLUT))
+            using (new ProfilingScope(cmd, URPProfilingSamplers.ColorGradingLUT, passData.hdrGrading ? lutBuilderHdr : lutBuilderLdr))
             {
                 // TODO: should these components be set instead?
 

Packages/com.unity.render-pipelines.universal/Runtime/Passes/MainLightShadowCasterPass.cs

@@ -268,7 +268,7 @@ void RenderMainLightCascadeShadowmap(RasterCommandBuffer cmd, ref PassData data)
 
             VisibleLight shadowLight = lightData.visibleLights[shadowLightIndex];
 
-            using (new ProfilingScope(cmd, URPProfilingSamplers.MainLightShadow))
+            using (new ProfilingScope(cmd, URPProfilingSamplers.MainLightShadow, shadowLight.light))
             {
                 // Need to start by setting the Camera position and worldToCamera Matrix as that is not set for passes executed before normal rendering
                 ShadowUtils.SetCameraPosition(cmd, data.cameraData.worldSpaceCameraPos);

Packages/com.unity.render-pipelines.universal/Runtime/ReflectionProbeManager.cs

@@ -300,7 +300,7 @@ public unsafe void UpdateGpuData(CommandBuffer cmd, ref CullingResults cullResul
                 Debug.LogWarning("A number of reflection probes have been skipped due to the reflection probe atlas being full.\nTo fix this, you can decrease the number or resolution of probes.");
             }
 
-            using (new ProfilingScope(cmd, URPProfilingSamplers.UpdateReflectionProbeAtlas))
+            using (new ProfilingScope(cmd, URPProfilingSamplers.UpdateReflectionProbeAtlas, m_AtlasTexture0))
             {
                 cmd.SetRenderTarget(m_AtlasTexture0);