Pool more types (fixes #31).

speps · speps · commit 0f7cf440d179 · 2021-03-17T16:36:14.000Z
diff --git a/LibTessDotNet/Sources/Dict.cs b/LibTessDotNet/Sources/Dict.cs
@@ -39,30 +39,58 @@ namespace LibTessDotNet
 {
     internal class Dict<TValue> where TValue : class
     {
-        public class Node
+        public class Node : Pooled<Node>
         {
             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 void Init(IPool pool)
+            {
+                _key = null;
+                _prev = null;
+                _next = null;
+            }
+
+            public void Reset(IPool pool)
+            {
+                _key = null;
+                _prev = null;
+                _next = null;
+            }
         }
 
         public delegate bool LessOrEqual(TValue lhs, TValue rhs);
 
+        private IPool _pool;
         private LessOrEqual _leq;
         Node _head;
 
-        public Dict(LessOrEqual leq)
+        public bool Empty { get { return _head._next == _head; } }
+
+        public Dict(IPool pool, LessOrEqual leq)
         {
+            _pool = pool;
             _leq = leq;
 
-            _head = new Node { _key = null };
+            Init();
+        }
+
+        public void Init()
+        {
+            _head = _pool.Get<Node>();
             _head._prev = _head;
             _head._next = _head;
         }
 
+        public void Reset()
+        {
+            _pool.Return(ref _head);
+        }
+
         public Node Insert(TValue key)
         {
             return InsertBefore(_head, key);
@@ -74,7 +102,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 = _pool.Get<Node>();
+            newNode._key = key;
             newNode._next = node._next;
             node._next._prev = newNode;
             newNode._prev = node;
@@ -101,6 +130,7 @@ public void Remove(Node node)
         {
             node._next._prev = node._prev;
             node._prev._next = node._next;
+            _pool.Return(ref node);
         }
     }
 }
diff --git a/LibTessDotNet/Sources/Mesh.cs b/LibTessDotNet/Sources/Mesh.cs
@@ -87,18 +87,18 @@ public void Reset(IPool pool)
             for (MeshUtils.Face f = _fHead, fNext = _fHead; f._next != null; f = fNext)
             {
                 fNext = f._next;
-                pool.Return(f);
+                pool.Return(ref f);
             }
             for (MeshUtils.Vertex v = _vHead, vNext = _vHead; v._next != null; v = vNext)
             {
                 vNext = v._next;
-                pool.Return(v);
+                pool.Return(ref v);
             }
             for (MeshUtils.Edge e = _eHead, eNext = _eHead; e._next != null; e = eNext)
             {
                 eNext = e._next;
-                pool.Return(e._Sym);
-                pool.Return(e);
+                pool.Return(ref e._Sym);
+                pool.Return(ref e);
             }
             
             _vHead = null;
@@ -389,7 +389,7 @@ public void ZapFace(IPool pool, MeshUtils.Face fZap)
             fNext._prev = fPrev;
             fPrev._next = fNext;
 
-            pool.Return(fZap);
+            pool.Return(ref fZap);
         }
 
         public void MergeConvexFaces(IPool pool, int maxVertsPerFace)
diff --git a/LibTessDotNet/Sources/MeshUtils.cs b/LibTessDotNet/Sources/MeshUtils.cs
@@ -127,9 +127,7 @@ public interface ITypePool
     {
         private Queue<T> _pool = new Queue<T>();
 
-        private static readonly Func<T> OptimizedInstantiator = Expression.Lambda<Func<T>>(
-                Expression.New(typeof(T))
-            ).Compile();
+        private static readonly Func<T> Creator = Expression.Lambda<Func<T>>(Expression.New(typeof(T))).Compile();
 
         public object Get()
         {
@@ -140,7 +138,7 @@ public object Get()
                     return _pool.Dequeue();
                 }
             }
-            return OptimizedInstantiator.Invoke();
+            return Creator();
         }
 
         public void Return(object obj)
