From 06aa8a7578c794dd4b16f12df5ce1bbeabc1d1c1 Mon Sep 17 00:00:00 2001 From: sharmander Date: Wed, 9 Dec 2020 17:26:05 -0500 Subject: [PATCH] GPU - Improve Memory Allocation (#1722) * Implement TreeMap from scratch. Begin implementation of MemoryBlockManager * Implement GetFreePosition using MemoryBlocks * Implementation of Memory Management using a Tree. Still some issues to work around, but promising thus far. * Resolved invalid mapping issue. Performance appears promising. * Add tick metrics * Use the logger instead * Use debug loggin instead of info. * Remove unnecessary code. Add descriptions of added functions. * Improve memory allocation even further. As well as improve speed of position fetching. * Add TreeDictionary to Ryujinx Commons Removed Unnecessary Usigns * Add a Performance Profiler + Improve ReserveFixed * Begin transition to allocation in nvdrv * Create singleton nvmemallocator * Moved Allocation into Nv Related Files As requested by gdkchan, any allocation of memory has been moved into the driver files. Mapping remains in the GPU MemoryManager. * Remove unnecessary usings * Add missing descriptions * Correct descriptions * Fix formatting. * Remove unnecessary whitespace * Formatting / Convention Updates * Changes / Fixes Made syntax and convention changes as requested by gdkchan. Fixed an issue where IsRegionUsed would return the wrong boolean. Fixed an issue where GetFreePosition was asked for an address instead of a size. * Undo commenting of Assert in shader cache * Update Ryujinx.Common/Collections/TreeDictionary.cs Co-authored-by: gdkchan * Resolved many suggestions * Implement Improved TreeDictionary Based off of Pseudo code and custom implementations. * Rename _set to _dictionary * Remove unused code * Remove unused code. * Remove unnecessary MapLow function. * Resolve data-structure based issues * Make adjustments to memory management. Deactive de-allocation for now, it causes more harm than good. * Minor refactorings + Re-implement deallocation Also cleaned up unnecessary code. * Add Tests for TreeDictionary * Update data structure to properly balance the tree * Experimental Implementation: 1. Reduce Time to Next Node to O(1) Runtime 2. Reduce While Loop Ct To 2 (In Most Cases) * Address issues w/ Deallocating Memory * Final Build + Fully Implement Dictionary Interface for new Data Structure + Cover All Memory Allocation Edge Cases, particularly w/ Games that De-Allocate a lot. * Minor Corrections Give TreeDictionary its own count (do not depend on inner dictionary) Properly remove adjacent allocations * Add AsList * Fix bug where internal dictionary wasn't being updated w/ new node for overwritten key. * Address comments in review. * Fix issue where block wouldn't break out (Fixes UE4 issues) * Update descriptions * Update descriptions * Reduce Node visibility to protect TreeDictionary Integrity + Remove usage of struct. * Update tests to use new TreeDictionary implementation. * Remove usage of dictionary in TreeDictionary * Refactoring / Renaming * Remove unneeded memoryblock class. * Add space for while * Add space for if * Formatting / descriptions * Clarified some descriptions * Reduce visibility of memory allocator * Edit method names to make more sense as memory blocks are no longer in use. * Make names consistent. * Protect against npe when sucessorof is called against keys that don't exist. (Not in use by memory manager, this is for other prs that might use this data structure) * Possible edge-case resolve * Update Ryujinx.Common/Collections/TreeDictionary.cs Co-authored-by: gdkchan * Update Ryujinx.HLE/HOS/Services/Nv/NvMemoryAllocator.cs Co-authored-by: gdkchan * Reduce # of unnecessary duplicate variables / Reduce visibility of variables only internally used. * Rename count to _count * Update Description of Add method. * Fix copypasta * Address comments * Address comments * Remove whitespace * Address comments, condense variables. * Consolidate vars * Fix whitespace. * Nit * Fix exception msg * Fix arrayIndex check * Fix arrayIndex check + indexer * Remove whitespace from cast Co-authored-by: gdkchan --- Ryujinx.Common/Collections/TreeDictionary.cs | 987 ++++++++++++++++++ Ryujinx.Graphics.Gpu/Image/TextureManager.cs | 8 +- Ryujinx.Graphics.Gpu/Image/TexturePool.cs | 2 +- Ryujinx.Graphics.Gpu/Memory/BufferManager.cs | 2 +- Ryujinx.Graphics.Gpu/Memory/MemoryManager.cs | 191 +--- .../NvHostAsGpu/NvHostAsGpuDeviceFile.cs | 41 +- .../NvHostChannel/NvHostChannelDeviceFile.cs | 17 +- .../HOS/Services/Nv/NvMemoryAllocator.cs | 282 +++++ Ryujinx.HLE/Switch.cs | 5 + Ryujinx.Tests/TreeDictionaryTests.cs | 244 +++++ 10 files changed, 1577 insertions(+), 202 deletions(-) create mode 100644 Ryujinx.Common/Collections/TreeDictionary.cs create mode 100644 Ryujinx.HLE/HOS/Services/Nv/NvMemoryAllocator.cs create mode 100644 Ryujinx.Tests/TreeDictionaryTests.cs diff --git a/Ryujinx.Common/Collections/TreeDictionary.cs b/Ryujinx.Common/Collections/TreeDictionary.cs new file mode 100644 index 0000000000..a44f650c1b --- /dev/null +++ b/Ryujinx.Common/Collections/TreeDictionary.cs @@ -0,0 +1,987 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; + +namespace Ryujinx.Common.Collections +{ + /// + /// Dictionary that provides the ability for O(logN) Lookups for keys that exist in the Dictionary, and O(logN) lookups for keys immediately greater than or less than a specified key. + /// + /// Key + /// Value + public class TreeDictionary : IDictionary where K : IComparable + { + private const bool Black = true; + private const bool Red = false; + private Node _root = null; + private int _count = 0; + public TreeDictionary() { } + + #region Public Methods + + /// + /// Returns the value of the node whose key is , or the default value if no such node exists. + /// + /// Key of the node value to get + /// Value associated w/ + /// is null + public V Get(K key) + { + if (key == null) + { + throw new ArgumentNullException(nameof(key)); + } + + Node node = GetNode(key); + + if (node == null) + { + return default; + } + + return node.Value; + } + + /// + /// Adds a new node into the tree whose key is key and value is . + ///

+ /// Note: Adding the same key multiple times will cause the value for that key to be overwritten. + /// + /// Key of the node to add + /// Value of the node to add + /// or are null + public void Add(K key, V value) + { + if (key == null) + { + throw new ArgumentNullException(nameof(key)); + } + if (null == value) + { + throw new ArgumentNullException(nameof(value)); + } + + Insert(key, value); + } + + /// + /// Removes the node whose key is from the tree. + /// + /// Key of the node to remove + /// is null + public void Remove(K key) + { + if (key == null) + { + throw new ArgumentNullException(nameof(key)); + } + if (Delete(key) != null) + { + _count--; + } + } + + /// + /// Returns the value whose key is equal to or immediately less than . + /// + /// Key for which to find the floor value of + /// Key of node immediately less than + /// is null + public K Floor(K key) + { + Node node = FloorNode(key); + if (node != null) + { + return node.Key; + } + return default; + } + + /// + /// Returns the node whose key is equal to or immediately greater than . + /// + /// Key for which to find the ceiling node of + /// Key of node immediately greater than + /// is null + public K Ceiling(K key) + { + Node node = CeilingNode(key); + if (node != null) + { + return node.Key; + } + return default; + } + + /// + /// Finds the value whose key is immediately greater than . + /// + /// Key to find the successor of + /// Value + public K SuccessorOf(K key) + { + Node node = GetNode(key); + if (node != null) + { + Node successor = SuccessorOf(node); + + return successor != null ? successor.Key : default; + } + return default; + } + + /// + /// Finds the value whose key is immediately less than . + /// + /// Key to find the predecessor of + /// Value + public K PredecessorOf(K key) + { + Node node = GetNode(key); + if (node != null) + { + Node predecessor = PredecessorOf(node); + + return predecessor != null ? predecessor.Key : default; + } + return default; + } + + /// + /// Adds all the nodes in the dictionary as key/value pairs into . + ///

+ /// The key/value pairs will be added in Level Order. + /// + /// List to add the tree pairs into + public List> AsLevelOrderList() + { + List> list = new List>(); + + Queue> nodes = new Queue>(); + + if (this._root != null) + { + nodes.Enqueue(this._root); + } + while (nodes.Count > 0) + { + Node node = nodes.Dequeue(); + list.Add(new KeyValuePair(node.Key, node.Value)); + if (node.Left != null) + { + nodes.Enqueue(node.Left); + } + if (node.Right != null) + { + nodes.Enqueue(node.Right); + } + } + return list; + } + + /// + /// Adds all the nodes in the dictionary into . + ///

+ /// The nodes will be added in Sorted by Key Order. + /// + public List> AsList() + { + List> list = new List>(); + + Queue> nodes = new Queue>(); + + if (this._root != null) + { + nodes.Enqueue(this._root); + } + while (nodes.Count > 0) + { + Node node = nodes.Dequeue(); + list.Add(new KeyValuePair(node.Key, node.Value)); + if (node.Left != null) + { + nodes.Enqueue(node.Left); + } + if (node.Right != null) + { + nodes.Enqueue(node.Right); + } + } + + return list; + } + #endregion + #region Private Methods (BST) + + /// + /// Retrieve the node reference whose key is , or null if no such node exists. + /// + /// Key of the node to get + /// Node reference in the tree + /// is null + private Node GetNode(K key) + { + if (key == null) + { + throw new ArgumentNullException(nameof(key)); + } + + Node node = _root; + while (node != null) + { + int cmp = key.CompareTo(node.Key); + if (cmp < 0) + { + node = node.Left; + } + else if (cmp > 0) + { + node = node.Right; + } + else + { + return node; + } + } + return null; + } + + /// + /// Inserts a new node into the tree whose key is and value is . + ///

+ /// Adding the same key multiple times will overwrite the previous value. + /// + /// Key of the node to insert + /// Value of the node to insert + private void Insert(K key, V value) + { + Node newNode = BSTInsert(key, value); + RestoreBalanceAfterInsertion(newNode); + } + + /// + /// Insertion Mechanism for a Binary Search Tree (BST). + ///

+ /// Iterates the tree starting from the root and inserts a new node where all children in the left subtree are less than , and all children in the right subtree are greater than . + ///

+ /// Note: If a node whose key is already exists, it's value will be overwritten. + /// + /// Key of the node to insert + /// Value of the node to insert + /// The inserted Node + private Node BSTInsert(K key, V value) + { + Node parent = null; + Node node = _root; + + while (node != null) + { + parent = node; + int cmp = key.CompareTo(node.Key); + if (cmp < 0) + { + node = node.Left; + } + else if (cmp > 0) + { + node = node.Right; + } + else + { + node.Value = value; + return node; + } + } + Node newNode = new Node(key, value, parent); + if (newNode.Parent == null) + { + _root = newNode; + } + else if (key.CompareTo(parent.Key) < 0) + { + parent.Left = newNode; + } + else + { + parent.Right = newNode; + } + _count++; + return newNode; + } + + /// + /// Removes from the dictionary, if it exists. + /// + /// Key of the node to delete + /// The deleted Node + private Node Delete(K key) + { + // O(1) Retrieval + Node nodeToDelete = GetNode(key); + + if (nodeToDelete == null) return null; + + Node replacementNode; + + if (LeftOf(nodeToDelete) == null || RightOf(nodeToDelete) == null) + { + replacementNode = nodeToDelete; + } + else + { + replacementNode = PredecessorOf(nodeToDelete); + } + + Node 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.Key = replacementNode.Key; + nodeToDelete.Value = replacementNode.Value; + } + + if (tmp != null && ColorOf(replacementNode) == Black) + { + RestoreBalanceAfterRemoval(tmp); + } + + return replacementNode; + } + + /// + /// Returns the node with the largest key where is considered the root node. + /// + /// Root Node + /// Node with the maximum key in the tree of + /// is null + private static Node Maximum(Node node) + { + if (node == null) + { + throw new ArgumentNullException(nameof(node)); + } + Node tmp = node; + while (tmp.Right != null) + { + tmp = tmp.Right; + } + + return tmp; + } + + /// + /// Returns the node with the smallest key where is considered the root node. + /// + /// Root Node + /// Node with the minimum key in the tree of + /// is null + private static Node Minimum(Node node) + { + if (node == null) + { + throw new ArgumentNullException(nameof(node)); + } + Node tmp = node; + while (tmp.Left != null) + { + tmp = tmp.Left; + } + + return tmp; + } + + /// + /// Returns the node whose key immediately less than or equal to . + /// + /// Key for which to find the floor node of + /// Node whose key is immediately less than or equal to , or null if no such node is found. + /// is null + private Node FloorNode(K key) + { + if (key == null) + { + throw new ArgumentNullException(nameof(key)); + } + Node tmp = _root; + + while (tmp != null) + { + int cmp = key.CompareTo(tmp.Key); + if (cmp > 0) + { + if (tmp.Right != null) + { + tmp = tmp.Right; + } + else + { + return tmp; + } + } + else if (cmp < 0) + { + if (tmp.Left != null) + { + tmp = tmp.Left; + } + else + { + Node parent = tmp.Parent; + Node ptr = tmp; + while (parent != null && ptr == parent.Left) + { + ptr = parent; + parent = parent.Parent; + } + return parent; + } + } + else + { + return tmp; + } + } + return null; + } + + /// + /// Returns the node whose key is immediately greater than or equal to than . + /// + /// Key for which to find the ceiling node of + /// Node whose key is immediately greater than or equal to , or null if no such node is found. + /// is null + private Node CeilingNode(K key) + { + if (key == null) + { + throw new ArgumentNullException(nameof(key)); + } + Node tmp = _root; + + while (tmp != null) + { + int cmp = key.CompareTo(tmp.Key); + if (cmp < 0) + { + if (tmp.Left != null) + { + tmp = tmp.Left; + } + else + { + return tmp; + } + } + else if (cmp > 0) + { + if (tmp.Right != null) + { + tmp = tmp.Right; + } + else + { + Node parent = tmp.Parent; + Node ptr = tmp; + while (parent != null && ptr == parent.Right) + { + ptr = parent; + parent = parent.Parent; + } + return parent; + } + } + else + { + return tmp; + } + } + return null; + } + + /// + /// Finds the node with the key immediately greater than .Key. + /// + /// Node to find the successor of + /// Successor of + private static Node SuccessorOf(Node node) + { + if (node.Right != null) + { + return Minimum(node.Right); + } + Node parent = node.Parent; + while (parent != null && node == parent.Right) + { + node = parent; + parent = parent.Parent; + } + return parent; + } + + /// + /// Finds the node whose key immediately less than .Key. + /// + /// Node to find the predecessor of + /// Predecessor of + private static Node PredecessorOf(Node node) + { + if (node.Left != null) + { + return Maximum(node.Left); + } + Node parent = node.Parent; + while (parent != null && node == parent.Left) + { + node = parent; + parent = parent.Parent; + } + return parent; + } + #endregion + #region Private Methods (RBL) + + private void RestoreBalanceAfterRemoval(Node balanceNode) + { + Node ptr = balanceNode; + + while (ptr != _root && ColorOf(ptr) == Black) + { + if (ptr == LeftOf(ParentOf(ptr))) + { + Node 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 + { + Node 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(Node balanceNode) + { + SetColor(balanceNode, Red); + while (balanceNode != null && balanceNode != _root && ColorOf(ParentOf(balanceNode)) == Red) + { + if (ParentOf(balanceNode) == LeftOf(ParentOf(ParentOf(balanceNode)))) + { + Node 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 + { + Node 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(Node node) + { + if (node != null) + { + Node right = RightOf(node); + node.Right = LeftOf(right); + if (LeftOf(right) != null) + { + LeftOf(right).Parent = node; + } + right.Parent = ParentOf(node); + if (ParentOf(node) == null) + { + _root = right; + } + else if (node == LeftOf(ParentOf(node))) + { + ParentOf(node).Left = right; + } + else + { + ParentOf(node).Right = right; + } + right.Left = node; + node.Parent = right; + } + } + + private void RotateRight(Node node) + { + if (node != null) + { + Node left = LeftOf(node); + node.Left = RightOf(left); + if (RightOf(left) != null) + { + RightOf(left).Parent = node; + } + left.Parent = node.Parent; + if (ParentOf(node) == null) + { + _root = left; + } + else if (node == RightOf(ParentOf(node))) + { + ParentOf(node).Right = left; + } + else + { + ParentOf(node).Left = left; + } + left.Right = node; + node.Parent = left; + } + } + #endregion + + #region Safety-Methods + + // These methods save memory by allowing us to forego sentinel nil nodes, as well as serve as protection against nullpointerexceptions. + + /// + /// Returns the color of , or Black if it is null. + /// + /// Node + /// The boolean color of , or black if null + private static bool ColorOf(Node node) + { + return node == null || node.Color; + } + + /// + /// Sets the color of node to . + ///

+ /// This method does nothing if is null. + /// + /// Node to set the color of + /// Color (Boolean) + private static void SetColor(Node node, bool color) + { + if (node != null) + { + node.Color = color; + } + } + + /// + /// This method returns the left node of , or null if is null. + /// + /// Node to retrieve the left child from + /// Left child of + private static Node LeftOf(Node node) + { + return node?.Left; + } + + /// + /// This method returns the right node of , or null if is null. + /// + /// Node to retrieve the right child from + /// Right child of + private static Node RightOf(Node node) + { + return node?.Right; + } + + /// + /// Returns the parent node of , or null if is null. + /// + /// Node to retrieve the parent from + /// Parent of + private static Node ParentOf(Node node) + { + return node?.Parent; + } + #endregion + + #region Interface Implementations + + // Method descriptions are not provided as they are already included as part of the interface. + public bool ContainsKey(K key) + { + if (key == null) + { + throw new ArgumentNullException(nameof(key)); + } + return GetNode(key) != null; + } + + bool IDictionary.Remove(K key) + { + int count = _count; + Remove(key); + return count > _count; + } + + public bool TryGetValue(K key, [MaybeNullWhen(false)] out V value) + { + if (null == key) + { + throw new ArgumentNullException(nameof(key)); + } + Node node = GetNode(key); + value = node != null ? node.Value : default; + return node != null; + } + + public void Add(KeyValuePair item) + { + if (item.Key == null) + { + throw new ArgumentNullException(nameof(item.Key)); + } + + Add(item.Key, item.Value); + } + + public void Clear() + { + _root = null; + _count = 0; + } + + public bool Contains(KeyValuePair item) + { + if (item.Key == null) + { + return false; + } + + Node node = GetNode(item.Key); + if (node != null) + { + return node.Key.Equals(item.Key) && node.Value.Equals(item.Value); + } + return false; + } + + public void CopyTo(KeyValuePair[] array, int arrayIndex) + { + if (arrayIndex < 0 || array.Length - arrayIndex < this.Count) + { + throw new ArgumentOutOfRangeException(nameof(arrayIndex)); + } + + SortedList list = GetKeyValues(); + + int offset = 0; + + for (int i = arrayIndex; i < array.Length && offset < list.Count; i++) + { + array[i] = new KeyValuePair(list.Keys[i], list.Values[i]); + offset++; + } + } + + public bool Remove(KeyValuePair item) + { + Node node = GetNode(item.Key); + + if (node == null) + { + return false; + } + + if (node.Value.Equals(item.Value)) + { + int count = _count; + Remove(item.Key); + return count > _count; + } + + return false; + } + + public IEnumerator> GetEnumerator() + { + return GetKeyValues().GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetKeyValues().GetEnumerator(); + } + + public int Count => _count; + + public ICollection Keys => GetKeyValues().Keys; + + public ICollection Values => GetKeyValues().Values; + + public bool IsReadOnly => false; + + public V this[K key] + { + get => Get(key); + set => Add(key, value); + } + + #endregion + #region Private Interface Helper Methods + + /// + /// Returns a sorted list of all the node keys / values in the tree. + /// + /// List of node keys + private SortedList GetKeyValues() + { + SortedList set = new SortedList(); + Queue> queue = new Queue>(); + if (_root != null) + { + queue.Enqueue(_root); + } + + while (queue.Count > 0) + { + Node node = queue.Dequeue(); + set.Add(node.Key, node.Value); + if (null != node.Left) + { + queue.Enqueue(node.Left); + } + if (null != node.Right) + { + queue.Enqueue(node.Right); + } + } + + return set; + } + #endregion + } + + /// + /// Represents a node in the TreeDictionary which contains a key and value of generic type K and V, respectively. + /// + /// Key of the node + /// Value of the node + internal class Node + { + internal bool Color = true; + internal Node Left = null; + internal Node Right = null; + internal Node Parent = null; + internal K Key; + internal V Value; + + public Node(K key, V value, Node parent) + { + this.Key = key; + this.Value = value; + this.Parent = parent; + } + } +} diff --git a/Ryujinx.Graphics.Gpu/Image/TextureManager.cs b/Ryujinx.Graphics.Gpu/Image/TextureManager.cs index 6b11a6715f..993218ce09 100644 --- a/Ryujinx.Graphics.Gpu/Image/TextureManager.cs +++ b/Ryujinx.Graphics.Gpu/Image/TextureManager.cs @@ -472,7 +472,7 @@ namespace Ryujinx.Graphics.Gpu.Image { ulong address = _context.MemoryManager.Translate(copyTexture.Address.Pack()); - if (address == MemoryManager.BadAddress) + if (address == MemoryManager.PteUnmapped) { return null; } @@ -533,7 +533,7 @@ namespace Ryujinx.Graphics.Gpu.Image { ulong address = _context.MemoryManager.Translate(colorState.Address.Pack()); - if (address == MemoryManager.BadAddress) + if (address == MemoryManager.PteUnmapped) { return null; } @@ -618,7 +618,7 @@ namespace Ryujinx.Graphics.Gpu.Image { ulong address = _context.MemoryManager.Translate(dsState.Address.Pack()); - if (address == MemoryManager.BadAddress) + if (address == MemoryManager.PteUnmapped) { return null; } @@ -983,7 +983,7 @@ namespace Ryujinx.Graphics.Gpu.Image { ulong address = _context.MemoryManager.Translate(cbp.DstAddress.Pack()); - if (address == MemoryManager.BadAddress) + if (address == MemoryManager.PteUnmapped) { return null; } diff --git a/Ryujinx.Graphics.Gpu/Image/TexturePool.cs b/Ryujinx.Graphics.Gpu/Image/TexturePool.cs index 53d810b960..9c7e849b82 100644 --- a/Ryujinx.Graphics.Gpu/Image/TexturePool.cs +++ b/Ryujinx.Graphics.Gpu/Image/TexturePool.cs @@ -54,7 +54,7 @@ namespace Ryujinx.Graphics.Gpu.Image // Bad address. We can't add a texture with a invalid address // to the cache. - if (info.Address == MemoryManager.BadAddress) + if (info.Address == MemoryManager.PteUnmapped) { return null; } diff --git a/Ryujinx.Graphics.Gpu/Memory/BufferManager.cs b/Ryujinx.Graphics.Gpu/Memory/BufferManager.cs index 568133ca54..1d48b38ca3 100644 --- a/Ryujinx.Graphics.Gpu/Memory/BufferManager.cs +++ b/Ryujinx.Graphics.Gpu/Memory/BufferManager.cs @@ -401,7 +401,7 @@ namespace Ryujinx.Graphics.Gpu.Memory ulong address = _context.MemoryManager.Translate(gpuVa); - if (address == MemoryManager.BadAddress) + if (address == MemoryManager.PteUnmapped) { return 0; } diff --git a/Ryujinx.Graphics.Gpu/Memory/MemoryManager.cs b/Ryujinx.Graphics.Gpu/Memory/MemoryManager.cs index 91575e205a..2990fb52a5 100644 --- a/Ryujinx.Graphics.Gpu/Memory/MemoryManager.cs +++ b/Ryujinx.Graphics.Gpu/Memory/MemoryManager.cs @@ -10,10 +10,6 @@ namespace Ryujinx.Graphics.Gpu.Memory /// public class MemoryManager { - private const ulong AddressSpaceSize = 1UL << 40; - - public const ulong BadAddress = ulong.MaxValue; - private const int PtLvl0Bits = 14; private const int PtLvl1Bits = 14; public const int PtPageBits = 12; @@ -29,8 +25,7 @@ namespace Ryujinx.Graphics.Gpu.Memory private const int PtLvl0Bit = PtPageBits + PtLvl1Bits; private const int PtLvl1Bit = PtPageBits; - private const ulong PteUnmapped = 0xffffffff_ffffffff; - private const ulong PteReserved = 0xffffffff_fffffffe; + public const ulong PteUnmapped = 0xffffffff_ffffffff; private readonly ulong[][] _pageTable; @@ -136,116 +131,6 @@ namespace Ryujinx.Graphics.Gpu.Memory return va; } - /// - /// Maps a given range of pages to an allocated GPU virtual address. - /// The memory is automatically allocated by the memory manager. - /// - /// CPU virtual address to map into - /// Size in bytes of the mapping - /// Required alignment of the GPU virtual address in bytes - /// GPU virtual address where the range was mapped, or an all ones mask in case of failure - public ulong MapAllocate(ulong pa, ulong size, ulong alignment) - { - lock (_pageTable) - { - ulong va = GetFreePosition(size, alignment); - - if (va != PteUnmapped) - { - for (ulong offset = 0; offset < size; offset += PageSize) - { - SetPte(va + offset, pa + offset); - } - } - - return va; - } - } - - /// - /// Maps a given range of pages to an allocated GPU virtual address. - /// The memory is automatically allocated by the memory manager. - /// This also ensures that the mapping is always done in the first 4GB of GPU address space. - /// - /// CPU virtual address to map into - /// Size in bytes of the mapping - /// GPU virtual address where the range was mapped, or an all ones mask in case of failure - public ulong MapLow(ulong pa, ulong size) - { - lock (_pageTable) - { - ulong va = GetFreePosition(size, 1, PageSize); - - if (va != PteUnmapped && va <= uint.MaxValue && (va + size) <= uint.MaxValue) - { - for (ulong offset = 0; offset < size; offset += PageSize) - { - SetPte(va + offset, pa + offset); - } - } - else - { - va = PteUnmapped; - } - - return va; - } - } - - /// - /// Reserves memory at a fixed GPU memory location. - /// This prevents the reserved region from being used for memory allocation for map. - /// - /// GPU virtual address to reserve - /// Size in bytes of the reservation - /// GPU virtual address of the reservation, or an all ones mask in case of failure - public ulong ReserveFixed(ulong va, ulong size) - { - lock (_pageTable) - { - MemoryUnmapped?.Invoke(this, new UnmapEventArgs(va, size)); - - for (ulong offset = 0; offset < size; offset += PageSize) - { - if (IsPageInUse(va + offset)) - { - return PteUnmapped; - } - } - - for (ulong offset = 0; offset < size; offset += PageSize) - { - SetPte(va + offset, PteReserved); - } - } - - return va; - } - - /// - /// Reserves memory at any GPU memory location. - /// - /// Size in bytes of the reservation - /// Reservation address alignment in bytes - /// GPU virtual address of the reservation, or an all ones mask in case of failure - public ulong Reserve(ulong size, ulong alignment) - { - lock (_pageTable) - { - ulong address = GetFreePosition(size, alignment); - - if (address != PteUnmapped) - { - for (ulong offset = 0; offset < size; offset += PageSize) - { - SetPte(address + offset, PteReserved); - } - } - - return address; - } - } - /// /// Frees memory that was previously allocated by a map or reserved. /// @@ -265,55 +150,6 @@ namespace Ryujinx.Graphics.Gpu.Memory } } - /// - /// Gets the address of an unused (free) region of the specified size. - /// - /// Size of the region in bytes - /// Required alignment of the region address in bytes - /// Start address of the search on the address space - /// GPU virtual address of the allocation, or an all ones mask in case of failure - private ulong GetFreePosition(ulong size, ulong alignment = 1, ulong start = 1UL << 32) - { - // Note: Address 0 is not considered valid by the driver, - // when 0 is returned it's considered a mapping error. - ulong address = start; - ulong freeSize = 0; - - if (alignment == 0) - { - alignment = 1; - } - - alignment = (alignment + PageMask) & ~PageMask; - - while (address + freeSize < AddressSpaceSize) - { - if (!IsPageInUse(address + freeSize)) - { - freeSize += PageSize; - - if (freeSize >= size) - { - return address; - } - } - else - { - address += freeSize + PageSize; - freeSize = 0; - - ulong remainder = address % alignment; - - if (remainder != 0) - { - address = (address - remainder) + alignment; - } - } - } - - return PteUnmapped; - } - /// /// Checks if a given page is mapped. /// @@ -333,7 +169,7 @@ namespace Ryujinx.Graphics.Gpu.Memory { ulong baseAddress = GetPte(gpuVa); - if (baseAddress == PteUnmapped || baseAddress == PteReserved) + if (baseAddress == PteUnmapped) { return PteUnmapped; } @@ -341,29 +177,6 @@ namespace Ryujinx.Graphics.Gpu.Memory return baseAddress + (gpuVa & PageMask); } - /// - /// Checks if a given memory page is mapped or reserved. - /// - /// GPU virtual address of the page - /// True if the page is mapped or reserved, false otherwise - private bool IsPageInUse(ulong gpuVa) - { - if (gpuVa >> PtLvl0Bits + PtLvl1Bits + PtPageBits != 0) - { - return false; - } - - ulong l0 = (gpuVa >> PtLvl0Bit) & PtLvl0Mask; - ulong l1 = (gpuVa >> PtLvl1Bit) & PtLvl1Mask; - - if (_pageTable[l0] == null) - { - return false; - } - - return _pageTable[l0][l1] != PteUnmapped; - } - /// /// Gets the Page Table entry for a given GPU virtual address. /// diff --git a/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostAsGpu/NvHostAsGpuDeviceFile.cs b/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostAsGpu/NvHostAsGpuDeviceFile.cs index 6c49fd5ca1..fb97322930 100644 --- a/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostAsGpu/NvHostAsGpuDeviceFile.cs +++ b/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostAsGpu/NvHostAsGpuDeviceFile.cs @@ -1,4 +1,5 @@ -using Ryujinx.Common.Logging; +using Ryujinx.Common.Collections; +using Ryujinx.Common.Logging; using Ryujinx.Graphics.Gpu.Memory; using Ryujinx.HLE.HOS.Kernel.Process; using Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostAsGpu.Types; @@ -12,8 +13,12 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostAsGpu class NvHostAsGpuDeviceFile : NvDeviceFile { private static ConcurrentDictionary _addressSpaceContextRegistry = new ConcurrentDictionary(); + private NvMemoryAllocator _memoryAllocator; - public NvHostAsGpuDeviceFile(ServiceCtx context, IVirtualMemoryManager memory, long owner) : base(context, owner) { } + public NvHostAsGpuDeviceFile(ServiceCtx context, IVirtualMemoryManager memory, long owner) : base(context, owner) + { + _memoryAllocator = context.Device.MemoryAllocator; + } public override NvInternalResult Ioctl(NvIoctl command, Span arguments) { @@ -92,11 +97,30 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostAsGpu // the Offset field holds the alignment size instead. if ((arguments.Flags & AddressSpaceFlags.FixedOffset) != 0) { - arguments.Offset = (long)addressSpaceContext.Gmm.ReserveFixed((ulong)arguments.Offset, size); + bool regionInUse = _memoryAllocator.IsRegionInUse((ulong)arguments.Offset, size, out ulong freeAddressStartPosition); + ulong address; + + if (!regionInUse) + { + _memoryAllocator.AllocateRange((ulong)arguments.Offset, size, freeAddressStartPosition); + address = freeAddressStartPosition; + } + else + { + address = NvMemoryAllocator.PteUnmapped; + } + + arguments.Offset = (long)address; } else { - arguments.Offset = (long)addressSpaceContext.Gmm.Reserve((ulong)size, (ulong)arguments.Offset); + ulong address = _memoryAllocator.GetFreeAddress((ulong)size, out ulong freeAddressStartPosition, (ulong)arguments.Offset); + if (address != NvMemoryAllocator.PteUnmapped) + { + _memoryAllocator.AllocateRange(address, (ulong)size, freeAddressStartPosition); + } + + arguments.Offset = unchecked((long)address); } if (arguments.Offset < 0) @@ -128,6 +152,7 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostAsGpu if (addressSpaceContext.RemoveReservation(arguments.Offset)) { + _memoryAllocator.DeallocateRange((ulong)arguments.Offset, size); addressSpaceContext.Gmm.Free((ulong)arguments.Offset, size); } else @@ -152,6 +177,7 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostAsGpu { if (size != 0) { + _memoryAllocator.DeallocateRange((ulong)arguments.Offset, (ulong)size); addressSpaceContext.Gmm.Free((ulong)arguments.Offset, (ulong)size); } } @@ -252,7 +278,12 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostAsGpu } else { - arguments.Offset = (long)addressSpaceContext.Gmm.MapAllocate((ulong)physicalAddress, (ulong)size, pageSize); + ulong va = _memoryAllocator.GetFreeAddress((ulong)size, out ulong freeAddressStartPosition, (ulong) pageSize); + if (va != NvMemoryAllocator.PteUnmapped) + { + _memoryAllocator.AllocateRange(va, (ulong)size, freeAddressStartPosition); + } + arguments.Offset = (long)addressSpaceContext.Gmm.Map((ulong)physicalAddress, va, (ulong)size); } if (arguments.Offset < 0) diff --git a/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostChannel/NvHostChannelDeviceFile.cs b/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostChannel/NvHostChannelDeviceFile.cs index d675ffc701..ca20aab505 100644 --- a/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostChannel/NvHostChannelDeviceFile.cs +++ b/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostChannel/NvHostChannelDeviceFile.cs @@ -1,4 +1,5 @@ -using Ryujinx.Common.Logging; +using Ryujinx.Common.Collections; +using Ryujinx.Common.Logging; using Ryujinx.Graphics.Gpu.Memory; using Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostAsGpu; using Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel.Types; @@ -23,6 +24,7 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel private readonly Switch _device; private readonly IVirtualMemoryManager _memory; + private NvMemoryAllocator _memoryAllocator; public enum ResourcePolicy { @@ -45,6 +47,7 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel _timeout = 3000; _submitTimeout = 0; _timeslice = 0; + _memoryAllocator = _device.MemoryAllocator; ChannelSyncpoints = new uint[MaxModuleSyncpoint]; @@ -245,7 +248,17 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel { if (map.DmaMapAddress == 0) { - map.DmaMapAddress = (long)gmm.MapLow((ulong)map.Address, (uint)map.Size); + ulong va = _memoryAllocator.GetFreeAddress((ulong) map.Size, out ulong freeAddressStartPosition, 1, MemoryManager.PageSize); + + if (va != NvMemoryAllocator.PteUnmapped && va <= uint.MaxValue && (va + (uint)map.Size) <= uint.MaxValue) + { + _memoryAllocator.AllocateRange(va, (uint)map.Size, freeAddressStartPosition); + map.DmaMapAddress = (long)gmm.Map((ulong)map.Address, va, (uint)map.Size); + } + else + { + map.DmaMapAddress = unchecked((long)NvMemoryAllocator.PteUnmapped); + } } commandBufferEntry.MapAddress = (int)map.DmaMapAddress; diff --git a/Ryujinx.HLE/HOS/Services/Nv/NvMemoryAllocator.cs b/Ryujinx.HLE/HOS/Services/Nv/NvMemoryAllocator.cs new file mode 100644 index 0000000000..4662660818 --- /dev/null +++ b/Ryujinx.HLE/HOS/Services/Nv/NvMemoryAllocator.cs @@ -0,0 +1,282 @@ +using Ryujinx.Common.Collections; +using System.Collections.Generic; +using Ryujinx.Common; +using System; +using Ryujinx.Graphics.Gpu.Memory; + +namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices +{ + class NvMemoryAllocator + { + private const ulong AddressSpaceSize = 1UL << 40; + + private const ulong DefaultStart = 1UL << 32; + private const ulong InvalidAddress = 0; + + private const ulong PageSize = MemoryManager.PageSize; + private const ulong PageMask = MemoryManager.PageMask; + + public const ulong PteUnmapped = MemoryManager.PteUnmapped; + + // Key --> Start Address of Region + // Value --> End Address of Region + private readonly TreeDictionary _tree = new TreeDictionary(); + + private readonly Dictionary> _dictionary = new Dictionary>(); + private readonly LinkedList _list = new LinkedList(); + + public NvMemoryAllocator() + { + _tree.Add(PageSize, PageSize + AddressSpaceSize); + LinkedListNode node = _list.AddFirst(PageSize); + _dictionary[PageSize] = node; + } + + /// + /// Marks a range of memory as consumed by removing it from the tree. + /// This function will split memory regions if there is available space. + /// + /// Virtual address at which to allocate + /// Size of the allocation in bytes + /// Reference to the address of memory where the allocation can take place + #region Memory Allocation + public void AllocateRange(ulong va, ulong size, ulong referenceAddress = InvalidAddress) + { + lock (_tree) + { + if (referenceAddress != InvalidAddress) + { + ulong endAddress = va + size; + ulong referenceEndAddress = _tree.Get(referenceAddress); + if (va >= referenceAddress) + { + // Need Left Node + if (va > referenceAddress) + { + ulong leftEndAddress = va; + + // Overwrite existing block with its new smaller range. + _tree.Add(referenceAddress, leftEndAddress); + } + else + { + // We need to get rid of the large chunk. + _tree.Remove(referenceAddress); + } + + ulong rightSize = referenceEndAddress - endAddress; + // If leftover space, create a right node. + if (rightSize > 0) + { + _tree.Add(endAddress, referenceEndAddress); + + LinkedListNode node = _list.AddAfter(_dictionary[referenceAddress], endAddress); + _dictionary[endAddress] = node; + } + + if (va == referenceAddress) + { + _list.Remove(_dictionary[referenceAddress]); + _dictionary.Remove(referenceAddress); + } + } + } + } + } + + /// + /// Marks a range of memory as free by adding it to the tree. + /// This function will automatically compact the tree when it determines there are multiple ranges of free memory adjacent to each other. + /// + /// Virtual address at which to deallocate + /// Size of the allocation in bytes + public void DeallocateRange(ulong va, ulong size) + { + lock (_tree) + { + ulong freeAddressStartPosition = _tree.Floor(va); + if (freeAddressStartPosition != InvalidAddress) + { + LinkedListNode node = _dictionary[freeAddressStartPosition]; + ulong targetPrevAddress = _dictionary[freeAddressStartPosition].Previous != null ? _dictionary[_dictionary[freeAddressStartPosition].Previous.Value].Value : InvalidAddress; + ulong targetNextAddress = _dictionary[freeAddressStartPosition].Next != null ? _dictionary[_dictionary[freeAddressStartPosition].Next.Value].Value : InvalidAddress; + ulong expandedStart = va; + ulong expandedEnd = va + size; + + while (targetPrevAddress != InvalidAddress) + { + ulong prevAddress = targetPrevAddress; + ulong prevEndAddress = _tree.Get(targetPrevAddress); + if (prevEndAddress >= expandedStart) + { + expandedStart = targetPrevAddress; + LinkedListNode prevPtr = _dictionary[prevAddress]; + if (prevPtr.Previous != null) + { + targetPrevAddress = prevPtr.Previous.Value; + } + else + { + targetPrevAddress = InvalidAddress; + } + node = node.Previous; + _tree.Remove(prevAddress); + _list.Remove(_dictionary[prevAddress]); + _dictionary.Remove(prevAddress); + } + else + { + break; + } + } + + while (targetNextAddress != InvalidAddress) + { + ulong nextAddress = targetNextAddress; + ulong nextEndAddress = _tree.Get(targetNextAddress); + if (nextAddress <= expandedEnd) + { + expandedEnd = Math.Max(expandedEnd, nextEndAddress); + LinkedListNode nextPtr = _dictionary[nextAddress]; + if (nextPtr.Next != null) + { + targetNextAddress = nextPtr.Next.Value; + } + else + { + targetNextAddress = InvalidAddress; + } + _tree.Remove(nextAddress); + _list.Remove(_dictionary[nextAddress]); + _dictionary.Remove(nextAddress); + } + else + { + break; + } + } + _tree.Add(expandedStart, expandedEnd); + LinkedListNode nodePtr = _list.AddAfter(node, expandedStart); + _dictionary[expandedStart] = nodePtr; + } + } + } + + /// + /// Gets the address of an unused (free) region of the specified size. + /// + /// Size of the region in bytes + /// Position at which memory can be allocated + /// Required alignment of the region address in bytes + /// Start address of the search on the address space + /// GPU virtual address of the allocation, or an all ones mask in case of failure + public ulong GetFreeAddress(ulong size, out ulong freeAddressStartPosition, ulong alignment = 1, ulong start = DefaultStart) + { + // Note: Address 0 is not considered valid by the driver, + // when 0 is returned it's considered a mapping error. + lock (_tree) + { + ulong address = start; + + if (alignment == 0) + { + alignment = 1; + } + + alignment = (alignment + PageMask) & ~PageMask; + if (address < AddressSpaceSize) + { + bool completedFirstPass = false; + ulong targetAddress; + if(start == DefaultStart) + { + targetAddress = _list.Last.Value; + } + else + { + targetAddress = _tree.Floor(address); + if(targetAddress == InvalidAddress) + { + targetAddress = _tree.Ceiling(address); + } + } + while (address < AddressSpaceSize) + { + if (targetAddress != InvalidAddress) + { + if (address >= targetAddress) + { + if (address + size <= _tree.Get(targetAddress)) + { + freeAddressStartPosition = targetAddress; + return address; + } + else + { + LinkedListNode nextPtr = _dictionary[targetAddress]; + if (nextPtr.Next != null) + { + targetAddress = nextPtr.Next.Value; + } + else + { + if (completedFirstPass) + { + break; + } + else + { + completedFirstPass = true; + address = start; + targetAddress = _tree.Floor(address); + } + } + } + } + else + { + address += PageSize * (targetAddress / PageSize - (address / PageSize)); + + ulong remainder = address % alignment; + + if (remainder != 0) + { + address = (address - remainder) + alignment; + } + } + } + else + { + break; + } + } + } + freeAddressStartPosition = InvalidAddress; + } + + return PteUnmapped; + } + + /// + /// Checks if a given memory region is mapped or reserved. + /// + /// GPU virtual address of the page + /// Size of the allocation in bytes + /// Nearest lower address that memory can be allocated + /// True if the page is mapped or reserved, false otherwise + public bool IsRegionInUse(ulong gpuVa, ulong size, out ulong freeAddressStartPosition) + { + lock (_tree) + { + ulong floorAddress = _tree.Floor(gpuVa); + freeAddressStartPosition = floorAddress; + if (floorAddress != InvalidAddress) + { + return !(gpuVa >= floorAddress && ((gpuVa + size) < _tree.Get(floorAddress))); + } + } + return true; + } + #endregion + } +} diff --git a/Ryujinx.HLE/Switch.cs b/Ryujinx.HLE/Switch.cs index d54c64e109..6014ccff92 100644 --- a/Ryujinx.HLE/Switch.cs +++ b/Ryujinx.HLE/Switch.cs @@ -12,6 +12,7 @@ using Ryujinx.HLE.HOS; using Ryujinx.HLE.HOS.Services; using Ryujinx.HLE.HOS.Services.Apm; using Ryujinx.HLE.HOS.Services.Hid; +using Ryujinx.HLE.HOS.Services.Nv.NvDrvServices; using Ryujinx.HLE.HOS.SystemState; using Ryujinx.Memory; using System; @@ -26,6 +27,8 @@ namespace Ryujinx.HLE public GpuContext Gpu { get; private set; } + internal NvMemoryAllocator MemoryAllocator { get; private set; } + internal Host1xDevice Host1x { get; } public VirtualFileSystem FileSystem { get; private set; } @@ -69,6 +72,8 @@ namespace Ryujinx.HLE Gpu = new GpuContext(renderer); + MemoryAllocator = new NvMemoryAllocator(); + Host1x = new Host1xDevice(Gpu.Synchronization); var nvdec = new NvdecDevice(Gpu.MemoryManager); var vic = new VicDevice(Gpu.MemoryManager); diff --git a/Ryujinx.Tests/TreeDictionaryTests.cs b/Ryujinx.Tests/TreeDictionaryTests.cs new file mode 100644 index 0000000000..610c2f6e02 --- /dev/null +++ b/Ryujinx.Tests/TreeDictionaryTests.cs @@ -0,0 +1,244 @@ +using NUnit.Framework; +using Ryujinx.Common.Collections; +using System; +using System.Collections.Generic; + +namespace Ryujinx.Tests.Collections +{ + class TreeDictionaryTests + { + [Test] + public void EnsureAddIntegrity() + { + TreeDictionary dictionary = new TreeDictionary(); + + Assert.AreEqual(dictionary.Count, 0); + + dictionary.Add(2, 7); + dictionary.Add(1, 4); + dictionary.Add(10, 2); + dictionary.Add(4, 1); + dictionary.Add(3, 2); + dictionary.Add(11, 2); + dictionary.Add(5, 2); + + Assert.AreEqual(dictionary.Count, 7); + + List> list = dictionary.AsLevelOrderList(); + + /* + * Tree Should Look as Follows After Rotations + * + * 2 + * 1 4 + * 3 10 + * 5 11 + * + */ + + Assert.AreEqual(list.Count, dictionary.Count); + Assert.AreEqual(list[0].Key, 2); + Assert.AreEqual(list[1].Key, 1); + Assert.AreEqual(list[2].Key, 4); + Assert.AreEqual(list[3].Key, 3); + Assert.AreEqual(list[4].Key, 10); + Assert.AreEqual(list[5].Key, 5); + Assert.AreEqual(list[6].Key, 11); + } + + [Test] + public void EnsureRemoveIntegrity() + { + TreeDictionary dictionary = new TreeDictionary(); + + Assert.AreEqual(dictionary.Count, 0); + + dictionary.Add(2, 7); + dictionary.Add(1, 4); + dictionary.Add(10, 2); + dictionary.Add(4, 1); + dictionary.Add(3, 2); + dictionary.Add(11, 2); + dictionary.Add(5, 2); + dictionary.Add(7, 2); + dictionary.Add(9, 2); + dictionary.Add(8, 2); + dictionary.Add(13, 2); + dictionary.Add(24, 2); + dictionary.Add(6, 2); + Assert.AreEqual(dictionary.Count, 13); + + List> list = dictionary.AsLevelOrderList(); + + /* + * Tree Should Look as Follows After Rotations + * + * 4 + * 2 10 + * 1 3 7 13 + * 5 9 11 24 + * 6 8 + */ + + foreach (KeyValuePair node in list) + { + Console.WriteLine($"{node.Key} -> {node.Value}"); + } + Assert.AreEqual(list.Count, dictionary.Count); + Assert.AreEqual(list[0].Key, 4); + Assert.AreEqual(list[1].Key, 2); + Assert.AreEqual(list[2].Key, 10); + Assert.AreEqual(list[3].Key, 1); + Assert.AreEqual(list[4].Key, 3); + Assert.AreEqual(list[5].Key, 7); + Assert.AreEqual(list[6].Key, 13); + Assert.AreEqual(list[7].Key, 5); + Assert.AreEqual(list[8].Key, 9); + Assert.AreEqual(list[9].Key, 11); + Assert.AreEqual(list[10].Key, 24); + Assert.AreEqual(list[11].Key, 6); + Assert.AreEqual(list[12].Key, 8); + + list.Clear(); + + dictionary.Remove(7); + + /* + * Tree Should Look as Follows After Removal + * + * 4 + * 2 10 + * 1 3 6 13 + * 5 9 11 24 + * 8 + */ + + list = dictionary.AsLevelOrderList(); + foreach (KeyValuePair node in list) + { + Console.WriteLine($"{node.Key} -> {node.Value}"); + } + Assert.AreEqual(list[0].Key, 4); + Assert.AreEqual(list[1].Key, 2); + Assert.AreEqual(list[2].Key, 10); + Assert.AreEqual(list[3].Key, 1); + Assert.AreEqual(list[4].Key, 3); + Assert.AreEqual(list[5].Key, 6); + Assert.AreEqual(list[6].Key, 13); + Assert.AreEqual(list[7].Key, 5); + Assert.AreEqual(list[8].Key, 9); + Assert.AreEqual(list[9].Key, 11); + Assert.AreEqual(list[10].Key, 24); + Assert.AreEqual(list[11].Key, 8); + + list.Clear(); + + dictionary.Remove(10); + + list = dictionary.AsLevelOrderList(); + /* + * Tree Should Look as Follows After Removal + * + * 4 + * 2 9 + * 1 3 6 13 + * 5 8 11 24 + * + */ + foreach (KeyValuePair node in list) + { + Console.WriteLine($"{node.Key} -> {node.Value}"); + } + Assert.AreEqual(list[0].Key, 4); + Assert.AreEqual(list[1].Key, 2); + Assert.AreEqual(list[2].Key, 9); + Assert.AreEqual(list[3].Key, 1); + Assert.AreEqual(list[4].Key, 3); + Assert.AreEqual(list[5].Key, 6); + Assert.AreEqual(list[6].Key, 13); + Assert.AreEqual(list[7].Key, 5); + Assert.AreEqual(list[8].Key, 8); + Assert.AreEqual(list[9].Key, 11); + Assert.AreEqual(list[10].Key, 24); + } + + [Test] + public void EnsureOverwriteIntegrity() + { + TreeDictionary dictionary = new TreeDictionary(); + + Assert.AreEqual(dictionary.Count, 0); + + dictionary.Add(2, 7); + dictionary.Add(1, 4); + dictionary.Add(10, 2); + dictionary.Add(4, 1); + dictionary.Add(3, 2); + dictionary.Add(11, 2); + dictionary.Add(5, 2); + dictionary.Add(7, 2); + dictionary.Add(9, 2); + dictionary.Add(8, 2); + dictionary.Add(13, 2); + dictionary.Add(24, 2); + dictionary.Add(6, 2); + Assert.AreEqual(dictionary.Count, 13); + + List> list = dictionary.AsLevelOrderList(); + + foreach (KeyValuePair node in list) + { + Console.WriteLine($"{node.Key} -> {node.Value}"); + } + + /* + * Tree Should Look as Follows After Rotations + * + * 4 + * 2 10 + * 1 3 7 13 + * 5 9 11 24 + * 6 8 + */ + + Assert.AreEqual(list.Count, dictionary.Count); + Assert.AreEqual(list[0].Key, 4); + Assert.AreEqual(list[1].Key, 2); + Assert.AreEqual(list[2].Key, 10); + Assert.AreEqual(list[3].Key, 1); + Assert.AreEqual(list[4].Key, 3); + Assert.AreEqual(list[5].Key, 7); + Assert.AreEqual(list[6].Key, 13); + Assert.AreEqual(list[7].Key, 5); + Assert.AreEqual(list[8].Key, 9); + Assert.AreEqual(list[9].Key, 11); + Assert.AreEqual(list[10].Key, 24); + Assert.AreEqual(list[11].Key, 6); + Assert.AreEqual(list[12].Key, 8); + + Assert.AreEqual(list[4].Value, 2); + + dictionary.Add(3, 4); + + list = dictionary.AsLevelOrderList(); + + Assert.AreEqual(list[4].Value, 4); + + + // Assure that none of the nodes locations have been modified. + Assert.AreEqual(list[0].Key, 4); + Assert.AreEqual(list[1].Key, 2); + Assert.AreEqual(list[2].Key, 10); + Assert.AreEqual(list[3].Key, 1); + Assert.AreEqual(list[4].Key, 3); + Assert.AreEqual(list[5].Key, 7); + Assert.AreEqual(list[6].Key, 13); + Assert.AreEqual(list[7].Key, 5); + Assert.AreEqual(list[8].Key, 9); + Assert.AreEqual(list[9].Key, 11); + Assert.AreEqual(list[10].Key, 24); + Assert.AreEqual(list[11].Key, 6); + Assert.AreEqual(list[12].Key, 8); + } + } +}