deadcade/Ryujinx
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Make EntryTable<T> expandable

Browse source 
* EntryTable is now expandable instead of being a fixed slab.
* Remove EntryTable<T>.TryAllocate
* Remove Counter<T>.TryCreate

Address LDj3SNuD's feedback
This commit is contained in:
FICTURE7 2021-04-16 18:20:05 +04:00
parent 5b4543e62c
commit 9c0dbb9c07
4 changed files with 155 additions and 95 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

57
ARMeilleure/Common/Counter.cs
View file

@ -18,10 +18,22 @@ namespace ARMeilleure.Common
/// </summary>
/// <param name="countTable"><see cref="EntryTable{T}"/> instance</param>
/// <param name="index">Index in the <see cref="EntryTable{T}"/></param>
private Counter(EntryTable<T> countTable, int index)
/// <exception cref="ArgumentNullException"><paramref name="countTable"/> is <see langword="null"/></exception>
/// <exception cref="ArgumentException"><typeparamref name="T"/> is unsupported</exception>
public Counter(EntryTable<T> countTable)
{
_countTable = countTable;
_index = index;
if (typeof(T) != typeof(byte) && typeof(T) != typeof(sbyte) &&
typeof(T) != typeof(short) && typeof(T) != typeof(ushort) &&
typeof(T) != typeof(int) && typeof(T) != typeof(uint) &&
typeof(T) != typeof(long) && typeof(T) != typeof(ulong) &&
typeof(T) != typeof(nint) && typeof(T) != typeof(nuint) &&
typeof(T) != typeof(float) && typeof(T) != typeof(double))
{
throw new ArgumentException("Counter does not support the specified type.");
}
_countTable = countTable ?? throw new ArgumentNullException(nameof(countTable));
_index = countTable.Allocate();
}
/// <summary>
@ -67,48 +79,11 @@ namespace ARMeilleure.Common
}
/// <summary>
/// Frees resources used by <see cref="Counter{T}"/> instance.
/// Frees resources used by the <see cref="Counter{T}"/> instance.
/// </summary>
~Counter()
{
Dispose(false);
}
/// <summary>
/// Tries to create a <see cref="Counter{T}"/> instance from the specified <see cref="EntryTable{T}"/> instance.
/// </summary>
/// <param name="countTable"><see cref="EntryTable{T}"/> from which to create the <see cref="Counter{T}"/></param>
/// <param name="counter"><see cref="Counter{T}"/> instance if success; otherwise <see langword="null"/></param>
/// <returns><see langword="true"/> if success; otherwise <see langword="false"/></returns>
/// <exception cref="ArgumentNullException"><paramref name="countTable"/> is <see langword="null"/></exception>
/// <exception cref="ArgumentException"><typeparamref name="T"/> is unsupported</exception>
public static bool TryCreate(EntryTable<T> countTable, out Counter<T> counter)
{
if (countTable == null)
{
throw new ArgumentNullException(nameof(countTable));
}
if (typeof(T) != typeof(byte) && typeof(T) != typeof(sbyte) &&
typeof(T) != typeof(short) && typeof(T) != typeof(ushort) &&
typeof(T) != typeof(int) && typeof(T) != typeof(uint) &&
typeof(T) != typeof(long) && typeof(T) != typeof(ulong) &&
typeof(T) != typeof(nint) && typeof(T) != typeof(nuint) &&
typeof(T) != typeof(float) && typeof(T) != typeof(double))
{
throw new ArgumentException("Counter does not support the specified type", nameof(countTable));
}
if (countTable.TryAllocate(out int index))
{
counter = new Counter<T>(countTable, index);
return true;
}
counter = null;
return false;
}
}
}

161
ARMeilleure/Common/EntryTable.cs
View file