@@ -165,14 +163,16 @@ public abstract class IPool
     {
         public IPool()
         {
+            Register<Mesh>(new DefaultTypePool<Mesh>());
             Register<MeshUtils.Vertex>(new DefaultTypePool<MeshUtils.Vertex>());
             Register<MeshUtils.Face>(new DefaultTypePool<MeshUtils.Face>());
             Register<MeshUtils.Edge>(new DefaultTypePool<MeshUtils.Edge>());
             Register<Tess.ActiveRegion>(new DefaultTypePool<Tess.ActiveRegion>());
+            Register<Dict<Tess.ActiveRegion>.Node>(new DefaultTypePool<Dict<Tess.ActiveRegion>.Node>());
         }
         public abstract void Register<T>(ITypePool typePool) where T : class, Pooled<T>, new();
         public abstract T Get<T>() where T : class, Pooled<T>, new();
-        public abstract void Return<T>(T obj) where T : class, Pooled<T>, new();
+        public abstract void Return<T>(ref T obj) where T : class, Pooled<T>, new();
     }
 
     public class NullPool : IPool
@@ -188,8 +188,9 @@ public override void Register<T>(ITypePool typePool)
         {
         }
 
-        public override void Return<T>(T obj)
+        public override void Return<T>(ref T obj)
         {
+            obj = null;
         }
     }
 
@@ -217,13 +218,13 @@ public override T Get<T>()
             }
             if (obj == null)
             {
-                obj = new T();
+                throw new InvalidOperationException("Type not registered with type tool");
             }
             obj.Init(this);
             return obj;
         }
 
-        public override void Return<T>(T obj)
+        public override void Return<T>(ref T obj)
         {
             if (obj == null)
             {
@@ -235,6 +236,7 @@ public override void Return<T>(T obj)
             {
                 typePool.Return(obj);
             }
+            obj = null;
         }
     }
 
@@ -514,8 +516,8 @@ public static void KillEdge(IPool pool, Edge eDel)
             eNext._Sym._next = ePrev;
             ePrev._Sym._next = eNext;
 
-            pool.Return(eDel._Sym);
-            pool.Return(eDel);
+            pool.Return(ref eDel._Sym);
+            pool.Return(ref eDel);
         }
 
         /// <summary>
@@ -539,7 +541,7 @@ public static void KillVertex(IPool pool, Vertex vDel, Vertex newOrg)
             vNext._prev = vPrev;
             vPrev._next = vNext;
 
-            pool.Return(vDel);
+            pool.Return(ref vDel);
         }
 
         /// <summary>
@@ -563,7 +565,7 @@ public static void KillFace(IPool pool, Face fDel, Face newLFace)
             fNext._prev = fPrev;
             fPrev._next = fNext;
 
-            pool.Return(fDel);
+            pool.Return(ref fDel);
         }
 
         /// <summary>
diff --git a/LibTessDotNet/Sources/PriorityHeap.cs b/LibTessDotNet/Sources/PriorityHeap.cs
@@ -50,7 +50,7 @@ internal class PriorityHeap<TValue> where TValue : class
     {
         public delegate bool LessOrEqual(TValue lhs, TValue rhs);
 
-        protected class HandleElem
+        internal class HandleElem
         {
             internal TValue _key;
             internal int _node;
@@ -78,7 +78,7 @@ public PriorityHeap(int initialSize, LessOrEqual leq)
             _initialized = false;
 
             _nodes[1] = 1;
-            _handles[1] = new HandleElem { _key = null };
+            _handles[1] = new HandleElem();
         }
 
         private void FloatDown(int curr)
diff --git a/LibTessDotNet/Sources/PriorityQueue.cs b/LibTessDotNet/Sources/PriorityQueue.cs
@@ -65,7 +65,7 @@ public PriorityQueue(int initialSize, PriorityHeap<TValue>.LessOrEqual leq)
             _initialized = false;
         }
 
