mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-18 06:38:42 +02:00
* Make all structs readonly when applicable. It should reduce amount of needless defensive copies * Make structs with trivial boilerplate equality code record structs * Remove unnecessary readonly modifiers from TextureCreateInfo * Make BitMap structs readonly too
245 lines
8.5 KiB
C#
245 lines
8.5 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
|
|
namespace Ryujinx.Graphics.Gpu.Shader.HashTable
|
|
{
|
|
/// <summary>
|
|
/// Partitioned hash table.
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
public class PartitionedHashTable<T>
|
|
{
|
|
/// <summary>
|
|
/// Entry for a given data size.
|
|
/// </summary>
|
|
private readonly struct SizeEntry
|
|
{
|
|
/// <summary>
|
|
/// Size for the data that will be stored on the hash table on this entry.
|
|
/// </summary>
|
|
public int Size { get; }
|
|
|
|
/// <summary>
|
|
/// Number of entries on the hash table.
|
|
/// </summary>
|
|
public int TableCount => _table.Count;
|
|
|
|
private readonly PartitionHashTable<T> _table;
|
|
|
|
/// <summary>
|
|
/// Creates an entry for a given size.
|
|
/// </summary>
|
|
/// <param name="size">Size of the data to be stored on this entry</param>
|
|
public SizeEntry(int size)
|
|
{
|
|
Size = size;
|
|
_table = new PartitionHashTable<T>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an item for existing data, or adds a new one.
|
|
/// </summary>
|
|
/// <param name="data">Data associated with the item</param>
|
|
/// <param name="dataHash">Hash of <paramref name="data"/></param>
|
|
/// <param name="item">Item to be added</param>
|
|
/// <returns>Existing item, or <paramref name="item"/> if not present</returns>
|
|
public T GetOrAdd(byte[] data, uint dataHash, T item)
|
|
{
|
|
Debug.Assert(data.Length == Size);
|
|
return _table.GetOrAdd(data, dataHash, item);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a new item.
|
|
/// </summary>
|
|
/// <param name="data">Data associated with the item</param>
|
|
/// <param name="dataHash">Hash of <paramref name="data"/></param>
|
|
/// <param name="item">Item to be added</param>
|
|
/// <returns>True if added, false otherwise</returns>
|
|
public bool Add(byte[] data, uint dataHash, T item)
|
|
{
|
|
Debug.Assert(data.Length == Size);
|
|
return _table.Add(data, dataHash, item);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a partial entry.
|
|
/// </summary>
|
|
/// <param name="ownerData">Full entry data</param>
|
|
/// <param name="dataHash">Hash of the sub-region of the data that belongs to this entry</param>
|
|
/// <returns>True if added, false otherwise</returns>
|
|
public bool AddPartial(byte[] ownerData, uint dataHash)
|
|
{
|
|
return _table.AddPartial(ownerData, dataHash, Size);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fills a new hash table with "partials" of existing full entries of higher size.
|
|
/// </summary>
|
|
/// <param name="newEntry">Entry with the new hash table</param>
|
|
public void FillPartials(SizeEntry newEntry)
|
|
{
|
|
Debug.Assert(newEntry.Size < Size);
|
|
_table.FillPartials(newEntry._table, newEntry.Size);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tries to find an item on the hash table.
|
|
/// </summary>
|
|
/// <param name="dataAccessor">Data accessor</param>
|
|
/// <param name="item">The item on the table, if found, otherwise unmodified</param>
|
|
/// <param name="data">The data on the table, if found, otherwise unmodified</param>
|
|
/// <returns>Table lookup result</returns>
|
|
public PartitionHashTable<T>.SearchResult TryFindItem(scoped ref SmartDataAccessor dataAccessor, scoped ref T item, scoped ref byte[] data)
|
|
{
|
|
return _table.TryFindItem(ref dataAccessor, Size, ref item, ref data);
|
|
}
|
|
}
|
|
|
|
private readonly List<SizeEntry> _sizeTable;
|
|
|
|
/// <summary>
|
|
/// Creates a new partitioned hash table.
|
|
/// </summary>
|
|
public PartitionedHashTable()
|
|
{
|
|
_sizeTable = new List<SizeEntry>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a new item to the table.
|
|
/// </summary>
|
|
/// <param name="data">Data</param>
|
|
/// <param name="item">Item associated with the data</param>
|
|
public void Add(byte[] data, T item)
|
|
{
|
|
GetOrAdd(data, item);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an existing item from the table, or adds a new one if not present.
|
|
/// </summary>
|
|
/// <param name="data">Data</param>
|
|
/// <param name="item">Item associated with the data</param>
|
|
/// <returns>Existing item, or <paramref name="item"/> if not present</returns>
|
|
public T GetOrAdd(byte[] data, T item)
|
|
{
|
|
SizeEntry sizeEntry;
|
|
|
|
int index = BinarySearch(_sizeTable, data.Length);
|
|
if (index < _sizeTable.Count && _sizeTable[index].Size == data.Length)
|
|
{
|
|
sizeEntry = _sizeTable[index];
|
|
}
|
|
else
|
|
{
|
|
if (index < _sizeTable.Count && _sizeTable[index].Size < data.Length)
|
|
{
|
|
index++;
|
|
}
|
|
|
|
sizeEntry = new SizeEntry(data.Length);
|
|
|
|
_sizeTable.Insert(index, sizeEntry);
|
|
|
|
for (int i = index + 1; i < _sizeTable.Count; i++)
|
|
{
|
|
_sizeTable[i].FillPartials(sizeEntry);
|
|
}
|
|
}
|
|
|
|
HashState hashState = new HashState();
|
|
hashState.Initialize();
|
|
|
|
for (int i = 0; i < index; i++)
|
|
{
|
|
ReadOnlySpan<byte> dataSlice = new ReadOnlySpan<byte>(data).Slice(0, _sizeTable[i].Size);
|
|
hashState.Continue(dataSlice);
|
|
_sizeTable[i].AddPartial(data, hashState.Finalize(dataSlice));
|
|
}
|
|
|
|
hashState.Continue(data);
|
|
return sizeEntry.GetOrAdd(data, hashState.Finalize(data), item);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Performs binary search on a list of hash tables, each one with a fixed data size.
|
|
/// </summary>
|
|
/// <param name="entries">List of hash tables</param>
|
|
/// <param name="size">Size to search for</param>
|
|
/// <returns>Index of the hash table with the given size, or nearest one otherwise</returns>
|
|
private static int BinarySearch(List<SizeEntry> entries, int size)
|
|
{
|
|
int left = 0;
|
|
int middle = 0;
|
|
int right = entries.Count - 1;
|
|
|
|
while (left <= right)
|
|
{
|
|
middle = left + ((right - left) >> 1);
|
|
|
|
SizeEntry entry = entries[middle];
|
|
|
|
if (size == entry.Size)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (size < entry.Size)
|
|
{
|
|
right = middle - 1;
|
|
}
|
|
else
|
|
{
|
|
left = middle + 1;
|
|
}
|
|
}
|
|
|
|
return middle;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tries to find an item on the table.
|
|
/// </summary>
|
|
/// <param name="dataAccessor">Data accessor</param>
|
|
/// <param name="item">Item, if found</param>
|
|
/// <param name="data">Data, if found</param>
|
|
/// <returns>True if the item was found on the table, false otherwise</returns>
|
|
public bool TryFindItem(IDataAccessor dataAccessor, out T item, out byte[] data)
|
|
{
|
|
SmartDataAccessor sda = new SmartDataAccessor(dataAccessor);
|
|
|
|
item = default;
|
|
data = null;
|
|
|
|
int left = 0;
|
|
int right = _sizeTable.Count;
|
|
|
|
while (left != right)
|
|
{
|
|
int index = left + ((right - left) >> 1);
|
|
|
|
PartitionHashTable<T>.SearchResult result = _sizeTable[index].TryFindItem(ref sda, ref item, ref data);
|
|
|
|
if (result == PartitionHashTable<T>.SearchResult.FoundFull)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (result == PartitionHashTable<T>.SearchResult.NotFound)
|
|
{
|
|
right = index;
|
|
}
|
|
else /* if (result == PartitionHashTable<T>.SearchResult.FoundPartial) */
|
|
{
|
|
left = index + 1;
|
|
}
|
|
}
|
|
|
|
data = null;
|
|
return false;
|
|
}
|
|
}
|
|
}
|