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.

4 files changed, 52 insertions, 25 deletions

diff --git a/ARMeilleure/Translation/DirectCallStubs.cs b/ARMeilleure/Translation/DirectCallStubs.cs
index df7ca16e..57397d14 100644
--- a/ARMeilleure/Translation/DirectCallStubs.cs
+++ b/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;
             }
         }
diff --git a/ARMeilleure/Translation/PTC/Ptc.cs b/ARMeilleure/Translation/PTC/Ptc.cs
index b5a92b97..34492559 100644
--- a/ARMeilleure/Translation/PTC/Ptc.cs
+++ b/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;
-
-            Parallel.ForEach(profiledFuncsToTranslate, new ParallelOptions { MaxDegreeOfParallelism = maxDegreeOfParallelism }, (item, state) =>
+            void TranslateFuncs()
             {
-                ulong address = item.Key;
+                while (profiledFuncsToTranslate.TryDequeue(out var item))
+                {
+                    ulong address = item.address;
 
-                Debug.Assert(PtcProfiler.IsAddressInStaticCodeRange(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);
+                    bool isAddressUnique = funcs.TryAdd(address, func);
 
-                Debug.Assert(isAddressUnique, $"The address 0x{address:X16} is not unique.");
+                    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)
+                    {
+                        break;
+                    }
                 }
+            }
+
+            int maxDegreeOfParallelism = (Environment.ProcessorCount * 3) / 4;
 
-                Interlocked.Increment(ref _translateCount);
+            List<Thread> threads = new List<Thread>();
 
-                if (State != PtcState.Enabled)
-                {
-                    state.Stop();
-                }
-            });
+            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);
diff --git a/ARMeilleure/Translation/PTC/PtcProfiler.cs b/ARMeilleure/Translation/PTC/PtcProfiler.cs
index bc9814ec..0def32c3 100644
--- a/ARMeilleure/Translation/PTC/PtcProfiler.cs
+++ b/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));
                 }
             }
 
diff --git a/ARMeilleure/Translation/Translator.cs b/ARMeilleure/Translation/Translator.cs
index d78f5e21..612f6647 100644
--- a/ARMeilleure/Translation/Translator.cs
+++ b/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);
-            ResetOperationPool(highCq);
+            ReturnOperandPool(highCq);
+            ReturnOperationPool(highCq);
 
             return new TranslatedFunction(func, funcSize, highCq);
         }
 
+        internal static void ResetPools()
+        {
+            ResetOperandPools();
+            ResetOperationPools();
+        }
+
         private struct Range
         {
             public ulong Start { get; }