-        class StackItem
+        struct StackItem
         {
             internal int p, r;
         };
diff --git a/LibTessDotNet/Sources/Sweep.cs b/LibTessDotNet/Sources/Sweep.cs
@@ -58,7 +58,7 @@ public void Init(IPool pool)
             public void Reset(IPool pool)
             {
                 _eUp = null;
-                _nodeUp = null;
+                _nodeUp = null; // don't return to pool as Dict takes care of that
                 _windingNumber = 0;
                 _inside = false;
                 _sentinel = false;
@@ -129,7 +129,7 @@ private void DeleteRegion(ActiveRegion reg)
             }
             reg._eUp._activeRegion = null;
             _dict.Remove(reg._nodeUp);
-            _pool.Return(reg);
+            _pool.Return(ref reg);
         }
 
         /// <summary>
@@ -609,7 +609,7 @@ private bool CheckForIntersect(ActiveRegion regUp)
             {
                 // Easy case -- intersection at one of the right endpoints
                 CheckForRightSplice(regUp);
-                _pool.Return(isect);
+                _pool.Return(ref isect);
                 return false;
             }
 
@@ -630,7 +630,7 @@ private bool CheckForIntersect(ActiveRegion regUp)
                     eUp = RegionBelow(regUp)._eUp;
                     FinishLeftRegions(RegionBelow(regUp), regLo);
                     AddRightEdges(regUp, eUp._Oprev, eUp, eUp, true);
-                    _pool.Return(isect);
+                    _pool.Return(ref isect);
                     return true;
                 }
                 if( dstUp == _event ) {
@@ -643,7 +643,7 @@ private bool CheckForIntersect(ActiveRegion regUp)
                     regLo._eUp = eLo._Oprev;
                     eLo = FinishLeftRegions(regLo, null);
                     AddRightEdges(regUp, eLo._Onext, eUp._Rprev, e, true);
-                    _pool.Return(isect);
+                    _pool.Return(ref isect);
                     return true;
                 }
                 // Special case: called from ConnectRightVertex. If either
@@ -664,7 +664,7 @@ private bool CheckForIntersect(ActiveRegion regUp)
                     eLo._Org._t = _event._t;
                 }
                 // leave the rest for ConnectRightVertex
-                _pool.Return(isect);
+                _pool.Return(ref isect);
                 return false;
             }
 
@@ -680,7 +680,7 @@ private bool CheckForIntersect(ActiveRegion regUp)
             _mesh.Splice(_pool, eLo._Oprev, eUp);
             eUp._Org._s = isect._s;
             eUp._Org._t = isect._t;
-            _pool.Return(isect);
+            _pool.Return(ref isect);
             isect = null;
             eUp._Org._pqHandle = _pq.Insert(eUp._Org);
             if (eUp._Org._pqHandle._handle == PQHandle.Invalid)
@@ -933,7 +933,7 @@ private void ConnectLeftVertex(MeshUtils.Vertex vEvent)
             // Get a pointer to the active region containing vEvent
             tmp._eUp = vEvent._anEdge._Sym;
             var regUp = _dict.Find(tmp).Key;
-            _pool.Return(tmp);
+            _pool.Return(ref tmp);
             var regLo = RegionBelow(regUp);
             if (regLo == null)
             {
@@ -1064,7 +1064,14 @@ private void AddSentinel(Real smin, Real smax, Real t)
         /// </summary>
         private void InitEdgeDict()
         {
-            _dict = new Dict<ActiveRegion>(EdgeLeq);
+            if (_dict == null)
+            {
+                _dict = new Dict<ActiveRegion>(_pool, EdgeLeq);
+            }
+            else
+            {
+                _dict.Init();
+            }
 
             AddSentinel(-SentinelCoord, SentinelCoord, -SentinelCoord);
             AddSentinel(-SentinelCoord, SentinelCoord, +SentinelCoord);
@@ -1089,7 +1096,8 @@ private void DoneEdgeDict()
                 DeleteRegion(reg);
             }
 
-            _dict = null;
+            Debug.Assert(_dict.Empty);
+            _dict.Reset();
         }
 
         /// <summary>
