lazy-load cached files to reduce memory footprint (WS Shareable)

update and use LastAccessTime of cached files to make LRU more reasonable

Author: viruscamp

DependenciesLib/BinaryCache.cs

@@ -4,7 +4,8 @@
 using System.Diagnostics;
 using Dependencies.ClrPh;
 using System.ComponentModel;
-
+using System.Linq;
+
 namespace Dependencies
 {
 
@@ -292,8 +293,7 @@ public class BinaryCacheImpl :  BinaryCache
     {
         public BinaryCacheImpl(string ApplicationAppDataPath, int _MaxBinaryCount)
         {
-
-            BinaryDatabase = new Dictionary<string, PE>();
+            BinaryDatabase = new Dictionary<string, Lazy<PE>>();
             BinaryDatabaseLock = new Object();
             LruCache = new List<string>();
 
@@ -306,10 +306,13 @@ public BinaryCacheImpl(string ApplicationAppDataPath, int _MaxBinaryCount)
 
         public override void Load()
         {
-            // "warm up" the cache
-            foreach (var CachedBinary in Directory.EnumerateFiles(BinaryCacheFolderPath))
-            {
-                GetBinaryAsync(CachedBinary);
+            // load cached file order by LastAccessTime to make LRU always available
+            foreach (var cachedBinaryFile in new DirectoryInfo(BinaryCacheFolderPath).EnumerateFiles()
+                .OrderByDescending(fi => fi.LastAccessTime))
+            {
+                var peHash = cachedBinaryFile.Name;
+                LruCache.Add(peHash);
+                BinaryDatabase.Add(peHash, new Lazy<PE>(() => LoadCachedBinary(peHash), true));
             }
 
             string System32Folder = Environment.GetFolderPath(Environment.SpecialFolder.System);
@@ -339,9 +342,7 @@ public override void Load()
                 {
                     GetBinaryAsync(Path.Combine(SysWow64Folder, KnownDll));
                 }
-
             }
-
         }
 
         public override void Unload()
@@ -358,7 +359,11 @@ public override void Unload()
                     // Force map unloading before deleting file
                     if (BinaryDatabase.ContainsKey(PeHash))
                     {
-                        BinaryDatabase[PeHash].Unload();
+                        var lazyPE = BinaryDatabase[PeHash];
+                        if (lazyPE.IsValueCreated)
+                        {
+                            lazyPE.Value.Unload();
+                        }
                     }
 
                     try
@@ -371,20 +376,53 @@ public override void Unload()
                         // so only the last one alive can clear the cache.
                         Debug.WriteLine("[BinaryCache] Could not unload file {0:s} : {1:s} ", CachedBinary, uae);
                     }
-
                 }
             }
 
-
             // flush the cache
             BinaryDatabase.Clear();
         }
 
+        private PE LoadCachedBinary(string peHash)
+        {
+            var cachedBinaryFile = Path.Combine(BinaryCacheFolderPath, peHash);
+            if (!NativeFile.Exists(cachedBinaryFile))
+            {
+                lock (BinaryDatabaseLock)
+                {
+                    LruCache.Remove(peHash);
+                    BinaryDatabase.Remove(peHash);
+                }
+                return null;
+            }
+
+            PE cachedPE = new PE(cachedBinaryFile);
+            try
+            {
+                // update LastAccessTime to save LRU to disk
+                // note: Windows from Vista disable updating LastAccessTime by default,
+                // so we have to update it manually.
+                new FileInfo(cachedBinaryFile).LastAccessTime = DateTime.Now;
+            }
+            catch { }
+
+            if (!cachedPE.Load())
+            {
+                lock (BinaryDatabaseLock)
+                {
+                    LruCache.Remove(peHash);
+                    BinaryDatabase.Remove(peHash);
+                }
+                return null;
+            }
+
+            return cachedPE;
+        }
+
         public void GetBinaryAsync(string PePath, RunWorkerCompletedEventHandler Callback = null)
         {
             BackgroundWorker bw = new BackgroundWorker();
             bw.DoWork += (sender, e) => {
-
                 GetBinary(PePath);
             };
 
@@ -393,7 +431,6 @@ public void GetBinaryAsync(string PePath, RunWorkerCompletedEventHandler Callbac
                 bw.RunWorkerCompleted += Callback;
             }
 
-
             bw.RunWorkerAsync();
         }
 
@@ -419,25 +456,25 @@ public override PE GetBinary(string PePath)
                 // Cache "miss"
                 if (!hit)
                 {
-
                     string DestFilePath = Path.Combine(BinaryCacheFolderPath, PeHash);
                     if (!File.Exists(DestFilePath) && (DestFilePath != PePath))
                     {
                         // Debug.WriteLine(String.Format("FileCopy from {0:s} to {1:s}", PePath, DestFilePath), "BinaryCache");
                         NativeFile.Copy(PePath, DestFilePath);
-                    }
-
-                    PE NewShadowBinary = new PE(DestFilePath);
-                    NewShadowBinary.Load();
-
-                    LruCache.Add(PeHash);
-                    BinaryDatabase.Add(PeHash, NewShadowBinary);
+                    }
+
+                    LruCache.Add(PeHash);
+                    BinaryDatabase.Add(PeHash, new Lazy<PE>(() => LoadCachedBinary(PeHash)));
                 }
             }
 
             // Cache "Hit"
             UpdateLru(PeHash);
-            PE ShadowBinary = BinaryDatabase[PeHash];
+            PE ShadowBinary = BinaryDatabase[PeHash].Value;
+            if (ShadowBinary == null)
+            {
+                return null;
+            }
             ShadowBinary.Filepath = Path.GetFullPath(PePath); // convert any paths to an absolute one.
 
             Debug.WriteLine(String.Format("File {0:s} loaded from {1:s}", PePath, Path.Combine(BinaryCacheFolderPath, PeHash)), "BinaryCache");
@@ -465,7 +502,7 @@ protected void UpdateLru(string PeHash)
 
         #region Members
         private List<string> LruCache;
-        private Dictionary<string, PE> BinaryDatabase;
+        private Dictionary<string, Lazy<PE>> BinaryDatabase;
         private Object BinaryDatabaseLock;
 
         private string BinaryCacheFolderPath;