14ce9e1567
* Initial commit with a lot of testing stuff. * Partial Unmap Cleanup Part 1 * Fix some minor issues, hopefully windows tests. * Disable partial unmap tests on macos for now Weird issue. * Goodbye magic number * Add COMPlus_EnableAlternateStackCheck for tests `COMPlus_EnableAlternateStackCheck` is needed for NullReferenceException handling to work on linux after registering the signal handler, due to how dotnet registers its own signal handler. * Address some feedback * Force retry when memory is mapped in memory tracking This case existed before, but returning `false` no longer retries, so it would crash immediately after unprotecting the memory... Now, we return `true` to deliberately retry. This case existed before (was just broken by this change) and I don't really want to look into fixing the issue right now. Technically, this means that on guest code partial unmaps will retry _due to this_ rather than hitting the handler. I don't expect this to cause any issues. This should fix random crashes in Xenoblade Chronicles 2. * Use IsRangeMapped * Suppress MockMemoryManager.UnmapEvent warning This event is not signalled by the mock memory manager. * Remove 4kb mapping
93 lines
3.0 KiB
C#
93 lines
3.0 KiB
C#
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
|
|
using static Ryujinx.Common.Memory.PartialUnmaps.PartialUnmapHelpers;
|
|
|
|
namespace Ryujinx.Common.Memory.PartialUnmaps
|
|
{
|
|
/// <summary>
|
|
/// A simple fixed size thread safe map that can be used from native code.
|
|
/// Integer thread IDs map to corresponding structs.
|
|
/// </summary>
|
|
/// <typeparam name="T">The value type for the map</typeparam>
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
public struct ThreadLocalMap<T> where T : unmanaged
|
|
{
|
|
public const int MapSize = 20;
|
|
|
|
public Array20<int> ThreadIds;
|
|
public Array20<T> Structs;
|
|
|
|
public static int ThreadIdsOffset;
|
|
public static int StructsOffset;
|
|
|
|
/// <summary>
|
|
/// Populates the field offsets for use when emitting native code.
|
|
/// </summary>
|
|
static ThreadLocalMap()
|
|
{
|
|
ThreadLocalMap<T> instance = new ThreadLocalMap<T>();
|
|
|
|
ThreadIdsOffset = OffsetOf(ref instance, ref instance.ThreadIds);
|
|
StructsOffset = OffsetOf(ref instance, ref instance.Structs);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the index of a given thread ID in the map, or reserves one.
|
|
/// When reserving a struct, its value is set to the given initial value.
|
|
/// Returns -1 when there is no space to reserve a new entry.
|
|
/// </summary>
|
|
/// <param name="threadId">Thread ID to use as a key</param>
|
|
/// <param name="initial">Initial value of the associated struct.</param>
|
|
/// <returns>The index of the entry, or -1 if none</returns>
|
|
public int GetOrReserve(int threadId, T initial)
|
|
{
|
|
// Try get a match first.
|
|
|
|
for (int i = 0; i < MapSize; i++)
|
|
{
|
|
int compare = Interlocked.CompareExchange(ref ThreadIds[i], threadId, threadId);
|
|
|
|
if (compare == threadId)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
// Try get a free entry. Since the id is assumed to be unique to this thread, we know it doesn't exist yet.
|
|
|
|
for (int i = 0; i < MapSize; i++)
|
|
{
|
|
int compare = Interlocked.CompareExchange(ref ThreadIds[i], threadId, 0);
|
|
|
|
if (compare == 0)
|
|
{
|
|
Structs[i] = initial;
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the struct value for a given map entry.
|
|
/// </summary>
|
|
/// <param name="index">Index of the entry</param>
|
|
/// <returns>A reference to the struct value</returns>
|
|
public ref T GetValue(int index)
|
|
{
|
|
return ref Structs[index];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Releases an entry from the map.
|
|
/// </summary>
|
|
/// <param name="index">Index of the entry to release</param>
|
|
public void Release(int index)
|
|
{
|
|
Interlocked.Exchange(ref ThreadIds[index], 0);
|
|
}
|
|
}
|
|
}
|