mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-17 14:18:44 +02:00
* Support for resources on non-contiguous GPU memory regions * Implement MultiRange physical addresses, only used with a single range for now * Actually use non-contiguous ranges * GetPhysicalRegions fixes * Documentation and remove Address property from TextureInfo * Finish implementing GetWritableRegion * Fix typo
204 lines
6 KiB
C#
204 lines
6 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Ryujinx.Memory.Range
|
|
{
|
|
/// <summary>
|
|
/// Sorted list of ranges that supports binary search.
|
|
/// </summary>
|
|
/// <typeparam name="T">Type of the range.</typeparam>
|
|
public class MultiRangeList<T> : IEnumerable<T> where T : IMultiRangeItem
|
|
{
|
|
private const int ArrayGrowthSize = 32;
|
|
|
|
private readonly List<T> _items;
|
|
|
|
public int Count => _items.Count;
|
|
|
|
/// <summary>
|
|
/// Creates a new range list.
|
|
/// </summary>
|
|
public MultiRangeList()
|
|
{
|
|
_items = new List<T>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a new item to the list.
|
|
/// </summary>
|
|
/// <param name="item">The item to be added</param>
|
|
public void Add(T item)
|
|
{
|
|
int index = BinarySearch(item.BaseAddress);
|
|
|
|
if (index < 0)
|
|
{
|
|
index = ~index;
|
|
}
|
|
|
|
_items.Insert(index, item);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes an item from the list.
|
|
/// </summary>
|
|
/// <param name="item">The item to be removed</param>
|
|
/// <returns>True if the item was removed, or false if it was not found</returns>
|
|
public bool Remove(T item)
|
|
{
|
|
int index = BinarySearch(item.BaseAddress);
|
|
|
|
if (index >= 0)
|
|
{
|
|
while (index > 0 && _items[index - 1].BaseAddress == item.BaseAddress)
|
|
{
|
|
index--;
|
|
}
|
|
|
|
while (index < _items.Count)
|
|
{
|
|
if (_items[index].Equals(item))
|
|
{
|
|
_items.RemoveAt(index);
|
|
|
|
return true;
|
|
}
|
|
|
|
if (_items[index].BaseAddress > item.BaseAddress)
|
|
{
|
|
break;
|
|
}
|
|
|
|
index++;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets all items on the list overlapping the specified memory range.
|
|
/// </summary>
|
|
/// <param name="address">Start address of the range</param>
|
|
/// <param name="size">Size in bytes of the range</param>
|
|
/// <param name="output">Output array where matches will be written. It is automatically resized to fit the results</param>
|
|
/// <returns>The number of overlapping items found</returns>
|
|
public int FindOverlaps(ulong address, ulong size, ref T[] output)
|
|
{
|
|
return FindOverlaps(new MultiRange(address, size), ref output);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets all items on the list overlapping the specified memory ranges.
|
|
/// </summary>
|
|
/// <param name="range">Ranges of memory being searched</param>
|
|
/// <param name="output">Output array where matches will be written. It is automatically resized to fit the results</param>
|
|
/// <returns>The number of overlapping items found</returns>
|
|
public int FindOverlaps(MultiRange range, ref T[] output)
|
|
{
|
|
int outputIndex = 0;
|
|
|
|
foreach (T item in _items)
|
|
{
|
|
if (item.Range.OverlapsWith(range))
|
|
{
|
|
if (outputIndex == output.Length)
|
|
{
|
|
Array.Resize(ref output, outputIndex + ArrayGrowthSize);
|
|
}
|
|
|
|
output[outputIndex++] = item;
|
|
}
|
|
}
|
|
|
|
return outputIndex;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets all items on the list starting at the specified memory address.
|
|
/// </summary>
|
|
/// <param name="baseAddress">Base address to find</param>
|
|
/// <param name="output">Output array where matches will be written. It is automatically resized to fit the results</param>
|
|
/// <returns>The number of matches found</returns>
|
|
public int FindOverlaps(ulong baseAddress, ref T[] output)
|
|
{
|
|
int index = BinarySearch(baseAddress);
|
|
|
|
int outputIndex = 0;
|
|
|
|
if (index >= 0)
|
|
{
|
|
while (index > 0 && _items[index - 1].BaseAddress == baseAddress)
|
|
{
|
|
index--;
|
|
}
|
|
|
|
while (index < _items.Count)
|
|
{
|
|
T overlap = _items[index++];
|
|
|
|
if (overlap.BaseAddress != baseAddress)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (outputIndex == output.Length)
|
|
{
|
|
Array.Resize(ref output, outputIndex + ArrayGrowthSize);
|
|
}
|
|
|
|
output[outputIndex++] = overlap;
|
|
}
|
|
}
|
|
|
|
return outputIndex;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Performs binary search on the internal list of items.
|
|
/// </summary>
|
|
/// <param name="address">Address to find</param>
|
|
/// <returns>List index of the item, or complement index of nearest item with lower value on the list</returns>
|
|
private int BinarySearch(ulong address)
|
|
{
|
|
int left = 0;
|
|
int right = _items.Count - 1;
|
|
|
|
while (left <= right)
|
|
{
|
|
int range = right - left;
|
|
|
|
int middle = left + (range >> 1);
|
|
|
|
T item = _items[middle];
|
|
|
|
if (item.BaseAddress == address)
|
|
{
|
|
return middle;
|
|
}
|
|
|
|
if (address < item.BaseAddress)
|
|
{
|
|
right = middle - 1;
|
|
}
|
|
else
|
|
{
|
|
left = middle + 1;
|
|
}
|
|
}
|
|
|
|
return ~left;
|
|
}
|
|
|
|
public IEnumerator<T> GetEnumerator()
|
|
{
|
|
return _items.GetEnumerator();
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return _items.GetEnumerator();
|
|
}
|
|
}
|
|
} |