mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-09-10 13:43:17 +02:00
![FICTURE7](/assets/img/avatar_default.png)
* Add AddressTable<T> * Use AddressTable<T> for dispatch * Remove JumpTable & co. * Add fallback for out of range addresses * Add PPTC support * Add documentation to `AddressTable<T>` * Make AddressTable<T> configurable * Fix table walk * Fix IsMapped check * Remove CountTableCapacity * Add PPTC support for fast path * Rename IsMapped to IsValid * Remove stale comment * Change format of address in exception message * Add TranslatorStubs * Split DispatchStub Avoids recompilation of stubs during tests. * Add hint for 64bit or 32bit * Add documentation to `Symbol` * Add documentation to `TranslatorStubs` Make `TranslatorStubs` disposable as well. * Add documentation to `SymbolType` * Add `AddressTableEventSource` to monitor function table size Add an EventSource which measures the amount of unmanaged bytes allocated by AddressTable<T> instances. dotnet-counters monitor -n Ryujinx --counters ARMeilleure * Add `AllowLcqInFunctionTable` optimization toggle This is to reduce the impact this change has on the test duration. Before everytime a test was ran, the FunctionTable would be initialized and populated so that the newly compiled test would get registered to it. * Implement unmanaged dispatcher Uses the DispatchStub to dispatch into the next translation, which allows execution to stay in unmanaged for longer and skips a ConcurrentDictionary look up when the target translation has been registered to the FunctionTable. * Remove redundant null check * Tune levels of FunctionTable Uses 5 levels instead of 4 and change unit of AddressTableEventSource from KB to MB. * Use 64-bit function table Improves codegen for direct branches: mov qword [rax+0x408],0x10603560 - mov rcx,sub_10603560_OFFSET - mov ecx,[rcx] - mov ecx,ecx - mov rdx,JIT_CACHE_BASE - add rdx,rcx + mov rcx,sub_10603560 + mov rdx,[rcx] mov rcx,rax Improves codegen for dispatch stub: and rax,byte +0x1f - mov eax,[rcx+rax*4] - mov eax,eax - mov rcx,JIT_CACHE_BASE - lea rax,[rcx+rax] + mov rax,[rcx+rax*8] mov rcx,rbx * Remove `JitCacheSymbol` & `JitCache.Offset` * Turn `Translator.Translate` into an instance method We do not have to add more parameter to this method and related ones as new structures are added & needed for translation. * Add symbol only when PTC is enabled Address LDj3SNuD's feedback * Change `NativeContext.Running` to a 32-bit integer * Fix PageTable symbol for host mapped
197 lines
6.8 KiB
C#
197 lines
6.8 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Numerics;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace ARMeilleure.Common
|
|
{
|
|
/// <summary>
|
|
/// 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> : IDisposable where TEntry : unmanaged
|
|
{
|
|
private bool _disposed;
|
|
private int _freeHint;
|
|
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 desired page size in
|
|
/// bytes.
|
|
/// </summary>
|
|
/// <param name="pageSize">Desired page size in bytes</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 (pageSize < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(pageSize), "Page size cannot be negative.");
|
|
}
|
|
|
|
if (sizeof(TEntry) == 0)
|
|
{
|
|
throw new ArgumentException("Size of TEntry cannot be zero.");
|
|
}
|
|
|
|
_allocated = new BitMap();
|
|
_pages = new Dictionary<int, IntPtr>();
|
|
_pageLogCapacity = BitOperations.Log2((uint)(pageSize / sizeof(TEntry)));
|
|
_pageCapacity = 1 << _pageLogCapacity;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allocates an entry in the <see cref="EntryTable{TEntry}"/>.
|
|
/// </summary>
|
|
/// <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))
|
|
{
|
|
_freeHint = _allocated.FindFirstUnset();
|
|
}
|
|
|
|
int index = _freeHint++;
|
|
var page = GetPage(index);
|
|
|
|
_allocated.Set(index);
|
|
|
|
GetValue(page, index) = default;
|
|
|
|
return index;
|
|
}
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
if (_allocated.IsSet(index))
|
|
{
|
|
_allocated.Clear(index);
|
|
|
|
_freeHint = index;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 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 <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>
|
|
public ref TEntry GetValue(int index)
|
|
{
|
|
if (_disposed)
|
|
{
|
|
throw new ObjectDisposedException(null);
|
|
}
|
|
|
|
lock (_allocated)
|
|
{
|
|
if (!_allocated.IsSet(index))
|
|
{
|
|
throw new ArgumentException("Entry at the specified index was not allocated", nameof(index));
|
|
}
|
|
|
|
var page = GetPage(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}"/>
|
|
/// 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);
|
|
}
|
|
}
|
|
}
|