mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-17 14:18:44 +02:00
Enable CPU JIT cache invalidation (#2965)
* Enable CPU JIT cache invalidation * Invalidate cache on IC IVAU
This commit is contained in:
parent
72e543e946
commit
92d166ecb7
12 changed files with 911 additions and 14 deletions
|
@ -12,7 +12,8 @@ namespace ARMeilleure.Instructions
|
||||||
{
|
{
|
||||||
static partial class InstEmit
|
static partial class InstEmit
|
||||||
{
|
{
|
||||||
private const int DczSizeLog2 = 4;
|
private const int DczSizeLog2 = 4; // Log2 size in words
|
||||||
|
public const int DczSizeInBytes = 4 << DczSizeLog2;
|
||||||
|
|
||||||
public static void Hint(ArmEmitterContext context)
|
public static void Hint(ArmEmitterContext context)
|
||||||
{
|
{
|
||||||
|
@ -87,7 +88,7 @@ namespace ARMeilleure.Instructions
|
||||||
// DC ZVA
|
// DC ZVA
|
||||||
Operand t = GetIntOrZR(context, op.Rt);
|
Operand t = GetIntOrZR(context, op.Rt);
|
||||||
|
|
||||||
for (long offset = 0; offset < (4 << DczSizeLog2); offset += 8)
|
for (long offset = 0; offset < DczSizeInBytes; offset += 8)
|
||||||
{
|
{
|
||||||
Operand address = context.Add(t, Const(offset));
|
Operand address = context.Add(t, Const(offset));
|
||||||
|
|
||||||
|
@ -100,6 +101,11 @@ namespace ARMeilleure.Instructions
|
||||||
// No-op
|
// No-op
|
||||||
case 0b11_011_0111_1110_001: // DC CIVAC
|
case 0b11_011_0111_1110_001: // DC CIVAC
|
||||||
break;
|
break;
|
||||||
|
|
||||||
|
case 0b11_011_0111_0101_001: // IC IVAU
|
||||||
|
Operand target = Register(op.Rt, RegisterType.Integer, OperandType.I64);
|
||||||
|
context.Call(typeof(NativeInterface).GetMethod(nameof(NativeInterface.InvalidateCacheLine)), target);
|
||||||
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -242,6 +242,11 @@ namespace ARMeilleure.Instructions
|
||||||
return (ulong)function.FuncPtr.ToInt64();
|
return (ulong)function.FuncPtr.ToInt64();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
public static void InvalidateCacheLine(ulong address)
|
||||||
|
{
|
||||||
|
Context.Translator.InvalidateJitCacheRegion(address, InstEmit.DczSizeInBytes);
|
||||||
|
}
|
||||||
|
|
||||||
public static bool CheckSynchronization()
|
public static bool CheckSynchronization()
|
||||||
{
|
{
|
||||||
Statistics.PauseTimer();
|
Statistics.PauseTimer();
|
||||||
|
|
|
@ -114,6 +114,7 @@ namespace ARMeilleure.Translation
|
||||||
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetFpscr))); // A32 only.
|
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetFpscr))); // A32 only.
|
||||||
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetFpsr)));
|
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetFpsr)));
|
||||||
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetFunctionAddress)));
|
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetFunctionAddress)));
|
||||||
|
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.InvalidateCacheLine)));
|
||||||
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidr)));
|
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidr)));
|
||||||
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidr32))); // A32 only.
|
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidr32))); // A32 only.
|
||||||
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidrEl0)));
|
SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidrEl0)));
|
||||||
|
|
756
ARMeilleure/Translation/IntervalTree.cs
Normal file
756
ARMeilleure/Translation/IntervalTree.cs
Normal file
|
@ -0,0 +1,756 @@
|
||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
|
||||||
|
namespace ARMeilleure.Translation
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// An Augmented Interval Tree based off of the "TreeDictionary"'s Red-Black Tree. Allows fast overlap checking of ranges.
|
||||||
|
/// </summary>
|
||||||
|
/// <typeparam name="K">Key</typeparam>
|
||||||
|
/// <typeparam name="V">Value</typeparam>
|
||||||
|
public class IntervalTree<K, V> where K : IComparable<K>
|
||||||
|
{
|
||||||
|
private const int ArrayGrowthSize = 32;
|
||||||
|
|
||||||
|
private const bool Black = true;
|
||||||
|
private const bool Red = false;
|
||||||
|
private IntervalTreeNode<K, V> _root = null;
|
||||||
|
private int _count = 0;
|
||||||
|
|
||||||
|
public int Count => _count;
|
||||||
|
|
||||||
|
public IntervalTree() { }
|
||||||
|
|
||||||
|
#region Public Methods
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gets the values of the interval whose key is <paramref name="key"/>.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="key">Key of the node value to get</param>
|
||||||
|
/// <param name="value">Value with the given <paramref name="key"/></param>
|
||||||
|
/// <returns>True if the key is on the dictionary, false otherwise</returns>
|
||||||
|
public bool TryGet(K key, out V value)
|
||||||
|
{
|
||||||
|
IntervalTreeNode<K, V> node = GetNode(key);
|
||||||
|
|
||||||
|
if (node == null)
|
||||||
|
{
|
||||||
|
value = default;
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
value = node.Value;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Returns the start addresses of the intervals whose start and end keys overlap the given range.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="start">Start of the range</param>
|
||||||
|
/// <param name="end">End of the range</param>
|
||||||
|
/// <param name="overlaps">Overlaps array to place results in</param>
|
||||||
|
/// <param name="overlapCount">Index to start writing results into the array. Defaults to 0</param>
|
||||||
|
/// <returns>Number of intervals found</returns>
|
||||||
|
public int Get(K start, K end, ref K[] overlaps, int overlapCount = 0)
|
||||||
|
{
|
||||||
|
GetValues(_root, start, end, ref overlaps, ref overlapCount);
|
||||||
|
|
||||||
|
return overlapCount;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Adds a new interval into the tree whose start is <paramref name="start"/>, end is <paramref name="end"/> and value is <paramref name="value"/>.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="start">Start of the range to add</param>
|
||||||
|
/// <param name="end">End of the range to insert</param>
|
||||||
|
/// <param name="value">Value to add</param>
|
||||||
|
/// <param name="updateFactoryCallback">Optional factory used to create a new value if <paramref name="start"/> is already on the tree</param>
|
||||||
|
/// <exception cref="ArgumentNullException"><paramref name="value"/> is null</exception>
|
||||||
|
/// <returns>True if the value was added, false if the start key was already in the dictionary</returns>
|
||||||
|
public bool AddOrUpdate(K start, K end, V value, Func<K, V, V> updateFactoryCallback)
|
||||||
|
{
|
||||||
|
if (value == null)
|
||||||
|
{
|
||||||
|
throw new ArgumentNullException(nameof(value));
|
||||||
|
}
|
||||||
|
|
||||||
|
return BSTInsert(start, end, value, updateFactoryCallback, out IntervalTreeNode<K, V> node);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gets an existing or adds a new interval into the tree whose start is <paramref name="start"/>, end is <paramref name="end"/> and value is <paramref name="value"/>.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="start">Start of the range to add</param>
|
||||||
|
/// <param name="end">End of the range to insert</param>
|
||||||
|
/// <param name="value">Value to add</param>
|
||||||
|
/// <exception cref="ArgumentNullException"><paramref name="value"/> is null</exception>
|
||||||
|
/// <returns><paramref name="value"/> if <paramref name="start"/> is not yet on the tree, or the existing value otherwise</returns>
|
||||||
|
public V GetOrAdd(K start, K end, V value)
|
||||||
|
{
|
||||||
|
if (value == null)
|
||||||
|
{
|
||||||
|
throw new ArgumentNullException(nameof(value));
|
||||||
|
}
|
||||||
|
|
||||||
|
BSTInsert(start, end, value, null, out IntervalTreeNode<K, V> node);
|
||||||
|
return node.Value;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Removes a value from the tree, searching for it with <paramref name="key"/>.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="key">Key of the node to remove</param>
|
||||||
|
/// <returns>Number of deleted values</returns>
|
||||||
|
public int Remove(K key)
|
||||||
|
{
|
||||||
|
int removed = Delete(key);
|
||||||
|
|
||||||
|
_count -= removed;
|
||||||
|
|
||||||
|
return removed;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Adds all the nodes in the dictionary into <paramref name="list"/>.
|
||||||
|
/// </summary>
|
||||||
|
/// <returns>A list of all values sorted by Key Order</returns>
|
||||||
|
public List<V> AsList()
|
||||||
|
{
|
||||||
|
List<V> list = new List<V>();
|
||||||
|
|
||||||
|
AddToList(_root, list);
|
||||||
|
|
||||||
|
return list;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endregion
|
||||||
|
|
||||||
|
#region Private Methods (BST)
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Adds all values that are children of or contained within <paramref name="node"/> into <paramref name="list"/>, in Key Order.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="node">The node to search for values within</param>
|
||||||
|
/// <param name="list">The list to add values to</param>
|
||||||
|
private void AddToList(IntervalTreeNode<K, V> node, List<V> list)
|
||||||
|
{
|
||||||
|
if (node == null)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
AddToList(node.Left, list);
|
||||||
|
|
||||||
|
list.Add(node.Value);
|
||||||
|
|
||||||
|
AddToList(node.Right, list);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Retrieve the node reference whose key is <paramref name="key"/>, or null if no such node exists.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="key">Key of the node to get</param>
|
||||||
|
/// <exception cref="ArgumentNullException"><paramref name="key"/> is null</exception>
|
||||||
|
/// <returns>Node reference in the tree</returns>
|
||||||
|
private IntervalTreeNode<K, V> GetNode(K key)
|
||||||
|
{
|
||||||
|
if (key == null)
|
||||||
|
{
|
||||||
|
throw new ArgumentNullException(nameof(key));
|
||||||
|
}
|
||||||
|
|
||||||
|
IntervalTreeNode<K, V> node = _root;
|
||||||
|
while (node != null)
|
||||||
|
{
|
||||||
|
int cmp = key.CompareTo(node.Start);
|
||||||
|
if (cmp < 0)
|
||||||
|
{
|
||||||
|
node = node.Left;
|
||||||
|
}
|
||||||
|
else if (cmp > 0)
|
||||||
|
{
|
||||||
|
node = node.Right;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
return node;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Retrieve all values that overlap the given start and end keys.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="start">Start of the range</param>
|
||||||
|
/// <param name="end">End of the range</param>
|
||||||
|
/// <param name="overlaps">Overlaps array to place results in</param>
|
||||||
|
/// <param name="overlapCount">Overlaps count to update</param>
|
||||||
|
private void GetValues(IntervalTreeNode<K, V> node, K start, K end, ref K[] overlaps, ref int overlapCount)
|
||||||
|
{
|
||||||
|
if (node == null || start.CompareTo(node.Max) >= 0)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
GetValues(node.Left, start, end, ref overlaps, ref overlapCount);
|
||||||
|
|
||||||
|
bool endsOnRight = end.CompareTo(node.Start) > 0;
|
||||||
|
if (endsOnRight)
|
||||||
|
{
|
||||||
|
if (start.CompareTo(node.End) < 0)
|
||||||
|
{
|
||||||
|
if (overlaps.Length >= overlapCount)
|
||||||
|
{
|
||||||
|
Array.Resize(ref overlaps, overlapCount + ArrayGrowthSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
overlaps[overlapCount++] = node.Start;
|
||||||
|
}
|
||||||
|
|
||||||
|
GetValues(node.Right, start, end, ref overlaps, ref overlapCount);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Propagate an increase in max value starting at the given node, heading up the tree.
|
||||||
|
/// This should only be called if the max increases - not for rebalancing or removals.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="node">The node to start propagating from</param>
|
||||||
|
private void PropagateIncrease(IntervalTreeNode<K, V> node)
|
||||||
|
{
|
||||||
|
K max = node.Max;
|
||||||
|
IntervalTreeNode<K, V> ptr = node;
|
||||||
|
|
||||||
|
while ((ptr = ptr.Parent) != null)
|
||||||
|
{
|
||||||
|
if (max.CompareTo(ptr.Max) > 0)
|
||||||
|
{
|
||||||
|
ptr.Max = max;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Propagate recalculating max value starting at the given node, heading up the tree.
|
||||||
|
/// This fully recalculates the max value from all children when there is potential for it to decrease.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="node">The node to start propagating from</param>
|
||||||
|
private void PropagateFull(IntervalTreeNode<K, V> node)
|
||||||
|
{
|
||||||
|
IntervalTreeNode<K, V> ptr = node;
|
||||||
|
|
||||||
|
do
|
||||||
|
{
|
||||||
|
K max = ptr.End;
|
||||||
|
|
||||||
|
if (ptr.Left != null && ptr.Left.Max.CompareTo(max) > 0)
|
||||||
|
{
|
||||||
|
max = ptr.Left.Max;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ptr.Right != null && ptr.Right.Max.CompareTo(max) > 0)
|
||||||
|
{
|
||||||
|
max = ptr.Right.Max;
|
||||||
|
}
|
||||||
|
|
||||||
|
ptr.Max = max;
|
||||||
|
} while ((ptr = ptr.Parent) != null);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Insertion Mechanism for the interval tree. Similar to a BST insert, with the start of the range as the key.
|
||||||
|
/// Iterates the tree starting from the root and inserts a new node where all children in the left subtree are less than <paramref name="start"/>, and all children in the right subtree are greater than <paramref name="start"/>.
|
||||||
|
/// Each node can contain multiple values, and has an end address which is the maximum of all those values.
|
||||||
|
/// Post insertion, the "max" value of the node and all parents are updated.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="start">Start of the range to insert</param>
|
||||||
|
/// <param name="end">End of the range to insert</param>
|
||||||
|
/// <param name="value">Value to insert</param>
|
||||||
|
/// <param name="updateFactoryCallback">Optional factory used to create a new value if <paramref name="start"/> is already on the tree</param>
|
||||||
|
/// <param name="outNode">Node that was inserted or modified</param>
|
||||||
|
/// <returns>True if <paramref name="start"/> was not yet on the tree, false otherwise</returns>
|
||||||
|
private bool BSTInsert(K start, K end, V value, Func<K, V, V> updateFactoryCallback, out IntervalTreeNode<K, V> outNode)
|
||||||
|
{
|
||||||
|
IntervalTreeNode<K, V> parent = null;
|
||||||
|
IntervalTreeNode<K, V> node = _root;
|
||||||
|
|
||||||
|
while (node != null)
|
||||||
|
{
|
||||||
|
parent = node;
|
||||||
|
int cmp = start.CompareTo(node.Start);
|
||||||
|
if (cmp < 0)
|
||||||
|
{
|
||||||
|
node = node.Left;
|
||||||
|
}
|
||||||
|
else if (cmp > 0)
|
||||||
|
{
|
||||||
|
node = node.Right;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
outNode = node;
|
||||||
|
|
||||||
|
if (updateFactoryCallback != null)
|
||||||
|
{
|
||||||
|
// Replace
|
||||||
|
node.Value = updateFactoryCallback(start, node.Value);
|
||||||
|
|
||||||
|
int endCmp = end.CompareTo(node.End);
|
||||||
|
|
||||||
|
if (endCmp > 0)
|
||||||
|
{
|
||||||
|
node.End = end;
|
||||||
|
if (end.CompareTo(node.Max) > 0)
|
||||||
|
{
|
||||||
|
node.Max = end;
|
||||||
|
PropagateIncrease(node);
|
||||||
|
RestoreBalanceAfterInsertion(node);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (endCmp < 0)
|
||||||
|
{
|
||||||
|
node.End = end;
|
||||||
|
PropagateFull(node);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
IntervalTreeNode<K, V> newNode = new IntervalTreeNode<K, V>(start, end, value, parent);
|
||||||
|
if (newNode.Parent == null)
|
||||||
|
{
|
||||||
|
_root = newNode;
|
||||||
|
}
|
||||||
|
else if (start.CompareTo(parent.Start) < 0)
|
||||||
|
{
|
||||||
|
parent.Left = newNode;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
parent.Right = newNode;
|
||||||
|
}
|
||||||
|
|
||||||
|
PropagateIncrease(newNode);
|
||||||
|
_count++;
|
||||||
|
RestoreBalanceAfterInsertion(newNode);
|
||||||
|
outNode = newNode;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Removes the value from the dictionary after searching for it with <paramref name="key">.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="key">Key to search for</param>
|
||||||
|
/// <returns>Number of deleted values</returns>
|
||||||
|
private int Delete(K key)
|
||||||
|
{
|
||||||
|
IntervalTreeNode<K, V> nodeToDelete = GetNode(key);
|
||||||
|
|
||||||
|
if (nodeToDelete == null)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
IntervalTreeNode<K, V> replacementNode;
|
||||||
|
|
||||||
|
if (LeftOf(nodeToDelete) == null || RightOf(nodeToDelete) == null)
|
||||||
|
{
|
||||||
|
replacementNode = nodeToDelete;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
replacementNode = PredecessorOf(nodeToDelete);
|
||||||
|
}
|
||||||
|
|
||||||
|
IntervalTreeNode<K, V> tmp = LeftOf(replacementNode) ?? RightOf(replacementNode);
|
||||||
|
|
||||||
|
if (tmp != null)
|
||||||
|
{
|
||||||
|
tmp.Parent = ParentOf(replacementNode);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ParentOf(replacementNode) == null)
|
||||||
|
{
|
||||||
|
_root = tmp;
|
||||||
|
}
|
||||||
|
else if (replacementNode == LeftOf(ParentOf(replacementNode)))
|
||||||
|
{
|
||||||
|
ParentOf(replacementNode).Left = tmp;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
ParentOf(replacementNode).Right = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (replacementNode != nodeToDelete)
|
||||||
|
{
|
||||||
|
nodeToDelete.Start = replacementNode.Start;
|
||||||
|
nodeToDelete.Value = replacementNode.Value;
|
||||||
|
nodeToDelete.End = replacementNode.End;
|
||||||
|
nodeToDelete.Max = replacementNode.Max;
|
||||||
|
}
|
||||||
|
|
||||||
|
PropagateFull(replacementNode);
|
||||||
|
|
||||||
|
if (tmp != null && ColorOf(replacementNode) == Black)
|
||||||
|
{
|
||||||
|
RestoreBalanceAfterRemoval(tmp);
|
||||||
|
}
|
||||||
|
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Returns the node with the largest key where <paramref name="node"/> is considered the root node.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="node">Root Node</param>
|
||||||
|
/// <returns>Node with the maximum key in the tree of <paramref name="node"/></returns>
|
||||||
|
private static IntervalTreeNode<K, V> Maximum(IntervalTreeNode<K, V> node)
|
||||||
|
{
|
||||||
|
IntervalTreeNode<K, V> tmp = node;
|
||||||
|
while (tmp.Right != null)
|
||||||
|
{
|
||||||
|
tmp = tmp.Right;
|
||||||
|
}
|
||||||
|
|
||||||
|
return tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Finds the node whose key is immediately less than <paramref name="node"/>.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="node">Node to find the predecessor of</param>
|
||||||
|
/// <returns>Predecessor of <paramref name="node"/></returns>
|
||||||
|
private static IntervalTreeNode<K, V> PredecessorOf(IntervalTreeNode<K, V> node)
|
||||||
|
{
|
||||||
|
if (node.Left != null)
|
||||||
|
{
|
||||||
|
return Maximum(node.Left);
|
||||||
|
}
|
||||||
|
IntervalTreeNode<K, V> parent = node.Parent;
|
||||||
|
while (parent != null && node == parent.Left)
|
||||||
|
{
|
||||||
|
node = parent;
|
||||||
|
parent = parent.Parent;
|
||||||
|
}
|
||||||
|
return parent;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endregion
|
||||||
|
|
||||||
|
#region Private Methods (RBL)
|
||||||
|
|
||||||
|
private void RestoreBalanceAfterRemoval(IntervalTreeNode<K, V> balanceNode)
|
||||||
|
{
|
||||||
|
IntervalTreeNode<K, V> ptr = balanceNode;
|
||||||
|
|
||||||
|
while (ptr != _root && ColorOf(ptr) == Black)
|
||||||
|
{
|
||||||
|
if (ptr == LeftOf(ParentOf(ptr)))
|
||||||
|
{
|
||||||
|
IntervalTreeNode<K, V> sibling = RightOf(ParentOf(ptr));
|
||||||
|
|
||||||
|
if (ColorOf(sibling) == Red)
|
||||||
|
{
|
||||||
|
SetColor(sibling, Black);
|
||||||
|
SetColor(ParentOf(ptr), Red);
|
||||||
|
RotateLeft(ParentOf(ptr));
|
||||||
|
sibling = RightOf(ParentOf(ptr));
|
||||||
|
}
|
||||||
|
if (ColorOf(LeftOf(sibling)) == Black && ColorOf(RightOf(sibling)) == Black)
|
||||||
|
{
|
||||||
|
SetColor(sibling, Red);
|
||||||
|
ptr = ParentOf(ptr);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (ColorOf(RightOf(sibling)) == Black)
|
||||||
|
{
|
||||||
|
SetColor(LeftOf(sibling), Black);
|
||||||
|
SetColor(sibling, Red);
|
||||||
|
RotateRight(sibling);
|
||||||
|
sibling = RightOf(ParentOf(ptr));
|
||||||
|
}
|
||||||
|
SetColor(sibling, ColorOf(ParentOf(ptr)));
|
||||||
|
SetColor(ParentOf(ptr), Black);
|
||||||
|
SetColor(RightOf(sibling), Black);
|
||||||
|
RotateLeft(ParentOf(ptr));
|
||||||
|
ptr = _root;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
IntervalTreeNode<K, V> sibling = LeftOf(ParentOf(ptr));
|
||||||
|
|
||||||
|
if (ColorOf(sibling) == Red)
|
||||||
|
{
|
||||||
|
SetColor(sibling, Black);
|
||||||
|
SetColor(ParentOf(ptr), Red);
|
||||||
|
RotateRight(ParentOf(ptr));
|
||||||
|
sibling = LeftOf(ParentOf(ptr));
|
||||||
|
}
|
||||||
|
if (ColorOf(RightOf(sibling)) == Black && ColorOf(LeftOf(sibling)) == Black)
|
||||||
|
{
|
||||||
|
SetColor(sibling, Red);
|
||||||
|
ptr = ParentOf(ptr);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (ColorOf(LeftOf(sibling)) == Black)
|
||||||
|
{
|
||||||
|
SetColor(RightOf(sibling), Black);
|
||||||
|
SetColor(sibling, Red);
|
||||||
|
RotateLeft(sibling);
|
||||||
|
sibling = LeftOf(ParentOf(ptr));
|
||||||
|
}
|
||||||
|
SetColor(sibling, ColorOf(ParentOf(ptr)));
|
||||||
|
SetColor(ParentOf(ptr), Black);
|
||||||
|
SetColor(LeftOf(sibling), Black);
|
||||||
|
RotateRight(ParentOf(ptr));
|
||||||
|
ptr = _root;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
SetColor(ptr, Black);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void RestoreBalanceAfterInsertion(IntervalTreeNode<K, V> balanceNode)
|
||||||
|
{
|
||||||
|
SetColor(balanceNode, Red);
|
||||||
|
while (balanceNode != null && balanceNode != _root && ColorOf(ParentOf(balanceNode)) == Red)
|
||||||
|
{
|
||||||
|
if (ParentOf(balanceNode) == LeftOf(ParentOf(ParentOf(balanceNode))))
|
||||||
|
{
|
||||||
|
IntervalTreeNode<K, V> sibling = RightOf(ParentOf(ParentOf(balanceNode)));
|
||||||
|
|
||||||
|
if (ColorOf(sibling) == Red)
|
||||||
|
{
|
||||||
|
SetColor(ParentOf(balanceNode), Black);
|
||||||
|
SetColor(sibling, Black);
|
||||||
|
SetColor(ParentOf(ParentOf(balanceNode)), Red);
|
||||||
|
balanceNode = ParentOf(ParentOf(balanceNode));
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (balanceNode == RightOf(ParentOf(balanceNode)))
|
||||||
|
{
|
||||||
|
balanceNode = ParentOf(balanceNode);
|
||||||
|
RotateLeft(balanceNode);
|
||||||
|
}
|
||||||
|
SetColor(ParentOf(balanceNode), Black);
|
||||||
|
SetColor(ParentOf(ParentOf(balanceNode)), Red);
|
||||||
|
RotateRight(ParentOf(ParentOf(balanceNode)));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
IntervalTreeNode<K, V> sibling = LeftOf(ParentOf(ParentOf(balanceNode)));
|
||||||
|
|
||||||
|
if (ColorOf(sibling) == Red)
|
||||||
|
{
|
||||||
|
SetColor(ParentOf(balanceNode), Black);
|
||||||
|
SetColor(sibling, Black);
|
||||||
|
SetColor(ParentOf(ParentOf(balanceNode)), Red);
|
||||||
|
balanceNode = ParentOf(ParentOf(balanceNode));
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (balanceNode == LeftOf(ParentOf(balanceNode)))
|
||||||
|
{
|
||||||
|
balanceNode = ParentOf(balanceNode);
|
||||||
|
RotateRight(balanceNode);
|
||||||
|
}
|
||||||
|
SetColor(ParentOf(balanceNode), Black);
|
||||||
|
SetColor(ParentOf(ParentOf(balanceNode)), Red);
|
||||||
|
RotateLeft(ParentOf(ParentOf(balanceNode)));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
SetColor(_root, Black);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void RotateLeft(IntervalTreeNode<K, V> node)
|
||||||
|
{
|
||||||
|
if (node != null)
|
||||||
|
{
|
||||||
|
IntervalTreeNode<K, V> right = RightOf(node);
|
||||||
|
node.Right = LeftOf(right);
|
||||||
|
if (node.Right != null)
|
||||||
|
{
|
||||||
|
node.Right.Parent = node;
|
||||||
|
}
|
||||||
|
IntervalTreeNode<K, V> nodeParent = ParentOf(node);
|
||||||
|
right.Parent = nodeParent;
|
||||||
|
if (nodeParent == null)
|
||||||
|
{
|
||||||
|
_root = right;
|
||||||
|
}
|
||||||
|
else if (node == LeftOf(nodeParent))
|
||||||
|
{
|
||||||
|
nodeParent.Left = right;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
nodeParent.Right = right;
|
||||||
|
}
|
||||||
|
right.Left = node;
|
||||||
|
node.Parent = right;
|
||||||
|
|
||||||
|
PropagateFull(node);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private void RotateRight(IntervalTreeNode<K, V> node)
|
||||||
|
{
|
||||||
|
if (node != null)
|
||||||
|
{
|
||||||
|
IntervalTreeNode<K, V> left = LeftOf(node);
|
||||||
|
node.Left = RightOf(left);
|
||||||
|
if (node.Left != null)
|
||||||
|
{
|
||||||
|
node.Left.Parent = node;
|
||||||
|
}
|
||||||
|
IntervalTreeNode<K, V> nodeParent = ParentOf(node);
|
||||||
|
left.Parent = nodeParent;
|
||||||
|
if (nodeParent == null)
|
||||||
|
{
|
||||||
|
_root = left;
|
||||||
|
}
|
||||||
|
else if (node == RightOf(nodeParent))
|
||||||
|
{
|
||||||
|
nodeParent.Right = left;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
nodeParent.Left = left;
|
||||||
|
}
|
||||||
|
left.Right = node;
|
||||||
|
node.Parent = left;
|
||||||
|
|
||||||
|
PropagateFull(node);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#endregion
|
||||||
|
|
||||||
|
#region Safety-Methods
|
||||||
|
|
||||||
|
// These methods save memory by allowing us to forego sentinel nil nodes, as well as serve as protection against NullReferenceExceptions.
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Returns the color of <paramref name="node"/>, or Black if it is null.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="node">Node</param>
|
||||||
|
/// <returns>The boolean color of <paramref name="node"/>, or black if null</returns>
|
||||||
|
private static bool ColorOf(IntervalTreeNode<K, V> node)
|
||||||
|
{
|
||||||
|
return node == null || node.Color;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Sets the color of <paramref name="node"/> node to <paramref name="color"/>.
|
||||||
|
/// <br></br>
|
||||||
|
/// This method does nothing if <paramref name="node"/> is null.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="node">Node to set the color of</param>
|
||||||
|
/// <param name="color">Color (Boolean)</param>
|
||||||
|
private static void SetColor(IntervalTreeNode<K, V> node, bool color)
|
||||||
|
{
|
||||||
|
if (node != null)
|
||||||
|
{
|
||||||
|
node.Color = color;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// This method returns the left node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="node">Node to retrieve the left child from</param>
|
||||||
|
/// <returns>Left child of <paramref name="node"/></returns>
|
||||||
|
private static IntervalTreeNode<K, V> LeftOf(IntervalTreeNode<K, V> node)
|
||||||
|
{
|
||||||
|
return node?.Left;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// This method returns the right node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="node">Node to retrieve the right child from</param>
|
||||||
|
/// <returns>Right child of <paramref name="node"/></returns>
|
||||||
|
private static IntervalTreeNode<K, V> RightOf(IntervalTreeNode<K, V> node)
|
||||||
|
{
|
||||||
|
return node?.Right;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Returns the parent node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="node">Node to retrieve the parent from</param>
|
||||||
|
/// <returns>Parent of <paramref name="node"/></returns>
|
||||||
|
private static IntervalTreeNode<K, V> ParentOf(IntervalTreeNode<K, V> node)
|
||||||
|
{
|
||||||
|
return node?.Parent;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endregion
|
||||||
|
|
||||||
|
public bool ContainsKey(K key)
|
||||||
|
{
|
||||||
|
return GetNode(key) != null;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void Clear()
|
||||||
|
{
|
||||||
|
_root = null;
|
||||||
|
_count = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Represents a node in the IntervalTree which contains start and end keys of type K, and a value of generic type V.
|
||||||
|
/// </summary>
|
||||||
|
/// <typeparam name="K">Key type of the node</typeparam>
|
||||||
|
/// <typeparam name="V">Value type of the node</typeparam>
|
||||||
|
internal class IntervalTreeNode<K, V>
|
||||||
|
{
|
||||||
|
internal bool Color = true;
|
||||||
|
internal IntervalTreeNode<K, V> Left = null;
|
||||||
|
internal IntervalTreeNode<K, V> Right = null;
|
||||||
|
internal IntervalTreeNode<K, V> Parent = null;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The start of the range.
|
||||||
|
/// </summary>
|
||||||
|
internal K Start;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The end of the range.
|
||||||
|
/// </summary>
|
||||||
|
internal K End;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The maximum end value of this node and all its children.
|
||||||
|
/// </summary>
|
||||||
|
internal K Max;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Value stored on this node.
|
||||||
|
/// </summary>
|
||||||
|
internal V Value;
|
||||||
|
|
||||||
|
public IntervalTreeNode(K start, K end, V value, IntervalTreeNode<K, V> parent)
|
||||||
|
{
|
||||||
|
this.Start = start;
|
||||||
|
this.End = end;
|
||||||
|
this.Max = end;
|
||||||
|
this.Value = value;
|
||||||
|
this.Parent = parent;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
|
@ -585,7 +585,7 @@ namespace ARMeilleure.Translation.PTC
|
||||||
|
|
||||||
translator.RegisterFunction(infoEntry.Address, func);
|
translator.RegisterFunction(infoEntry.Address, func);
|
||||||
|
|
||||||
bool isAddressUnique = translator.Functions.TryAdd(infoEntry.Address, func);
|
bool isAddressUnique = translator.Functions.TryAdd(infoEntry.Address, infoEntry.GuestSize, func);
|
||||||
|
|
||||||
Debug.Assert(isAddressUnique, $"The address 0x{infoEntry.Address:X16} is not unique.");
|
Debug.Assert(isAddressUnique, $"The address 0x{infoEntry.Address:X16} is not unique.");
|
||||||
}
|
}
|
||||||
|
@ -815,7 +815,7 @@ namespace ARMeilleure.Translation.PTC
|
||||||
|
|
||||||
TranslatedFunction func = translator.Translate(address, item.funcProfile.Mode, item.funcProfile.HighCq);
|
TranslatedFunction func = translator.Translate(address, item.funcProfile.Mode, item.funcProfile.HighCq);
|
||||||
|
|
||||||
bool isAddressUnique = translator.Functions.TryAdd(address, func);
|
bool isAddressUnique = translator.Functions.TryAdd(address, func.GuestSize, func);
|
||||||
|
|
||||||
Debug.Assert(isAddressUnique, $"The address 0x{address:X16} is not unique.");
|
Debug.Assert(isAddressUnique, $"The address 0x{address:X16} is not unique.");
|
||||||
|
|
||||||
|
|
|
@ -96,7 +96,7 @@ namespace ARMeilleure.Translation.PTC
|
||||||
return address >= StaticCodeStart && address < StaticCodeStart + StaticCodeSize;
|
return address >= StaticCodeStart && address < StaticCodeStart + StaticCodeSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
internal static ConcurrentQueue<(ulong address, FuncProfile funcProfile)> GetProfiledFuncsToTranslate(ConcurrentDictionary<ulong, TranslatedFunction> funcs)
|
internal static ConcurrentQueue<(ulong address, FuncProfile funcProfile)> GetProfiledFuncsToTranslate(TranslatorCache<TranslatedFunction> funcs)
|
||||||
{
|
{
|
||||||
var profiledFuncsToTranslate = new ConcurrentQueue<(ulong address, FuncProfile funcProfile)>();
|
var profiledFuncsToTranslate = new ConcurrentQueue<(ulong address, FuncProfile funcProfile)>();
|
||||||
|
|
||||||
|
|
|
@ -49,7 +49,7 @@ namespace ARMeilleure.Translation
|
||||||
private readonly AutoResetEvent _backgroundTranslatorEvent;
|
private readonly AutoResetEvent _backgroundTranslatorEvent;
|
||||||
private readonly ReaderWriterLock _backgroundTranslatorLock;
|
private readonly ReaderWriterLock _backgroundTranslatorLock;
|
||||||
|
|
||||||
internal ConcurrentDictionary<ulong, TranslatedFunction> Functions { get; }
|
internal TranslatorCache<TranslatedFunction> Functions { get; }
|
||||||
internal AddressTable<ulong> FunctionTable { get; }
|
internal AddressTable<ulong> FunctionTable { get; }
|
||||||
internal EntryTable<uint> CountTable { get; }
|
internal EntryTable<uint> CountTable { get; }
|
||||||
internal TranslatorStubs Stubs { get; }
|
internal TranslatorStubs Stubs { get; }
|
||||||
|
@ -75,7 +75,7 @@ namespace ARMeilleure.Translation
|
||||||
JitCache.Initialize(allocator);
|
JitCache.Initialize(allocator);
|
||||||
|
|
||||||
CountTable = new EntryTable<uint>();
|
CountTable = new EntryTable<uint>();
|
||||||
Functions = new ConcurrentDictionary<ulong, TranslatedFunction>();
|
Functions = new TranslatorCache<TranslatedFunction>();
|
||||||
FunctionTable = new AddressTable<ulong>(for64Bits ? Levels64Bit : Levels32Bit);
|
FunctionTable = new AddressTable<ulong>(for64Bits ? Levels64Bit : Levels32Bit);
|
||||||
Stubs = new TranslatorStubs(this);
|
Stubs = new TranslatorStubs(this);
|
||||||
|
|
||||||
|
@ -98,7 +98,7 @@ namespace ARMeilleure.Translation
|
||||||
{
|
{
|
||||||
TranslatedFunction func = Translate(request.Address, request.Mode, highCq: true);
|
TranslatedFunction func = Translate(request.Address, request.Mode, highCq: true);
|
||||||
|
|
||||||
Functions.AddOrUpdate(request.Address, func, (key, oldFunc) =>
|
Functions.AddOrUpdate(request.Address, func.GuestSize, func, (key, oldFunc) =>
|
||||||
{
|
{
|
||||||
EnqueueForDeletion(key, oldFunc);
|
EnqueueForDeletion(key, oldFunc);
|
||||||
return func;
|
return func;
|
||||||
|
@ -196,7 +196,7 @@ namespace ARMeilleure.Translation
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
public ulong ExecuteSingle(State.ExecutionContext context, ulong address)
|
private ulong ExecuteSingle(State.ExecutionContext context, ulong address)
|
||||||
{
|
{
|
||||||
TranslatedFunction func = GetOrTranslate(address, context.ExecutionMode);
|
TranslatedFunction func = GetOrTranslate(address, context.ExecutionMode);
|
||||||
|
|
||||||
|
@ -215,7 +215,7 @@ namespace ARMeilleure.Translation
|
||||||
{
|
{
|
||||||
func = Translate(address, mode, highCq: false);
|
func = Translate(address, mode, highCq: false);
|
||||||
|
|
||||||
TranslatedFunction oldFunc = Functions.GetOrAdd(address, func);
|
TranslatedFunction oldFunc = Functions.GetOrAdd(address, func.GuestSize, func);
|
||||||
|
|
||||||
if (oldFunc != func)
|
if (oldFunc != func)
|
||||||
{
|
{
|
||||||
|
@ -471,7 +471,24 @@ namespace ARMeilleure.Translation
|
||||||
// If rejit is running, stop it as it may be trying to rejit a function on the invalidated region.
|
// If rejit is running, stop it as it may be trying to rejit a function on the invalidated region.
|
||||||
ClearRejitQueue(allowRequeue: true);
|
ClearRejitQueue(allowRequeue: true);
|
||||||
|
|
||||||
// TODO: Completely remove functions overlapping the specified range from the cache.
|
ulong[] overlapAddresses = Array.Empty<ulong>();
|
||||||
|
|
||||||
|
int overlapsCount = Functions.GetOverlaps(address, size, ref overlapAddresses);
|
||||||
|
|
||||||
|
for (int index = 0; index < overlapsCount; index++)
|
||||||
|
{
|
||||||
|
ulong overlapAddress = overlapAddresses[index];
|
||||||
|
|
||||||
|
if (Functions.TryGetValue(overlapAddress, out TranslatedFunction overlap))
|
||||||
|
{
|
||||||
|
Functions.Remove(overlapAddress);
|
||||||
|
Volatile.Write(ref FunctionTable.GetValue(overlapAddress), FunctionTable.Fill);
|
||||||
|
EnqueueForDeletion(overlapAddress, overlap);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO: Remove overlapping functions from the JitCache aswell.
|
||||||
|
// This should be done safely, with a mechanism to ensure the function is not being executed.
|
||||||
}
|
}
|
||||||
|
|
||||||
internal void EnqueueForRejit(ulong guestAddress, ExecutionMode mode)
|
internal void EnqueueForRejit(ulong guestAddress, ExecutionMode mode)
|
||||||
|
@ -493,7 +510,9 @@ namespace ARMeilleure.Translation
|
||||||
// Ensure no attempt will be made to compile new functions due to rejit.
|
// Ensure no attempt will be made to compile new functions due to rejit.
|
||||||
ClearRejitQueue(allowRequeue: false);
|
ClearRejitQueue(allowRequeue: false);
|
||||||
|
|
||||||
foreach (var func in Functions.Values)
|
List<TranslatedFunction> functions = Functions.AsList();
|
||||||
|
|
||||||
|
foreach (var func in functions)
|
||||||
{
|
{
|
||||||
JitCache.Unmap(func.FuncPtr);
|
JitCache.Unmap(func.FuncPtr);
|
||||||
|
|
||||||
|
|
95
ARMeilleure/Translation/TranslatorCache.cs
Normal file
95
ARMeilleure/Translation/TranslatorCache.cs
Normal file
|
@ -0,0 +1,95 @@
|
||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Threading;
|
||||||
|
|
||||||
|
namespace ARMeilleure.Translation
|
||||||
|
{
|
||||||
|
internal class TranslatorCache<T>
|
||||||
|
{
|
||||||
|
private readonly IntervalTree<ulong, T> _tree;
|
||||||
|
private readonly ReaderWriterLock _treeLock;
|
||||||
|
|
||||||
|
public int Count => _tree.Count;
|
||||||
|
|
||||||
|
public TranslatorCache()
|
||||||
|
{
|
||||||
|
_tree = new IntervalTree<ulong, T>();
|
||||||
|
_treeLock = new ReaderWriterLock();
|
||||||
|
}
|
||||||
|
|
||||||
|
public bool TryAdd(ulong address, ulong size, T value)
|
||||||
|
{
|
||||||
|
return AddOrUpdate(address, size, value, null);
|
||||||
|
}
|
||||||
|
|
||||||
|
public bool AddOrUpdate(ulong address, ulong size, T value, Func<ulong, T, T> updateFactoryCallback)
|
||||||
|
{
|
||||||
|
_treeLock.AcquireWriterLock(Timeout.Infinite);
|
||||||
|
bool result = _tree.AddOrUpdate(address, address + size, value, updateFactoryCallback);
|
||||||
|
_treeLock.ReleaseWriterLock();
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
public T GetOrAdd(ulong address, ulong size, T value)
|
||||||
|
{
|
||||||
|
_treeLock.AcquireWriterLock(Timeout.Infinite);
|
||||||
|
value = _tree.GetOrAdd(address, address + size, value);
|
||||||
|
_treeLock.ReleaseWriterLock();
|
||||||
|
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
public bool Remove(ulong address)
|
||||||
|
{
|
||||||
|
_treeLock.AcquireWriterLock(Timeout.Infinite);
|
||||||
|
bool removed = _tree.Remove(address) != 0;
|
||||||
|
_treeLock.ReleaseWriterLock();
|
||||||
|
|
||||||
|
return removed;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void Clear()
|
||||||
|
{
|
||||||
|
_treeLock.AcquireWriterLock(Timeout.Infinite);
|
||||||
|
_tree.Clear();
|
||||||
|
_treeLock.ReleaseWriterLock();
|
||||||
|
}
|
||||||
|
|
||||||
|
public bool ContainsKey(ulong address)
|
||||||
|
{
|
||||||
|
_treeLock.AcquireReaderLock(Timeout.Infinite);
|
||||||
|
bool result = _tree.ContainsKey(address);
|
||||||
|
_treeLock.ReleaseReaderLock();
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
public bool TryGetValue(ulong address, out T value)
|
||||||
|
{
|
||||||
|
_treeLock.AcquireReaderLock(Timeout.Infinite);
|
||||||
|
bool result = _tree.TryGet(address, out value);
|
||||||
|
_treeLock.ReleaseReaderLock();
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int GetOverlaps(ulong address, ulong size, ref ulong[] overlaps)
|
||||||
|
{
|
||||||
|
_treeLock.AcquireReaderLock(Timeout.Infinite);
|
||||||
|
int count = _tree.Get(address, address + size, ref overlaps);
|
||||||
|
_treeLock.ReleaseReaderLock();
|
||||||
|
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<T> AsList()
|
||||||
|
{
|
||||||
|
_treeLock.AcquireReaderLock(Timeout.Infinite);
|
||||||
|
List<T> list = _tree.AsList();
|
||||||
|
_treeLock.ReleaseReaderLock();
|
||||||
|
|
||||||
|
return list;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
|
@ -28,5 +28,10 @@ namespace Ryujinx.Cpu
|
||||||
{
|
{
|
||||||
_translator.Execute(context, address);
|
_translator.Execute(context, address);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
public void InvalidateCacheRegion(ulong address, ulong size)
|
||||||
|
{
|
||||||
|
_translator.InvalidateJitCacheRegion(address, size);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -36,6 +36,11 @@ namespace Ryujinx.HLE.HOS
|
||||||
_cpuContext.Execute(context, codeAddress);
|
_cpuContext.Execute(context, codeAddress);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
public void InvalidateCacheRegion(ulong address, ulong size)
|
||||||
|
{
|
||||||
|
_cpuContext.InvalidateCacheRegion(address, size);
|
||||||
|
}
|
||||||
|
|
||||||
public void Dispose()
|
public void Dispose()
|
||||||
{
|
{
|
||||||
if (_memoryManager is IRefCounted rc)
|
if (_memoryManager is IRefCounted rc)
|
||||||
|
|
|
@ -9,5 +9,6 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
|
||||||
IVirtualMemoryManager AddressSpace { get; }
|
IVirtualMemoryManager AddressSpace { get; }
|
||||||
|
|
||||||
void Execute(ExecutionContext context, ulong codeAddress);
|
void Execute(ExecutionContext context, ulong codeAddress);
|
||||||
|
void InvalidateCacheRegion(ulong address, ulong size);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -18,6 +18,10 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
|
||||||
throw new NotSupportedException();
|
throw new NotSupportedException();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
public void InvalidateCacheRegion(ulong address, ulong size)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
public void Dispose()
|
public void Dispose()
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in a new issue