@ -1,43 +1,63 @@
using System;
using System.Collections.Generic;
using System.Numerics;
using System.Runtime.InteropServices;
namespace ARMeilleure.Common
{
/// <summary>
/// Represents a fixed size table of the type <typeparamref name="TEntry"/>, whose entries will remain at the same
/// Represents an expandable table of the type <typeparamref name="TEntry"/>, whose entries will remain at the same
/// address through out the table's lifetime.
/// </summary>
/// <typeparam name="TEntry">Type of the entry in the table</typeparam>
class EntryTable<TEntry> where TEntry : unmanaged
class EntryTable<TEntry> : IDisposable where TEntry : unmanaged
{
private bool _disposed;
private int _freeHint;
private readonly TEntry[] _table;
private readonly int _pageCapacity; // Number of entries per page.
private readonly int _pageLogCapacity;
private readonly Dictionary<int, IntPtr> _pages;
private readonly BitMap _allocated;
/// <summary>
/// Initializes a new instance of the <see cref="EntryTable{TEntry}"/> class with the specified capacity.
/// Initializes a new instance of the <see cref="EntryTable{TEntry}"/> class with the desired page size.
/// </summary>
/// <param name="capacity">Capacity of the table</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="capacity"/> is less than 0</exception>
public EntryTable(int capacity)
/// <param name="pageSize">Desired page size</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="pageSize"/> is less than 0</exception>
/// <exception cref="ArgumentException"><typeparamref name="TEntry"/>'s size is zero</exception>
/// <remarks>
/// The actual page size may be smaller or larger depending on the size of <typeparamref name="TEntry"/>.
/// </remarks>
public unsafe EntryTable(int pageSize = 4096)
{
if (capacity < 0)
if (pageSize < 0)
{
throw new ArgumentOutOfRangeException(nameof(capacity));
throw new ArgumentOutOfRangeException(nameof(pageSize), "Page size cannot be negative.");
}
if (sizeof(TEntry) == 0)
{
throw new ArgumentException("Size of TEntry cannot be zero.");
}
_freeHint = 0;
_allocated = new BitMap();
_table = GC.AllocateArray<TEntry>(capacity, pinned: true);
_pages = new Dictionary<int, IntPtr>();
_pageLogCapacity = BitOperations.Log2((uint)(pageSize / sizeof(TEntry)));
_pageCapacity = 1 << _pageLogCapacity;
}
/// <summary>
/// Tries to allocate an entry in the <see cref="EntryTable{TEntry}"/>. Returns <see langword="true"/> if
/// success; otherwise returns <see langword="false"/>.
/// Allocates an entry in the <see cref="EntryTable{TEntry}"/>.
/// </summary>
/// <param name="index">Index of entry allocated in the table</param>
/// <returns><see langword="true"/> if success; otherwise <see langword="false"/></returns>
public bool TryAllocate(out int index)
/// <returns>Index of entry allocated in the table</returns>
/// <exception cref="ObjectDisposedException"><see cref="EntryTable{TEntry}"/> instance was disposed</exception>
public int Allocate()
{
if (_disposed)
{
throw new ObjectDisposedException(null);
}
lock (_allocated)
{
if (_allocated.IsSet(_freeHint))
@ -45,32 +65,37 @@ namespace ARMeilleure.Common
_freeHint = _allocated.FindFirstUnset();
}
if (_freeHint >= 0 && _freeHint < _table.Length)
{
index = _freeHint++;
int index = _freeHint++;
var page = GetPage(index);
_allocated.Set(index);
_allocated.Set(index);
GetValue(index) = default;
GetValue(page, index) = default;
return true;
}
return index;
}
index = 0;
return false;
}
/// <summary>
/// Frees the entry at the specified <paramref name="index"/>.
/// </summary>
/// <param name="index">Index of entry to free</param>
/// <exception cref="ObjectDisposedException"><see cref="EntryTable{TEntry}"/> instance was disposed</exception>
public void Free(int index)
{
if (_disposed)
{
throw new ObjectDisposedException(null);
}
lock (_allocated)
{
_allocated.Clear(index);
if (_allocated.IsSet(index))
{
_allocated.Clear(index);
_freeHint = index;
}
}
}
@ -78,25 +103,95 @@ namespace ARMeilleure.Common
/// Gets a reference to the entry at the specified allocated <paramref name="index"/>.
/// </summary>
/// <param name="index">Index of the entry</param>
/// <returns>Reference to the entry at the specified index</returns>
/// <returns>Reference to the entry at the specified <paramref name="index"/></returns>
/// <exception cref="ObjectDisposedException"><see cref="EntryTable{TEntry}"/> instance was disposed</exception>
/// <exception cref="ArgumentException">Entry at <paramref name="index"/> is not allocated</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is outside of the table</exception>
public ref TEntry GetValue(int index)
{
if (index < 0 || index >= _table.Length)
if (_disposed)
{
throw new ArgumentOutOfRangeException(nameof(index));
throw new ObjectDisposedException(null);
}
Span<TEntry> page;
lock (_allocated)
{
if (!_allocated.IsSet(index))
{
throw new ArgumentException("Entry at the specified index was not allocated", nameof(index));
}
page = GetPage(index);
}
return ref _table[index];
return ref GetValue(page, index);
}
/// <summary>
/// Gets a reference to the entry at using the specified <paramref name="index"/> from the specified
/// <paramref name="page"/>.
/// </summary>
/// <param name="page">Page to use</param>
/// <param name="index">Index to use</param>
/// <returns>Reference to the entry</returns>
private ref TEntry GetValue(Span<TEntry> page, int index)
{
return ref page[index & (_pageCapacity - 1)];
}
/// <summary>
/// Gets the page for the specified <see cref="index"/>.
/// </summary>
/// <param name="index">Index to use</param>
/// <returns>Page for the specified <see cref="index"/></returns>
private unsafe Span<TEntry> GetPage(int index)
{
var pageIndex = (int)((uint)(index & ~(_pageCapacity - 1)) >> _pageLogCapacity);
if (!_pages.TryGetValue(pageIndex, out IntPtr page))
{
page = Marshal.AllocHGlobal(sizeof(TEntry) * _pageCapacity);
_pages.Add(pageIndex, page);
}
return new Span<TEntry>((void*)page, _pageCapacity);
}
/// <summary>
/// Releases all resources used by the <see cref="EntryTable{TEntry}"/> instance.
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
/// <summary>
/// Releases all unmanaged and optionally managed resources used by the <see cref="EntryTable{TEntry}{T}"/>
/// instance.
/// </summary>
/// <param name="disposing"><see langword="true"/> to dispose managed resources also; otherwise just unmanaged resouces</param>
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
foreach (var page in _pages.Values)
{
Marshal.FreeHGlobal(page);
}
_disposed = true;
}
}
/// <summary>
/// Frees resources used by the <see cref="EntryTable{TEntry}"/> instance.
/// </summary>
~EntryTable()
{
Dispose(false);
}
}
}

