From 2502f1f07f31abe30a641d651c9640f3d81c2c0f Mon Sep 17 00:00:00 2001
From: LDj3SNuD <35856442+LDj3SNuD@users.noreply.github.com>
Date: Thu, 24 Dec 2020 03:58:36 +0100
Subject: 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/ThreadStaticPool.cs | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

(limited to 'ARMeilleure/Common/ThreadStaticPool.cs')

diff --git a/ARMeilleure/Common/ThreadStaticPool.cs b/ARMeilleure/Common/ThreadStaticPool.cs
index cf3a7bb4..3fce28ec 100644
--- a/ARMeilleure/Common/ThreadStaticPool.cs
+++ b/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];
         }
 
-- 
cgit v1.2.3