Free up memory allocated by Pools during any PPTC translations at boot time. (#1814)

* Added support for offline invalidation, via PPTC, of low cq translations replaced by high cq translations; both on a single run and between runs.

Added invalidation of .cache files in the event of reuse on a different user operating system.

Added .info and .cache files invalidation in case of a failed stream decompression.

Nits.

* InternalVersion = 1712;

* Nits.

* Address comment.

* Get rid of BinaryFormatter.

Nits.

* Move Ptc.LoadTranslations().

Nits.

* Nits.

* Fixed corner cases (in case backup copies have to be used). Added save logs.

* Not core fixes.

* Complement to the previous commit. Added load logs. Removed BinaryFormatter leftovers.

* Add LoadTranslations log.

* Nits.

* Removed the search and management of LowCq overlapping functions.

* Final increment of .info and .cache flags.

* Nit.

* Free up memory allocated by Pools during any PPTC translations at boot time.

* Nit due to rebase.

ARMeilleure/Common/BitMapPool.cs

@@ -1,6 +1,4 @@
-using System;
+namespace ARMeilleure.Common
-
-namespace ARMeilleure.Common
 {
     static class BitMapPool
     {
@@ -8,6 +6,7 @@ namespace ARMeilleure.Common
         {
             BitMap result = ThreadStaticPool<BitMap>.Instance.Allocate();
             result.Reset(initialCapacity);
+
             return result;
         }
 

ARMeilleure/Common/ThreadStaticPool.cs

@@ -5,12 +5,13 @@ using System.Threading;
 
 namespace ARMeilleure.Common
 {
-    internal class ThreadStaticPool<T> where T : class, new()
+    class ThreadStaticPool<T> where T : class, new()
     {
         private const int PoolSizeIncrement = 200;
 
         [ThreadStatic]
         private static ThreadStaticPool<T> _instance;
+
         public static ThreadStaticPool<T> Instance
         {
             get
@@ -19,6 +20,7 @@ namespace ARMeilleure.Common
                 {
                     PreparePool(0); // So that we can still use a pool when blindly initializing one.
                 }
+
                 return _instance;
             }
         }
@@ -33,9 +35,10 @@ namespace ARMeilleure.Common
         public static void PreparePool(int groupId)
         {
             // Prepare the pool for this thread, ideally using an existing one from the specified group.
+
             if (_instance == null)
             {
-                Stack<ThreadStaticPool<T>> pools = GetPools(groupId);
+                var pools = GetPools(groupId);
                 lock (pools)
                 {
                     _instance = (pools.Count != 0) ? pools.Pop() : new ThreadStaticPool<T>(PoolSizeIncrement * 2);
@@ -46,15 +49,29 @@ namespace ARMeilleure.Common
         public static void ReturnPool(int groupId)
         {
             // Reset and return the pool for this thread to the specified group.
-            Stack<ThreadStaticPool<T>> pools = GetPools(groupId);
+
+            var pools = GetPools(groupId);
             lock (pools)
             {
                 _instance.Clear();
                 pools.Push(_instance);
+
                 _instance = null;
             }
         }
 
+        public static void ResetPools()
+        {
+            // Resets any static references to the pools used by threads for each group, allowing them to be garbage collected.
+
+            foreach (var pools in _pools.Values)
+            {
+                pools.Clear();
+            }
+
+            _pools.Clear();
+        }
+
         private T[] _pool;
         private int _poolUsed = -1;
         private int _poolSize;
@@ -74,10 +91,12 @@ namespace ARMeilleure.Common
         public T Allocate()
         {
             int index = Interlocked.Increment(ref _poolUsed);
+
             if (index >= _poolSize)
             {
                 IncreaseSize();
             }
+
             return _pool[index];
         }
 

ARMeilleure/IntermediateRepresentation/OperandHelper.cs

@@ -90,10 +90,16 @@ namespace ARMeilleure.IntermediateRepresentation
             ThreadStaticPool<MemoryOperand>.PreparePool(highCq ? 1 : 0);
         }
 
-        public static void ResetOperandPool(bool highCq)
+        public static void ReturnOperandPool(bool highCq)
         {
             ThreadStaticPool<Operand>.ReturnPool(highCq ? 1 : 0);
             ThreadStaticPool<MemoryOperand>.ReturnPool(highCq ? 1 : 0);
         }
+
+        public static void ResetOperandPools()
+        {
+            ThreadStaticPool<Operand>.ResetPools();
+            ThreadStaticPool<MemoryOperand>.ResetPools();
+        }
     }
 }

ARMeilleure/IntermediateRepresentation/OperationHelper.cs

@@ -51,9 +51,14 @@ namespace ARMeilleure.IntermediateRepresentation
             ThreadStaticPool<Operation>.PreparePool(highCq ? 1 : 0);
         }
 
-        public static void ResetOperationPool(bool highCq)
+        public static void ReturnOperationPool(bool highCq)
         {
             ThreadStaticPool<Operation>.ReturnPool(highCq ? 1 : 0);
         }
+
+        public static void ResetOperationPools()
+        {
+            ThreadStaticPool<Operation>.ResetPools();
+        }
     }
 }

ARMeilleure/Translation/DirectCallStubs.cs

@@ -34,6 +34,8 @@ namespace ARMeilleure.Translation
                 _indirectCallStubPtr     = Marshal.GetFunctionPointerForDelegate<GuestFunction>(GenerateIndirectCallStub(false));
                 _indirectTailCallStubPtr = Marshal.GetFunctionPointerForDelegate<GuestFunction>(GenerateIndirectCallStub(true));
 
+                Translator.ResetPools();
+
                 _initialized = true;
             }
         }