@@ -1149,8 +1157,11 @@ private void InitPriorityQ()
             }
             // Make sure there is enough space for sentinels.
             vertexCount += 8;
-    
-            _pq = new PriorityQueue<MeshUtils.Vertex>(vertexCount, Geom.VertLeq);
+
+            if (_pq == null)
+            {
+                _pq = new PriorityQueue<MeshUtils.Vertex>(vertexCount, Geom.VertLeq);
+            }
 
             vHead = _mesh._vHead;
             for( v = vHead._next; v != vHead; v = v._next ) {
@@ -1165,7 +1176,7 @@ private void InitPriorityQ()
 
         private void DonePriorityQ()
         {
-            _pq = null;
+            Debug.Assert(_pq.Empty);
         }
 
         /// <summary>
diff --git a/LibTessDotNet/Sources/Tess.cs b/LibTessDotNet/Sources/Tess.cs
@@ -199,15 +199,16 @@ public Tess()
         }
         public Tess(IPool pool)
         {
+            if (pool == null)
+            {
+                throw new ArgumentNullException("pool");
+            }
+
             _normal = Vec3.Zero;
             _bminX = _bminY = _bmaxX = _bmaxY = 0;
 
             _windingRule = WindingRule.EvenOdd;
             _pool = pool;
-            if (_pool == null)
-            {
-                _pool = new NullPool();
-            }
             _mesh = null;
 
             _vertices = null;
@@ -845,8 +846,7 @@ public void Tessellate(WindingRule windingRule = WindingRule.EvenOdd, ElementTyp
                 OutputPolymesh(elementType, polySize);
             }
 
-            _pool.Return(_mesh);
-            _mesh = null;
+            _pool.Return(ref _mesh);
         }
     }
 }
diff --git a/TessBed/UnitTests.cs b/TessBed/UnitTests.cs

Original file line number	Diff line number	Diff line change
`@@ -87,18 +87,18 @@ public void Reset(IPool pool)`
`87`	`87`	`for (MeshUtils.Face f = _fHead, fNext = _fHead; f._next != null; f = fNext)`
`88`	`88`	`{`
`89`	`89`	`fNext = f._next;`
`90`		`- pool.Return(f);`
	`90`	`+ pool.Return(ref f);`
`91`	`91`	`}`
`92`	`92`	`for (MeshUtils.Vertex v = _vHead, vNext = _vHead; v._next != null; v = vNext)`
`93`	`93`	`{`
`94`	`94`	`vNext = v._next;`
`95`		`- pool.Return(v);`
	`95`	`+ pool.Return(ref v);`
`96`	`96`	`}`
`97`	`97`	`for (MeshUtils.Edge e = _eHead, eNext = _eHead; e._next != null; e = eNext)`
`98`	`98`	`{`
`99`	`99`	`eNext = e._next;`
`100`		`- pool.Return(e._Sym);`
`101`		`- pool.Return(e);`
	`100`	`+ pool.Return(ref e._Sym);`
	`101`	`+ pool.Return(ref e);`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`_vHead = null;`
`@@ -389,7 +389,7 @@ public void ZapFace(IPool pool, MeshUtils.Face fZap)`
`389`	`389`	`fNext._prev = fPrev;`
`390`	`390`	`fPrev._next = fNext;`
`391`	`391`
`392`		`- pool.Return(fZap);`
	`392`	`+ pool.Return(ref fZap);`
