Memory Changes (ryubing/ryujinx!46)

See merge request ryubing/ryujinx!46

src/Ryujinx.Common/Collections/IntrusiveRedBlackTree.cs

@@ -14,12 +14,13 @@ namespace Ryujinx.Common.Collections
         /// Adds a new node into the tree.
         /// </summary>
         /// <param name="node">Node to be added</param>
+        /// <param name="parent">Node to be added under</param>
         /// <exception cref="ArgumentNullException"><paramref name="node"/> is null</exception>
-        public void Add(T node)
+        public void Add(T node, T parent = null)
         {
             ArgumentNullException.ThrowIfNull(node);
 
-            Insert(node);
+            Insert(node, parent);
         }
 
         /// <summary>
@@ -76,9 +77,11 @@ namespace Ryujinx.Common.Collections
         /// Inserts a new node into the tree.
         /// </summary>
         /// <param name="node">Node to be inserted</param>
-        private void Insert(T node)
+        /// <param name="parent">Node to be inserted under</param>
+        private void Insert(T node, T parent = null)
         {
-            T newNode = BSTInsert(node);
+            T newNode = parent != null ? InsertWithParent(node, parent) : BSTInsert(node);
+            
             RestoreBalanceAfterInsertion(newNode);
         }
 
@@ -122,10 +125,78 @@ namespace Ryujinx.Common.Collections
             else if (newNode.CompareTo(parent) < 0)
             {
                 parent.Left = newNode;
+                
+                newNode.Successor = parent;
+                
+                if (parent.Predecessor != null)
+                {
+                    newNode.Predecessor = parent.Predecessor;
+                    parent.Predecessor = newNode;
+                    newNode.Predecessor.Successor = newNode;
+                }
+                
+                parent.Predecessor = newNode;
             }
             else
             {
                 parent.Right = newNode;
+                
+                newNode.Predecessor = parent;
+                
+                if (parent.Successor != null)
+                {
+                    newNode.Successor = parent.Successor;
+                    newNode.Successor.Predecessor = newNode;
+                }
+                
+                parent.Successor = newNode;
+            }
+            Count++;
+            return newNode;
+        }
+        
+        /// <summary>
+        /// Insertion Mechanism for a Binary Search Tree (BST).
+        /// <br></br>
+        /// Inserts a new node directly under a parent node
+        /// where all children in the left subtree are less than <paramref name="newNode"/>,
+        /// and all children in the right subtree are greater than <paramref name="newNode"/>.
+        /// </summary>
+        /// <param name="newNode">Node to be inserted</param>
+        /// <param name="parent">Node to be inserted under</param>
+        /// <returns>The inserted Node</returns>
+        private T InsertWithParent(T newNode, T parent)
+        {
+            newNode.Parent = parent;
+
+            if (newNode.CompareTo(parent) < 0)
+            {
+                parent.Left = newNode;
+                
+                newNode.Successor = parent;
+                
+                if (parent.Predecessor != null)
+                {
+                    newNode.Predecessor = parent.Predecessor;
+                    parent.Predecessor = newNode;
+                    newNode.Predecessor.Successor = newNode;
+                }
+                
+                parent.Predecessor = newNode;
+            }
+            else
+            {
+                parent.Right = newNode;
+                
+                newNode.Predecessor = parent;
+                
+                if (parent.Successor != null)
+                {
+                    newNode.Successor = parent.Successor;
+                    newNode.Successor.Predecessor = newNode;
+                }
+                
+                parent.Successor = newNode;
             }
 
             Count++;
@@ -159,7 +230,7 @@ namespace Ryujinx.Common.Collections
             }
             else
             {
-                T element = Minimum(RightOf(nodeToDelete));
+                T element = nodeToDelete.Successor;
 
                 child = RightOf(element);
                 parent = ParentOf(element);
@@ -187,6 +258,9 @@ namespace Ryujinx.Common.Collections
                 element.Left = old.Left;
                 element.Right = old.Right;
                 element.Parent = old.Parent;
+                element.Predecessor = old.Predecessor;
+                if (element.Predecessor != null)
+                    element.Predecessor.Successor = element;
 
                 if (ParentOf(old) == null)
                 {
@@ -241,6 +315,11 @@ namespace Ryujinx.Common.Collections
             {
                 RestoreBalanceAfterRemoval(child);
             }
+            
+            if (old.Successor != null)
+                old.Successor.Predecessor = old.Predecessor;
+            if (old.Predecessor != null)
+                old.Predecessor.Successor = old.Successor;
 
             return old;
         }

src/Ryujinx.Common/Collections/IntrusiveRedBlackTreeNode.cs

@@ -9,8 +9,7 @@ namespace Ryujinx.Common.Collections
         public T Left;
         public T Right;
         public T Parent;
-
-        public T Predecessor => IntrusiveRedBlackTreeImpl<T>.PredecessorOf((T)this);
-        public T Successor => IntrusiveRedBlackTreeImpl<T>.SuccessorOf((T)this);
+        public T Predecessor;
+        public T Successor;
     }
 }

src/Ryujinx.Common/Collections/TreeDictionary.cs

@@ -109,7 +109,7 @@ namespace Ryujinx.Common.Collections
             Node<TKey, TValue> node = GetNode(key);
             if (node != null)
             {
-                Node<TKey, TValue> successor = SuccessorOf(node);
+                Node<TKey, TValue> successor = node.Successor;
 
                 return successor != null ? successor.Key : default;
             }
@@ -127,7 +127,7 @@ namespace Ryujinx.Common.Collections
             Node<TKey, TValue> node = GetNode(key);
             if (node != null)
             {
-                Node<TKey, TValue> predecessor = PredecessorOf(node);
+                Node<TKey, TValue> predecessor = node.Predecessor;
 
                 return predecessor != null ? predecessor.Key : default;
             }
@@ -136,11 +136,10 @@ namespace Ryujinx.Common.Collections
         }
 
         /// <summary>
-        /// Adds all the nodes in the dictionary as key/value pairs into <paramref name="list"/>.
+        /// Adds all the nodes in the dictionary as key/value pairs into a list.
         /// <br></br>
         /// The key/value pairs will be added in Level Order.
         /// </summary>
-        /// <param name="list">List to add the tree pairs into</param>
         public List<KeyValuePair<TKey, TValue>> AsLevelOrderList()
         {
             List<KeyValuePair<TKey, TValue>> list = [];
@@ -170,7 +169,7 @@ namespace Ryujinx.Common.Collections
         }
 
         /// <summary>
-        /// Adds all the nodes in the dictionary into <paramref name="list"/>.
+        /// Adds all the nodes in the dictionary into a list.
         /// </summary>
         /// <returns>A list of all KeyValuePairs sorted by Key Order</returns>
         public List<KeyValuePair<TKey, TValue>> AsList()
@@ -284,7 +283,7 @@ namespace Ryujinx.Common.Collections
             }
 
             Node<TKey, TValue> newNode = new(key, value, parent);
-            if (newNode.Parent == null)
+            if (parent == null)
             {
                 Root = newNode;
             }