19
ARMeilleure/Translation/PTC/Ptc.cs
View file

@ -579,12 +579,7 @@ namespace ARMeilleure.Translation.PTC
{
RelocEntry[] relocEntries = GetRelocEntries(relocsReader, infoEntry.RelocEntriesCount);
if (!PatchCode(code, relocEntries, memory.PageTablePointer, jumpTable, countTable, out callCounter))
{
SkipUnwindInfo(unwindInfosReader);
continue;
}
PatchCode(code, relocEntries, memory.PageTablePointer, jumpTable, countTable, out callCounter);
}
UnwindInfo unwindInfo = ReadUnwindInfo(unwindInfosReader);
@ -683,7 +678,7 @@ namespace ARMeilleure.Translation.PTC
return relocEntries;
}
private static bool PatchCode(
private static void PatchCode(
Span<byte> code,
RelocEntry[] relocEntries,
IntPtr pageTablePointer,
@ -711,13 +706,9 @@ namespace ARMeilleure.Translation.PTC
}
else if (relocEntry.Index == CountTableIndex)
{
// If we could not allocate an entry on the count table we dip.
if (!Counter<uint>.TryCreate(countTable, out Counter<uint> counter))
{
return false;
}
callCounter = new Counter<uint>(countTable);
unsafe { imm = (ulong)Unsafe.AsPointer(ref counter.Value); }
unsafe { imm = (ulong)Unsafe.AsPointer(ref callCounter.Value); }
}
else if (Delegates.TryGetDelegateFuncPtrByIndex(relocEntry.Index, out IntPtr funcPtr))
{
@ -730,8 +721,6 @@ namespace ARMeilleure.Translation.PTC
BinaryPrimitives.WriteUInt64LittleEndian(code.Slice(relocEntry.Position, 8), imm);
}
return true;
}
private static UnwindInfo ReadUnwindInfo(BinaryReader unwindInfosReader)

13
ARMeilleure/Translation/Translator.cs
View file

@ -57,7 +57,7 @@ namespace ARMeilleure.Translation
_backgroundTranslatorEvent = new AutoResetEvent(false);
_backgroundTranslatorLock = new ReaderWriterLock();
CountTable = new EntryTable<uint>(CountTableCapacity);
CountTable = new EntryTable<uint>();
JitCache.Initialize(allocator);
@ -174,6 +174,8 @@ namespace ARMeilleure.Translation
_jumpTable.Dispose();
_jumpTable = null;
CountTable.Dispose();
GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
}
}
@ -393,14 +395,11 @@ namespace ARMeilleure.Translation
return context.GetControlFlowGraph();
}
internal static void EmitRejitCheck(ArmEmitterContext context, out Counter<uint> counter)
internal static Counter<uint> EmitRejitCheck(ArmEmitterContext context, out Counter<uint> counter)
{
const int MinsCallForRejit = 100;
if (!Counter<uint>.TryCreate(context.CountTable, out counter))
{
return;
}
counter = new Counter<uint>(context.CountTable);
Operand lblEnd = Label();
@ -413,6 +412,8 @@ namespace ARMeilleure.Translation
context.Call(typeof(NativeInterface).GetMethod(nameof(NativeInterface.EnqueueForRejit)), Const(context.EntryAddress));
context.MarkLabel(lblEnd);
return counter;
}
internal static void EmitSynchronization(EmitterContext context)