Memory Optimization

Quill/External/LibTessDotNet/Dict.cs

@@ -38,14 +38,19 @@ namespace LibTessDotNet
 {
     internal class Dict<TValue> where TValue : class
     {
-        public class Node
+        public class Node : Poolable
         {
             internal TValue _key;
             internal Node _prev, _next;
 
             public TValue Key { get { return _key; } }
             public Node Prev { get { return _prev; } }
             public Node Next { get { return _next; } }
+            public override void Reset()
+            {
+                // throw new System.NotImplementedException();
+                _key = null;
+            }
         }
 
         public delegate bool LessOrEqual(TValue lhs, TValue rhs);
@@ -62,6 +67,14 @@ public Dict(LessOrEqual leq)
             _head._next = _head;
         }
 
+        public void Reset()
+        {
+            var newNode = MemoryArena.Get<Node>();
+            _head = newNode;
+            _head._prev = _head;
+            _head._next = _head;
+        }
+
         public Node Insert(TValue key)
         {
             return InsertBefore(_head, key);
@@ -73,7 +86,8 @@ public Node InsertBefore(Node node, TValue key)
                 node = node._prev;
             } while (node._key != null && !_leq(node._key, key));
 
-            var newNode = new Node { _key = key };
+            var newNode = MemoryArena.Get<Node>();
+            newNode._key = key;
             newNode._next = node._next;
             node._next._prev = newNode;
             newNode._prev = node;

Quill/External/LibTessDotNet/Mesh.cs

@@ -39,16 +39,21 @@ namespace Prowl.Quill.External
 
 namespace LibTessDotNet
 {
-    internal class Mesh : MeshUtils.Pooled<Mesh>
+    internal class Mesh : Poolable
     {
         internal MeshUtils.Vertex _vHead;
         internal MeshUtils.Face _fHead;
         internal MeshUtils.Edge _eHead, _eHeadSym;
 
         public Mesh()
         {
-            var v = _vHead = MeshUtils.Vertex.Create();
-            var f = _fHead = MeshUtils.Face.Create();
+            Reset();
+        }
+
+        public override void Reset()
+        {
+            var v = _vHead = MemoryArena.Get<MeshUtils.Vertex>();
+            var f = _fHead = MemoryArena.Get<MeshUtils.Face>();
 
             var pair = MeshUtils.EdgePair.Create();
             var e = _eHead = pair._e;
@@ -82,30 +87,32 @@ public Mesh()
             eSym._activeRegion = null;
         }
 
-        public override void Reset()
-        {
-            _vHead = null;
-            _fHead = null;
-            _eHead = _eHeadSym = null;
-        }
-
         public override void OnFree()
         {
-            for (MeshUtils.Face f = _fHead._next, fNext = _fHead; f != _fHead; f = fNext)
-            {
-                fNext = f._next;
-                f.Free();
-            }
-            for (MeshUtils.Vertex v = _vHead._next, vNext = _vHead; v != _vHead; v = vNext)
-            {
-                vNext = v._next;
-                v.Free();
-            }
-            for (MeshUtils.Edge e = _eHead._next, eNext = _eHead; e != _eHead; e = eNext)
-            {
-                eNext = e._next;
-                e.Free();
-            }
+            // for (MeshUtils.Face f = _fHead._next, fNext = _fHead; f != _fHead; f = fNext)
+            // {
+            //     fNext = f._next;
+            //     f.Free();
+            // }
+            // _fHead.Free();
+            // for (MeshUtils.Vertex v = _vHead._next, vNext = _vHead; v != _vHead; v = vNext)
+            // {
+            //     vNext = v._next;
+            //     v.Free();
+            // }
+            // _vHead.Free();
+            // for (MeshUtils.Edge e = _eHead._next, eNext = _eHead; e != _eHead; e = eNext)
+            // {
+            //     eNext = e._next;
+            //     e.Free();
+            // }
+            // for (MeshUtils.Edge e = _eHeadSym._next, eNext = _eHeadSym; e != _eHeadSym; e = eNext)
+            // {
+            //     eNext = e._next;
+            //     e.Free();
+            // }
+            // _eHeadSym.Free();
+            // _eHead.Free();
         }
 
         /// <summary>
@@ -391,7 +398,7 @@ public void ZapFace(MeshUtils.Face fZap)
             fNext._prev = fPrev;
             fPrev._next = fNext;
 
-            fZap.Free();
+            // fZap.Free();
         }
 
         public void MergeConvexFaces(int maxVertsPerFace)

Quill/External/LibTessDotNet/MeshUtils.cs

@@ -108,39 +108,49 @@ public override string ToString()
         }
     }
 
-    internal static class MeshUtils
+    public abstract class Pooled<T> where T : Pooled<T>, new()
     {
-        public const int Undef = ~0;
-
-        public abstract class Pooled<T> where T : Pooled<T>, new()
+        private static Stack<T> _stack = new Stack<T>();
+        protected static int _created = 0;
+        protected static int _returned = 0;
+        protected static int _count = 0;
+        public abstract void Reset();
+        public virtual void OnFree() {}
+
+        public static void ResetCounters()
         {
-            private static Stack<T> _stack;
-
-            public abstract void Reset();
-            public virtual void OnFree() {}
+            _count = 0;
+            _created = 0;
+            _returned = 0;
+        }
 
-            public static T Create()
-            {
-                if (_stack != null && _stack.Count > 0)
-                {
-                    return _stack.Pop();
-                }
-                return new T();
-            }
+        public static T Create()
+        {
+            // if (_stack.TryPop(out T obj))
+            // {
+            //     Debug.Assert(obj != null);
+            //     return obj;
+            // }
+
+            _created++;
+            return new T(); 
+        }
 
-            public void Free()
-            {
-                OnFree();
-                Reset();
-                if (_stack == null)
-                {
-                    _stack = new Stack<T>();
-                }
-                _stack.Push((T)this);
-            }
+        public void Free()
+        {
+            OnFree();
+            Reset();
+            _stack.Push((T)this);
+            _returned++;
+            _count = _stack.Count;
         }
+    }
+
+    internal static class MeshUtils
+    {
+        public const int Undef = ~0;
 
-        public class Vertex : Pooled<Vertex>
+        public class Vertex : Poolable
         {
             internal Vertex _prev, _next;
             internal Edge _anEdge;
@@ -164,7 +174,7 @@ public override void Reset()
             }
         }
 
