mirror of
https://github.com/GreemDev/Ryujinx.git
synced 2024-12-23 08:05:47 +00:00
68f6b79fd3
* 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. * Add a simple Pools Limiter. * Nits. * Fix missing JumpTable.RegisterFunction() due to rebase. Clear MemoryStreams as soon as possible, when they are no longer needed. * Code cleaning. * Nit for retrigger Checks. * Update Ptc.cs * Contextual refactoring of Translator. Ignore resetting of pools for DirectCallStubs. * Nit for retrigger Checks.
141 lines
3.5 KiB
C#
141 lines
3.5 KiB
C#
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
|
|
namespace ARMeilleure.Common
|
|
{
|
|
class ThreadStaticPool<T> where T : class, new()
|
|
{
|
|
private const int ChunkSizeLimit = 1000; // even
|
|
private const int PoolSizeIncrement = 200; // > 0
|
|
|
|
[ThreadStatic]
|
|
private static ThreadStaticPool<T> _instance;
|
|
|
|
public static ThreadStaticPool<T> Instance
|
|
{
|
|
get
|
|
{
|
|
if (_instance == null)
|
|
{
|
|
PreparePool(0); // So that we can still use a pool when blindly initializing one.
|
|
}
|
|
|
|
return _instance;
|
|
}
|
|
}
|
|
|
|
private static ConcurrentDictionary<int, Stack<ThreadStaticPool<T>>> _pools = new();
|
|
|
|
private static Stack<ThreadStaticPool<T>> GetPools(int groupId)
|
|
{
|
|
return _pools.GetOrAdd(groupId, (groupId) => new());
|
|
}
|
|
|
|
public static void PreparePool(int groupId)
|
|
{
|
|
// Prepare the pool for this thread, ideally using an existing one from the specified group.
|
|
|
|
if (_instance == null)
|
|
{
|
|
var pools = GetPools(groupId);
|
|
lock (pools)
|
|
{
|
|
_instance = (pools.Count != 0) ? pools.Pop() : new();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void ReturnPool(int groupId)
|
|
{
|
|
// Reset, limit if necessary, and return the pool for this thread to the specified group.
|
|
|
|
var pools = GetPools(groupId);
|
|
lock (pools)
|
|
{
|
|
_instance.Clear();
|
|
_instance.ChunkSizeLimiter();
|
|
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)
|
|
{
|
|
foreach (var instance in pools)
|
|
{
|
|
instance.Dispose();
|
|
}
|
|
|
|
pools.Clear();
|
|
}
|
|
|
|
_pools.Clear();
|
|
}
|
|
|
|
private List<T[]> _pool;
|
|
private int _chunkIndex = -1;
|
|
private int _poolIndex = -1;
|
|
|
|
private ThreadStaticPool()
|
|
{
|
|
_pool = new(ChunkSizeLimit * 2);
|
|
|
|
AddChunkIfNeeded();
|
|
}
|
|
|
|
public T Allocate()
|
|
{
|
|
if (++_poolIndex >= PoolSizeIncrement)
|
|
{
|
|
AddChunkIfNeeded();
|
|
|
|
_poolIndex = 0;
|
|
}
|
|
|
|
return _pool[_chunkIndex][_poolIndex];
|
|
}
|
|
|
|
private void AddChunkIfNeeded()
|
|
{
|
|
if (++_chunkIndex >= _pool.Count)
|
|
{
|
|
T[] pool = new T[PoolSizeIncrement];
|
|
|
|
for (int i = 0; i < PoolSizeIncrement; i++)
|
|
{
|
|
pool[i] = new T();
|
|
}
|
|
|
|
_pool.Add(pool);
|
|
}
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
_chunkIndex = 0;
|
|
_poolIndex = -1;
|
|
}
|
|
|
|
private void ChunkSizeLimiter()
|
|
{
|
|
if (_pool.Count >= ChunkSizeLimit)
|
|
{
|
|
int newChunkSize = ChunkSizeLimit / 2;
|
|
|
|
_pool.RemoveRange(newChunkSize, _pool.Count - newChunkSize);
|
|
_pool.Capacity = ChunkSizeLimit * 2;
|
|
}
|
|
}
|
|
|
|
private void Dispose()
|
|
{
|
|
_pool.Clear();
|
|
}
|
|
}
|
|
}
|