HDRenderPipeline: Reduce GC alloc by replacging call to Array.Sort by our own quicksort

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/AmbientOcclusion/ScreenSpaceAmbientOcclusion.cs

             if (settings.enable == false || isForward)
             {
                 cmd.SetGlobalTexture(Uniforms._AOBuffer, UnityEngine.Rendering.PostProcessing.RuntimeUtilities.blackTexture); // Neutral is black, see the comment in the shaders
-                renderContext.ExecuteCommandBuffer(cmd);
                 return;
             }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

                         for (int i = 0; i < lcnt; ++i)
                         {
                             VisibleLight vl = cullResults.visibleLights[i];
+                            if (vl.light.shadows == LightShadows.None)
+                                continue;
+
-                            if( vl.light.shadows != LightShadows.None && asd != null && asd.shadowDimmer > 0.0f )
-                                m_ShadowRequests.Add( i );
+                            if (asd != null && asd.shadowDimmer > 0.0f)
+                                m_ShadowRequests.Add(i);
                         }
                         // pass this list to a routine that assigns shadows based on some heuristic
                         uint    shadowRequestCount = (uint)m_ShadowRequests.Count;
                         sortKeys[sortCount++] = (uint)lightCategory << 27 | (uint)gpuLightType << 22 | (uint)lightVolumeType << 17 | shadow << 16 | (uint)lightIndex;
                     }
 
-                    //TODO: Replace with custom sort, allocates mem and increases GC pressure.
-                    Array.Sort(sortKeys, 0, sortCount);
+                    Utilities.QuickSort(sortKeys, 0, sortCount - 1); // Call our own quicksort instead of Array.Sort(sortKeys, 0, sortCount) so we don't allocate memory (note the SortCount-1 that is different from original call).
 
                     // TODO: Refactor shadow management
                     // The good way of managing shadow:
                     }
 
                     // Not necessary yet but call it for future modification with sphere influence volume
-                    Array.Sort(sortKeys, 0, sortCount);
+                    Utilities.QuickSort(sortKeys, 0, sortCount - 1); // Call our own quicksort instead of Array.Sort(sortKeys, 0, sortCount) so we don't allocate memory (note the SortCount-1 that is different from original call).
 
                     for (int sortIndex = 0; sortIndex < sortCount; ++sortIndex)
                     {
             {
                 var bUseClusteredForDeferred = !usingFptl;
 
+                // TODO: To reduce GC pressure don't do concat string here
                 using (new Utilities.ProfilingSample((m_TileSettings.enableTileAndCluster ? "TilePass - Deferred Lighting Pass" : "SinglePass - Deferred Lighting Pass") + (outputSplitLighting ? " MRT" : ""), cmd))
                 {
                     var camera = hdCamera.camera;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Utilities.cs

                 overlayLineHeight = -1.0f;
             }
         }
+
+        // Just a sort function that doesn't allocate memory
+        // Note: Shoud be repalc by a radix sort for positive integer
+        static public int Partition(uint[] numbers, int left, int right)
+        {
+            uint pivot = numbers[left];
+            while (true)
+            {
+                while (numbers[left] < pivot)
+                    left++;
+
+                while (numbers[right] > pivot)
+                    right--;
+
+                if (left < right)
+                {
+                    uint temp = numbers[right];
+                    numbers[right] = numbers[left];
+                    numbers[left] = temp;
+                }
+                else
+                {
+                    return right;
+                }
+            }
+        }
+
+        static public void QuickSort(uint[] arr, int left, int right)
+        {
+            // For Recusrion
+            if (left < right)
+            {
+                int pivot = Partition(arr, left, right);
+
+                if (pivot > 1)
+                    QuickSort(arr, left, pivot - 1);
+
+                if (pivot + 1 < right)
+                    QuickSort(arr, pivot + 1, right);
+            }
+        }
     }
 }