-        public class Face : Pooled<Face>
+        public class Face : Poolable
         {
             internal Face _prev, _next;
             internal Edge _anEdge;
@@ -204,10 +214,10 @@ public struct EdgePair
 
             public static EdgePair Create()
             {
-                var pair = new MeshUtils.EdgePair();
-                pair._e = MeshUtils.Edge.Create();
+                var pair = new EdgePair();
+                pair._e = MemoryArena.Get<Edge>();
                 pair._e._pair = pair;
-                pair._eSym = MeshUtils.Edge.Create();
+                pair._eSym = MemoryArena.Get<Edge>();
                 pair._eSym._pair = pair;
                 return pair;
             }
@@ -218,7 +228,7 @@ public void Reset()
             }
         }
 
-        public class Edge : Pooled<Edge>
+        public class Edge : Poolable
         {
             internal EdgePair _pair;
             internal Edge _next, _Sym, _Onext, _Lnext;
@@ -326,7 +336,7 @@ public static void Splice(Edge a, Edge b)
         /// </summary>
         public static void MakeVertex(Edge eOrig, Vertex vNext)
         {
-            var vNew = MeshUtils.Vertex.Create();
+            var vNew = MemoryArena.Get<Vertex>();
 
             // insert in circular doubly-linked list before vNext
             var vPrev = vNext._prev;
@@ -355,7 +365,7 @@ public static void MakeVertex(Edge eOrig, Vertex vNext)
         /// </summary>
         public static void MakeFace(Edge eOrig, Face fNext)
         {
-            var fNew = MeshUtils.Face.Create();
+            var fNew = MemoryArena.Get<Face>();
 
             // insert in circular doubly-linked list before fNext
             var fPrev = fNext._prev;
@@ -394,8 +404,6 @@ public static void KillEdge(Edge eDel)
             var ePrev = eDel._Sym._next;
             eNext._Sym._next = ePrev;
             ePrev._Sym._next = eNext;
-
-            eDel.Free();
         }
 
         /// <summary>
@@ -418,8 +426,6 @@ public static void KillVertex(Vertex vDel, Vertex newOrg)
             var vNext = vDel._next;
             vNext._prev = vPrev;
             vPrev._next = vNext;
-
-            vDel.Free();
         }
 
         /// <summary>
@@ -442,8 +448,6 @@ public static void KillFace(Face fDel, Face newLFace)
             var fNext = fDel._next;
             fNext._prev = fPrev;
             fPrev._next = fNext;
-
-            fDel.Free();
         }
 
         /// <summary>

Quill/External/LibTessDotNet/PriorityHeap.cs

@@ -32,6 +32,8 @@
 */
 
 using System;
+using System.Buffers;
+using System.Collections.Generic;
 using System.Diagnostics;
 
 namespace Prowl.Quill.External
@@ -53,6 +55,29 @@ protected class HandleElem
         {
             internal TValue _key;
             internal int _node;
+            private static Stack<HandleElem> _pool = new Stack<HandleElem>();
+
+            private void Reset()
+            {
+                _key = null;
+                _node = 0;
+            }
+
+            public static HandleElem Get()
+            {
+                if (!_pool.TryPop(out HandleElem element))
+                {
+                    element = new HandleElem();
+                }
+
+                return element;
+            }
+
+            public static void Return(HandleElem element)
+            {
+                element.Reset();
+                _pool.Push(element);
+            }
         }
 
         private LessOrEqual _leq;
@@ -68,16 +93,45 @@ public PriorityHeap(int initialSize, LessOrEqual leq)
         {
             _leq = leq;
 
-            _nodes = new int[initialSize + 1];
-            _handles = new HandleElem[initialSize + 1];
+            _nodes = ArrayPool<int>.Shared.Rent(initialSize + 1);
+            _handles = ArrayPool<HandleElem>.Shared.Rent(initialSize + 1);
 
             _size = 0;
             _max = initialSize;
             _freeList = 0;
             _initialized = false;
 
             _nodes[1] = 1;
-            _handles[1] = new HandleElem { _key = null };
+            _handles[1] = HandleElem.Get();
+        }
+
+        public void Reset(int initialSize, LessOrEqual leq)
+        {
+            _leq = leq;
+
+            if(_nodes != null) ArrayPool<int>.Shared.Return(_nodes);
+            _nodes = ArrayPool<int>.Shared.Rent(initialSize + 1);
+
+            if(_handles != null)
+            {
+                foreach (HandleElem element in _handles)
+                {
+                    if (element == null) continue;
+
+                    HandleElem.Return(element);
+                }
+
+                ArrayPool<HandleElem>.Shared.Return(_handles);
+            }
+            _handles = ArrayPool<HandleElem>.Shared.Rent(initialSize + 1);
+
+            _size = 0;
+            _max = initialSize;
+            _freeList = 0;
+            _initialized = false;
+
+            _nodes[1] = 1;
+            _handles[1] = HandleElem.Get();
         }
 
         private void FloatDown(int curr)