Opti: disk cache allocs (#6523)

Author: NickKhalow

Explorer/Assets/DCL/Infrastructure/ECS/StreamableLoading/Cache/Disk/CleanUp/LRUDiskCleanUp.cs

@@ -9,6 +9,14 @@ namespace ECS.StreamableLoading.Cache.Disk.CleanUp
 {
     public class LRUDiskCleanUp : IDiskCleanUp
     {
+        private static readonly EnumerationOptions options =  
+            new EnumerationOptions
+            {
+                IgnoreInaccessible = true,
+                RecurseSubdirectories = false,
+                AttributesToSkip = FileAttributes.Hidden | FileAttributes.System
+            };
+
         private readonly CacheDirectory cacheDirectory;
         private readonly FilesLock filesLock;
         private readonly long maxCacheSizeBytes;
@@ -17,6 +25,7 @@ public class LRUDiskCleanUp : IDiskCleanUp
         /// Use file system enumerable because default DirectoryInfo API allocates a lot of memory per each call
         /// </summary>
         private readonly FileSystemEnumerable<CacheFileInfo> files;
+        private readonly FileSystemEnumerable<long> fileSizes;
 
         public LRUDiskCleanUp(CacheDirectory cacheDirectory, FilesLock filesLock, long maxCacheSizeBytes = 1024 * 1024 * 1024) //1GB
         {
@@ -27,25 +36,31 @@ public LRUDiskCleanUp(CacheDirectory cacheDirectory, FilesLock filesLock, long m
             files = new FileSystemEnumerable<CacheFileInfo>(
                 cacheDirectory.Path,
                 (ref FileSystemEntry entry) => CacheFileInfo.FromFileSystemEntry(ref entry),
-                new EnumerationOptions
-                {
-                    IgnoreInaccessible = true,
-                    RecurseSubdirectories = false,
-                    AttributesToSkip = FileAttributes.Hidden | FileAttributes.System
-                }
+                options
             )
             {
-                ShouldIncludePredicate = (ref FileSystemEntry entry) => entry.IsDirectory == false,
+                ShouldIncludePredicate = Predicate,
             };
+
+            fileSizes = new FileSystemEnumerable<long>(
+                cacheDirectory.Path,
+                (ref FileSystemEntry entry) => entry.Length,
+                options
+            )
+            {
+                ShouldIncludePredicate = Predicate,
+            };
+
+            static bool Predicate(ref FileSystemEntry entry) => entry.IsDirectory == false;
         }
 
         public void CleanUpIfNeeded()
         {
-            using var _ = CachedFiles(out var cachedFiles);
-            long directorySize = DirectorySize(cachedFiles);
+            long directorySize = DirectorySize(fileSizes);
 
             if (directorySize > maxCacheSizeBytes)
             {
+                using var _ = CachedFiles(out var cachedFiles);
                 cachedFiles.Sort(LRUComparer.INSTANCE);
 
                 for (int i = 0; i < cachedFiles.Count; i++)
@@ -68,10 +83,10 @@ public void NotifyUsed(string fileName)
             File.SetLastAccessTimeUtc(Path.Combine(cacheDirectory.Path, fileName), DateTime.UtcNow);
         }
 
-        private static long DirectorySize(IReadOnlyCollection<CacheFileInfo> files)
+        private static long DirectorySize(FileSystemEnumerable<long> fileSizes)
         {
             long size = 0;
-            foreach (CacheFileInfo fi in files) size += fi.Size;
+            foreach (long fi in fileSizes) size += fi;
             return size;
         }
 

Explorer/Assets/DCL/Infrastructure/ECS/StreamableLoading/Cache/Disk/Playgrounds/DiskCachePlayground.cs

@@ -12,21 +12,33 @@ public class DiskCachePlayground : MonoBehaviour
     {
         [SerializeField] private string cacheDirectory = string.Empty;
         [SerializeField] private string testFile = string.Empty;
+        [SerializeField] private bool useCleanUp = true;
+
 
         private void Start()
         {
             StartAsync().Forget();
         }
+        
+        private void Update()
+        {
+            CleanUp();
+        }
 
-        private IDiskCache NewDiskCache() =>
-            new DiskCache(CacheDirectory.New(cacheDirectory), new FilesLock(), IDiskCleanUp.None.INSTANCE);
+        private IDiskCache NewDiskCache(out IDiskCleanUp cleanUp)
+        {
+            var directory = CacheDirectory.New(cacheDirectory);
+            var filesLock = new FilesLock();
+            cleanUp = useCleanUp ? new LRUDiskCleanUp(directory, filesLock) : IDiskCleanUp.None.INSTANCE;
+            return new DiskCache(directory, filesLock, cleanUp);
+        }
 
         private async UniTaskVoid StartAsync()
         {
             byte[] testData = await File.ReadAllBytesAsync(testFile, destroyCancellationToken)!;
             string testExtension = Path.GetExtension(testFile);
 
-            IDiskCache diskCache = NewDiskCache();
+            IDiskCache diskCache = NewDiskCache(out _);
             using HashKey hashKey = HashKey.FromString(testFile);
 
             using SingleMemoryIterator iterator = new SingleMemoryIterator(testData);
@@ -43,10 +55,17 @@ private async UniTaskVoid StartAsync()
         [ContextMenu(nameof(RemoveAsync))]
         public async UniTaskVoid RemoveAsync()
         {
-            IDiskCache diskCache = NewDiskCache();
+            IDiskCache diskCache = NewDiskCache(out _);
             using HashKey hashKey = HashKey.FromString(testFile);
             var result = await diskCache.RemoveAsync(hashKey, Path.GetExtension(testFile), destroyCancellationToken);
             print($"Remove result: success {result.Success} and error {result.Error?.Message}");
         }
+
+        [ContextMenu(nameof(CleanUp))]
+        public void CleanUp()
+        {
+            var _ = NewDiskCache(out var cache);
+            cache.CleanUpIfNeeded();
+        }
     }
 }

Explorer/Assets/DCL/Infrastructure/ECS/StreamableLoading/Cache/Disk/Playgrounds/DiskCachePlayground.unity

@@ -248,14 +248,14 @@ MonoBehaviour:
   m_ScreenCoordScaleBias: {x: 0, y: 0, z: 0, w: 0}
   m_RequiresDepthTexture: 0
   m_RequiresColorTexture: 0
-  m_Version: 2
   m_TaaSettings:
     m_Quality: 3
     m_FrameInfluence: 0.1
     m_JitterScale: 1
     m_MipBias: 0
     m_VarianceClampScale: 0.9
     m_ContrastAdaptiveSharpening: 0
+  m_Version: 2
 --- !u!1 &672635447
 GameObject:
   m_ObjectHideFlags: 0
@@ -300,7 +300,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 1aafb2f1e4aa48c6a63ccc21dc766405, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  cacheDirectory: Assets/DCL/Caches/Playgrounds/CacheTest
+  cacheDirectory: /Users/nickkhalow/Library/Application Support/Decentraland/Explorer/DiskCacheV3
   testFile: Assets/DCL/MapRenderer/MapLayers/Atlas/SatelliteAtlasFallbackImages/0,0.jpg
 --- !u!1 &937544251
 GameObject:
@@ -328,14 +328,14 @@ Light:
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 937544251}
   m_Enabled: 1
-  serializedVersion: 11
+  serializedVersion: 12
   m_Type: 1
   m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
   m_Intensity: 1
   m_Range: 10
   m_SpotAngle: 30
   m_InnerSpotAngle: 21.80208
-  m_CookieSize: 10
+  m_CookieSize2D: {x: 10, y: 10}
   m_Shadows:
     m_Type: 2
     m_Resolution: -1
@@ -412,17 +412,23 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 474bcb49853aa07438625e644c072ee6, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  m_Version: 3
   m_UsePipelineSettings: 1
   m_AdditionalLightsShadowResolutionTier: 2
-  m_LightLayerMask: 1
-  m_RenderingLayers: 1
   m_CustomShadowLayers: 0
-  m_ShadowLayerMask: 1
-  m_ShadowRenderingLayers: 1
   m_LightCookieSize: {x: 1, y: 1}
   m_LightCookieOffset: {x: 0, y: 0}
   m_SoftShadowQuality: 0
+  m_RenderingLayersMask:
+    serializedVersion: 0
+    m_Bits: 1
+  m_ShadowRenderingLayersMask:
+    serializedVersion: 0
+    m_Bits: 1
+  m_Version: 4
+  m_LightLayerMask: 1
+  m_ShadowLayerMask: 1
+  m_RenderingLayers: 1
+  m_ShadowRenderingLayers: 1
 --- !u!1660057539 &9223372036854775807
 SceneRoots:
   m_ObjectHideFlags: 0

Explorer/Assets/DCL/Tests/PlayMode/PerformanceTests/LRUCacheCleanUpPerformanceTest.cs

@@ -0,0 +1,47 @@
+using DCL.Diagnostics;
+using DCL.Optimization.PerformanceBudgeting;
+using ECS.StreamableLoading.Common.Components;
+using NSubstitute;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using Unity.Profiling;
+using Unity.PerformanceTesting;
+using ECS.StreamableLoading.Cache.Disk;
+using ECS.StreamableLoading.Cache.Disk.CleanUp;
+using ECS.StreamableLoading.Cache.Disk.Lock;
+
+namespace DCL.Tests.PlayMode.PerformanceTests
+{
+    public class LRUCacheCleanUpPerformanceTest
+    {
+        private LRUDiskCleanUp cache;
+
+        [SetUp]
+        public void Setup()
+        {
+            CacheDirectory directory = CacheDirectory.NewDefault();
+            FilesLock filesLock = new FilesLock();
+            cache = new LRUDiskCleanUp(directory, filesLock);
+        }
+
+        [Test]
+        [Performance]
+        public void CleanUpIfNeeded()
+        {
+            ProfilerRecorder gcAlloc =
+                ProfilerRecorder.StartNew(ProfilerCategory.Memory, "GC.Alloc");
+
+            Measure
+                .Method(cache.CleanUpIfNeeded)
+                .WarmupCount(10)
+                .MeasurementCount(10)
+                .GC()
+                .Run();
+
+            Debug.Log($"GC Alloc: {gcAlloc.LastValue} bytes");
+        }
+    }
+}