ARMeilleure/Translation/PTC/Ptc.cs

@@ -8,13 +8,13 @@ using Ryujinx.Common.Logging;
 using System;
 using System.Buffers.Binary;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.IO.Compression;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace ARMeilleure.Translation.PTC
 {
@@ -664,35 +664,50 @@ namespace ARMeilleure.Translation.PTC
 
             ThreadPool.QueueUserWorkItem(TranslationLogger, profiledFuncsToTranslate.Count);
 
-            int maxDegreeOfParallelism = (Environment.ProcessorCount * 3) / 4;
+            void TranslateFuncs()
-
-            Parallel.ForEach(profiledFuncsToTranslate, new ParallelOptions { MaxDegreeOfParallelism = maxDegreeOfParallelism }, (item, state) =>
             {
-                ulong address = item.Key;
+                while (profiledFuncsToTranslate.TryDequeue(out var item))
+                {
+                    ulong address = item.address;
 
                     Debug.Assert(PtcProfiler.IsAddressInStaticCodeRange(address));
 
-                TranslatedFunction func = Translator.Translate(memory, jumpTable, address, item.Value.mode, item.Value.highCq);
+                    TranslatedFunction func = Translator.Translate(memory, jumpTable, address, item.mode, item.highCq);
 
                     bool isAddressUnique = funcs.TryAdd(address, func);
 
                     Debug.Assert(isAddressUnique, $"The address 0x{address:X16} is not unique.");
 
-                if (func.HighCq)
-                {
-                    jumpTable.RegisterFunction(address, func);
-                }
-
                     Interlocked.Increment(ref _translateCount);
 
                     if (State != PtcState.Enabled)
                     {
-                    state.Stop();
+                        break;
                     }
-            });
+                }
+            }
+
+            int maxDegreeOfParallelism = (Environment.ProcessorCount * 3) / 4;
+
+            List<Thread> threads = new List<Thread>();
+
+            for (int i = 0; i < maxDegreeOfParallelism; i++)
+            {
+                Thread thread = new Thread(TranslateFuncs);
+                thread.IsBackground = true;
+
+                threads.Add(thread);
+            }
+
+            threads.ForEach((thread) => thread.Start());
+            threads.ForEach((thread) => thread.Join());
+
+            threads.Clear();
 
             _loggerEvent.Set();
 
+            Translator.ResetPools();
+
             PtcJumpTable.Initialize(jumpTable);
 
             PtcJumpTable.ReadJumpTable(jumpTable);

ARMeilleure/Translation/PTC/PtcProfiler.cs

@@ -85,15 +85,17 @@ namespace ARMeilleure.Translation.PTC
             return address >= StaticCodeStart && address < StaticCodeStart + StaticCodeSize;
         }
 
-        internal static Dictionary<ulong, (ExecutionMode mode, bool highCq)> GetProfiledFuncsToTranslate(ConcurrentDictionary<ulong, TranslatedFunction> funcs)
+        internal static ConcurrentQueue<(ulong address, ExecutionMode mode, bool highCq)> GetProfiledFuncsToTranslate(ConcurrentDictionary<ulong, TranslatedFunction> funcs)
         {
-            var profiledFuncsToTranslate = new Dictionary<ulong, (ExecutionMode mode, bool highCq)>(ProfiledFuncs);
+            var profiledFuncsToTranslate = new ConcurrentQueue<(ulong address, ExecutionMode mode, bool highCq)>();
 
-            foreach (ulong address in profiledFuncsToTranslate.Keys)
+            foreach (var profiledFunc in ProfiledFuncs)
             {
-                if (funcs.ContainsKey(address))
+                ulong address = profiledFunc.Key;
+
+                if (!funcs.ContainsKey(address))
                 {
-                    profiledFuncsToTranslate.Remove(address);
+                    profiledFuncsToTranslate.Enqueue((address, profiledFunc.Value.mode, profiledFunc.Value.highCq));
                 }
             }
 

ARMeilleure/Translation/Translator.cs

@@ -148,6 +148,8 @@ namespace ARMeilleure.Translation
 
                 ClearJitCache();
 
+                ResetPools();
+
                 _jumpTable.Dispose();
                 _jumpTable = null;
             }
@@ -249,12 +251,18 @@ namespace ARMeilleure.Translation
                 }
             }
 
-            ResetOperandPool(highCq);
+            ReturnOperandPool(highCq);
-            ResetOperationPool(highCq);
+            ReturnOperationPool(highCq);
 
             return new TranslatedFunction(func, funcSize, highCq);
         }
 
+        internal static void ResetPools()
+        {
+            ResetOperandPools();
+            ResetOperationPools();
+        }
+
         private struct Range
         {
             public ulong Start { get; }