`393`	`393`	`}`
`394`	`394`
`395`	`395`	`public void MergeConvexFaces(IPool pool, int maxVertsPerFace)`
Original file line number	Diff line number	Diff line change
`@@ -127,9 +127,7 @@ public interface ITypePool`
`127`	`127`	`{`
`128`	`128`	`private Queue<T> _pool = new Queue<T>();`
`129`	`129`
`130`		`- private static readonly Func<T> OptimizedInstantiator = Expression.Lambda<Func<T>>(`
`131`		`- Expression.New(typeof(T))`
`132`		`- ).Compile();`
	`130`	`+ private static readonly Func<T> Creator = Expression.Lambda<Func<T>>(Expression.New(typeof(T))).Compile();`
`133`	`131`
`134`	`132`	`public object Get()`
`135`	`133`	`{`
`@@ -140,7 +138,7 @@ public object Get()`
`140`	`138`	`return _pool.Dequeue();`
`141`	`139`	`}`
`142`	`140`	`}`
`143`		`- return OptimizedInstantiator.Invoke();`
	`141`	`+ return Creator();`
`144`	`142`	`}`
`145`	`143`
`146`	`144`	`public void Return(object obj)`
`@@ -165,14 +163,16 @@ public abstract class IPool`
`165`	`163`	`{`
`166`	`164`	`public IPool()`
`167`	`165`	`{`
	`166`	`+ Register<Mesh>(new DefaultTypePool<Mesh>());`
`168`	`167`	`Register<MeshUtils.Vertex>(new DefaultTypePool<MeshUtils.Vertex>());`
`169`	`168`	`Register<MeshUtils.Face>(new DefaultTypePool<MeshUtils.Face>());`
`170`	`169`	`Register<MeshUtils.Edge>(new DefaultTypePool<MeshUtils.Edge>());`
`171`	`170`	`Register<Tess.ActiveRegion>(new DefaultTypePool<Tess.ActiveRegion>());`
	`171`	`+ Register<Dict<Tess.ActiveRegion>.Node>(new DefaultTypePool<Dict<Tess.ActiveRegion>.Node>());`
`172`	`172`	`}`
`173`	`173`	`public abstract void Register<T>(ITypePool typePool) where T : class, Pooled<T>, new();`
`174`	`174`	`public abstract T Get<T>() where T : class, Pooled<T>, new();`
`175`		`- public abstract void Return<T>(T obj) where T : class, Pooled<T>, new();`
	`175`	`+ public abstract void Return<T>(ref T obj) where T : class, Pooled<T>, new();`
`176`	`176`	`}`
`177`	`177`
`178`	`178`	`public class NullPool : IPool`
`@@ -188,8 +188,9 @@ public override void Register<T>(ITypePool typePool)`
`188`	`188`	`{`
`189`	`189`	`}`
`190`	`190`
`191`		`- public override void Return<T>(T obj)`
	`191`	`+ public override void Return<T>(ref T obj)`
`192`	`192`	`{`
	`193`	`+ obj = null;`
`193`	`194`	`}`
`194`	`195`	`}`
`195`	`196`
`@@ -217,13 +218,13 @@ public override T Get<T>()`
`217`	`218`	`}`
`218`	`219`	`if (obj == null)`
`219`	`220`	`{`
`220`		`- obj = new T();`
	`221`	`+ throw new InvalidOperationException("Type not registered with type tool");`
`221`	`222`	`}`
`222`	`223`	`obj.Init(this);`
`223`	`224`	`return obj;`
`224`	`225`	`}`
`225`	`226`
`226`		`- public override void Return<T>(T obj)`
	`227`	`+ public override void Return<T>(ref T obj)`
`227`	`228`	`{`
`228`	`229`	`if (obj == null)`
`229`	`230`	`{`
`@@ -235,6 +236,7 @@ public override void Return<T>(T obj)`
`235`	`236`	`{`
`236`	`237`	`typePool.Return(obj);`
`237`	`238`	`}`
	`239`	`+ obj = null;`
`238`	`240`	`}`
`239`	`241`	`}`
`240`	`242`
`@@ -514,8 +516,8 @@ public static void KillEdge(IPool pool, Edge eDel)`
`514`	`516`	`eNext._Sym._next = ePrev;`
`515`	`517`	`ePrev._Sym._next = eNext;`
`516`	`518`
`517`		`- pool.Return(eDel._Sym);`
`518`		`- pool.Return(eDel);`
	`519`	`+ pool.Return(ref eDel._Sym);`
	`520`	`+ pool.Return(ref eDel);`
`519`	`521`	`}`
`520`	`522`
`521`	`523`	`/// <summary>`
`@@ -539,7 +541,7 @@ public static void KillVertex(IPool pool, Vertex vDel, Vertex newOrg)`
`539`	`541`	`vNext._prev = vPrev;`
`540`	`542`	`vPrev._next = vNext;`
`541`	`543`
`542`		`- pool.Return(vDel);`
	`544`	`+ pool.Return(ref vDel);`
`543`	`545`	`}`
`544`	`546`
`545`	`547`	`/// <summary>`
`@@ -563,7 +565,7 @@ public static void KillFace(IPool pool, Face fDel, Face newLFace)`
`563`	`565`	`fNext._prev = fPrev;`
`564`	`566`	`fPrev._next = fNext;`
`565`	`567`
`566`		`- pool.Return(fDel);`
	`568`	`+ pool.Return(ref fDel);`
`567`	`569`	`}`
`568`	`570`
`569`	`571`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ internal class PriorityHeap<TValue> where TValue : class`
`50`	`50`	`{`
`51`	`51`	`public delegate bool LessOrEqual(TValue lhs, TValue rhs);`
`52`	`52`
`53`		`- protected class HandleElem`
	`53`	`+ internal class HandleElem`
`54`	`54`	`{`
`55`	`55`	`internal TValue _key;`
`56`	`56`	`internal int _node;`
`@@ -78,7 +78,7 @@ public PriorityHeap(int initialSize, LessOrEqual leq)`
`78`	`78`	`_initialized = false;`
`79`	`79`
`80`	`80`	`_nodes[1] = 1;`
`81`		`- _handles[1] = new HandleElem { _key = null };`
	`81`	`+ _handles[1] = new HandleElem();`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`private void FloatDown(int curr)`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public PriorityQueue(int initialSize, PriorityHeap<TValue>.LessOrEqual leq)`
`65`	`65`	`_initialized = false;`
`66`	`66`	`}`
`67`	`67`
`68`		`- class StackItem`
	`68`	`+ struct StackItem`
`69`	`69`	`{`
`70`	`70`	`internal int p, r;`
`71`	`71`	`};`
Original file line number	Diff line number	Diff line change
`@@ -199,15 +199,16 @@ public Tess()`
`199`	`199`	`}`
`200`	`200`	`public Tess(IPool pool)`
`201`	`201`	`{`
	`202`	`+ if (pool == null)`
	`203`	`+ {`
	`204`	`+ throw new ArgumentNullException("pool");`
	`205`	`+ }`
	`206`	`+`
`202`	`207`	`_normal = Vec3.Zero;`
`203`	`208`	`_bminX = _bminY = _bmaxX = _bmaxY = 0;`
`204`	`209`
`205`	`210`	`_windingRule = WindingRule.EvenOdd;`
`206`	`211`	`_pool = pool;`
`207`		`- if (_pool == null)`
`208`		`- {`
`209`		`- _pool = new NullPool();`
`210`		`- }`
`211`	`212`	`_mesh = null;`
`212`	`213`
`213`	`214`	`_vertices = null;`
`@@ -845,8 +846,7 @@ public void Tessellate(WindingRule windingRule = WindingRule.EvenOdd, ElementTyp`
`845`	`846`	`OutputPolymesh(elementType, polySize);`
`846`	`847`	`}`
`847`	`848`
`848`		`- _pool.Return(_mesh);`
`849`		`- _mesh = null;`
	`849`	`+ _pool.Return(ref _mesh);`
`850`	`850`	`}`
`851`	`851`	`}`
`852`	`852`	`}`