Array walking optimizations in CCNode to make node by tag lookup O(logN) instead of O(N). This change gets us 1.4 seconds on 16,000 nodes for the remove test.

totallyeviljake · totallyeviljake · commit ae09da308890 · 2013-09-03T15:46:45.000-07:00
diff --git a/cocos2d/base_nodes/CCNode.cs b/cocos2d/base_nodes/CCNode.cs
@@ -99,6 +99,7 @@ public class CCNode : ICCSelectorProtocol, ICCFocusable, ICCTargetedTouchDelegat
         protected CCActionManager m_pActionManager;
         protected CCCamera m_pCamera;
         protected CCRawList<CCNode> m_pChildren;
+        private Dictionary<int, List<CCNode>> m_pChildrenByTag;
         protected CCGridBase m_pGrid;
         protected CCNode m_pParent;
         protected CCScheduler m_pScheduler;
@@ -623,10 +624,15 @@ public virtual void Update(float dt)
 
         #endregion
 
+        private bool m_bCleaned = false;
         ~CCNode()
         {
             //unregisterScriptHandler();
             Cleanup();
+            if(m_pChildren != null)
+                m_pChildren.Clear();
+            if(m_pChildrenByTag != null)
+                m_pChildrenByTag.Clear();
         }
 
         public void GetPosition(out float x, out float y)
@@ -644,6 +650,10 @@ public void SetPosition(float x, float y)
 
         public virtual void Cleanup()
         {
+            if (m_bCleaned == true)
+            {
+                return;
+            }
             // actions
             StopAllActions();
 
@@ -658,6 +668,7 @@ public virtual void Cleanup()
                     elements[i].Cleanup();
                 }
             }
+            m_bCleaned = true;
         }
 
         public CCNode GetChildByTag(int tag)
@@ -666,6 +677,18 @@ public CCNode GetChildByTag(int tag)
 
             if (m_pChildren != null && m_pChildren.count > 0)
             {
+                if (m_pChildrenByTag.ContainsKey(tag))
+                {
+                    List<CCNode> l = m_pChildrenByTag[tag];
+                    foreach (CCNode n in l)
+                    {
+                        if (n.Tag == tag)
+                        {
+                            return (n);
+                        }
+                    }
+                }
+                /*
                 CCNode[] elements = m_pChildren.Elements;
                 for (int i = 0, count = m_pChildren.count; i < count; i++)
                 {
@@ -674,6 +697,7 @@ public CCNode GetChildByTag(int tag)
                         return elements[i];
                     }
                 }
+                 */
             }
 
             return null;
@@ -701,9 +725,19 @@ public virtual void AddChild(CCNode child, int zOrder, int tag)
             {
                 m_pChildren = new CCRawList<CCNode>();
             }
+            if (m_pChildrenByTag == null)
+            {
+                m_pChildrenByTag = new Dictionary<int, List<CCNode>>();
+            }
 
             InsertChild(child, zOrder);
 
+            if (!m_pChildrenByTag.ContainsKey(tag))
+            {
+                m_pChildrenByTag[tag] = new List<CCNode>();
+            }
+            m_pChildrenByTag[tag].Add(child);
+
             child.m_nTag = tag;
             child.Parent = this;
             child.m_uOrderOfArrival = s_globalOrderOfArrival++;
@@ -740,7 +774,19 @@ public virtual void RemoveChild(CCNode child, bool cleanup)
             {
                 return;
             }
-
+            try
+            {
+                if (m_pChildrenByTag.ContainsKey(child.Tag))
+                {
+                    m_pChildrenByTag[child.Tag].Remove(child);
+                }
+            }
+            catch (Exception)
+            {
+                // Ignore this here, don't care about this exception. It likely means either
+                // a concurrent modification has occured somewhere upstream, or the child was not
+                // added to the tag list successfully.
+            }
             if (m_pChildren.Contains(child))
             {
                 DetachChild(child, cleanup);
@@ -845,6 +891,56 @@ public virtual void ReorderChild(CCNode child, int zOrder)
             child.m_uOrderOfArrival = s_globalOrderOfArrival++;
             child.m_nZOrder = zOrder;
         }
+        #region Child Sorting
+
+        // Quick sort taken from http://snipd.net/quicksort-in-c
+        public static void Quicksort(CCNode[] elements, int left, int right)
+        {
+            int i = left, j = right;
+            CCNode pivot = elements[(left + right) / 2];
+
+            while (i <= j)
+            {
+                /*
+                           (pivot.m_nZOrder < elements[i].m_nZOrder ||
+                            (pivot.m_nZOrder == elements[i].m_nZOrder && pivot.m_uOrderOfArrival < elements[i].m_uOrderOfArrival)))
+                 */
+                while ((elements[i].m_nZOrder < pivot.m_nZOrder ||
+                            (pivot.m_nZOrder == elements[i].m_nZOrder && elements[i].m_uOrderOfArrival < pivot.m_uOrderOfArrival)))
+                {
+                    i++;
+                }
+
+                while ((elements[j].m_nZOrder > pivot.m_nZOrder ||
+                            (pivot.m_nZOrder == elements[j].m_nZOrder && elements[j].m_uOrderOfArrival > pivot.m_uOrderOfArrival)))
+                {
+                    j--;
+                }
+
+                if (i <= j)
+                {
+                    // Swap
+                    CCNode tmp = elements[i];
+                    elements[i] = elements[j];
+                    elements[j] = tmp;
+
+                    i++;
+                    j--;
+                }
+            }
+
+            // Recursive calls
+            if (left < j)
+            {
+                Quicksort(elements, left, j);
+            }
+
+            if (i < right)
+            {
+                Quicksort(elements, i, right);
+            }
+        }
+
 
         public virtual void SortAllChildren()
         {
@@ -854,6 +950,8 @@ public virtual void SortAllChildren()
                 int length = m_pChildren.count;
                 CCNode[] x = m_pChildren.Elements;
 
+                Quicksort(x, 0, length-1);
+                /*
                 // insertion sort
                 for (i = 1; i < length; i++)
                 {
@@ -870,13 +968,14 @@ public virtual void SortAllChildren()
                     }
                     x[j + 1] = tempItem;
                 }
-
+                */
                 //don't need to check children recursively, that's done in visit of each child
 
                 m_bReorderChildDirty = false;
             }
         }
 
+        #endregion
         /// <summary>
         /// This is called from the Visit() method. This is where you DRAW your node. Only
         /// draw stuff from this method call.
diff --git a/cocos2d/sprite_nodes/CCSprite.cs b/cocos2d/sprite_nodes/CCSprite.cs
@@ -952,8 +952,11 @@ public override void SortAllChildren()
             {
                 int i, j, length = m_pChildren.count;
                 CCNode[] x = m_pChildren.Elements;
-                CCNode tempItem;
+//                CCNode tempItem;
 
+                CCNode.Quicksort(x, 0, length - 1);
+
+                /*
                 // insertion sort
                 for (i = 1; i < length; i++)
                 {
@@ -970,6 +973,7 @@ public override void SortAllChildren()
                     }
                     x[j + 1] = tempItem;
                 }
+                */
 
                 if (m_pobBatchNode != null)
                 {
diff --git a/cocos2d/sprite_nodes/CCSpriteBatchNode.cs b/cocos2d/sprite_nodes/CCSpriteBatchNode.cs
@@ -272,7 +272,7 @@ public override void SortAllChildren()
                 // CCNode tempItem;
                 
                 //insertion sort - change to qsort per RIQ
-                Quicksort(elements, 0, count - 1);
+                CCNode.Quicksort(elements, 0, count - 1);
 
                 /*
                 for (int i = 1; i < count; i++)
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/AddRemoveSpriteSheet.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/AddRemoveSpriteSheet.cs
@@ -49,7 +49,6 @@ public override void initWithQuantityOfNodes(int nNodes)
 
         public override void Update(float dt)
         {
-            throw new NotFiniteNumberException();
         }
 
         public virtual string profilerName()
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/AddSpriteSheet.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/AddSpriteSheet.cs
@@ -9,11 +9,16 @@ namespace tests
 {
     public class AddSpriteSheet : AddRemoveSpriteSheet
     {
+        private bool bTested = false;
+
         public override void Update(float dt)
         {
             // reset seed
             //srandom(0);
-
+            if (bTested)
+            {
+                return;
+            }
             // 15 percent
             int totalToAdd = (int)(currentQuantityOfNodes * 0.15f);
 
@@ -24,35 +29,45 @@ public override void Update(float dt)
                 int[] zs = new int[totalToAdd];
 
                 // Don't include the sprite creation time and random as part of the profiling
+                long lStart = DateTime.Now.Ticks;
                 for (int i = 0; i < totalToAdd; i++)
                 {
                     CCSprite pSprite = new CCSprite(batchNode.Texture, new CCRect(0, 0, 32, 32));
                     sprites.Add(pSprite);
                     zs[i] = (int)(CCMacros.CCRandomBetweenNegative1And1() * 50);
 
                 }
+                long ldiff = DateTime.Now.Ticks - lStart;
+                CCLog.Log("Add Sprite took {0} sec", (new TimeSpan(ldiff)).TotalSeconds);
 
                 // add them with random Z (very important!)
                 //#if CC_ENABLE_PROFILERS
                 //        CCProfilingBeginTimingBlock(_profilingTimer);
                 //#endif
 
+                lStart = DateTime.Now.Ticks;
                 for (int i = 0; i < totalToAdd; i++)
                 {
                     batchNode.AddChild((CCNode)(sprites[i]), zs[i], PerformanceNodeChildrenTest.kTagBase + i);
                 }
+                ldiff = DateTime.Now.Ticks - lStart;
+                CCLog.Log("Add Child to Batch took {0} sec", (new TimeSpan(ldiff)).TotalSeconds);
 
                 //#if CC_ENABLE_PROFILERS
                 //        CCProfilingEndTimingBlock(_profilingTimer);
                 //#endif
 
                 // remove them
+                lStart = DateTime.Now.Ticks;
                 for (int i = 0; i < totalToAdd; i++)
                 {
                     batchNode.RemoveChildByTag(PerformanceNodeChildrenTest.kTagBase + i, true);
                 }
+                ldiff = DateTime.Now.Ticks - lStart;
+                CCLog.Log("Remove Child took {0} sec", (new TimeSpan(ldiff)).TotalSeconds);
 
             }
+            bTested = true;
         }
 
         public override string title()
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/IterateSpriteSheet.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/IterateSpriteSheet.cs
@@ -50,7 +50,6 @@ public override void initWithQuantityOfNodes(int nNodes)
 
         public override void Update(float dt)
         {
-            throw new NotFiniteNumberException();
         }
 
         public virtual string profilerName()
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/IterateSpriteSheetCArray.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/IterateSpriteSheetCArray.cs
@@ -8,8 +8,10 @@ namespace tests
 {
     public class IterateSpriteSheetCArray : IterateSpriteSheet
     {
+        bool bDone = false;
         public override void Update(float dt)
         {
+            if (bDone) return;
             // iterate using fast enumeration protocol
             var pChildren = batchNode.Children;
 
@@ -26,6 +28,7 @@ public override void Update(float dt)
             //#if CC_ENABLE_PROFILERS
             //    CCProfilingEndTimingBlock(_profilingTimer);
             //#endif
+            bDone = true;
         }
 
         public override string title()
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/IterateSpriteSheetFastEnum.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/IterateSpriteSheetFastEnum.cs
@@ -8,8 +8,10 @@ namespace tests
 {
     public class IterateSpriteSheetFastEnum : IterateSpriteSheet
     {
+        bool bDone = false;
         public override void Update(float dt)
         {
+            if (bDone) return;
             // iterate using fast enumeration protocol
             var pChildren = batchNode.Children;
 
@@ -26,6 +28,7 @@ public override void Update(float dt)
             //#if CC_ENABLE_PROFILERS
             //    CCProfilingEndTimingBlock(_profilingTimer);
             //#endif
+            bDone = true;
         }
 
         public override string title()
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/PerformanceNodeChildrenTest..cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/PerformanceNodeChildrenTest..cs
@@ -16,7 +16,7 @@ public class PerformanceNodeChildrenTest
         public static int kTagBase = 20000;
         public static int TEST_COUNT = 4;
 
-        public static int kMaxNodes = 15000;
+        public static int kMaxNodes = 50000;
         public static int kNodesIncrease = 500;
 
         public static int s_nCurCase = 0;
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/RemoveSpriteSheet.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/RemoveSpriteSheet.cs
@@ -9,8 +9,11 @@ namespace tests
     public class RemoveSpriteSheet : AddRemoveSpriteSheet
     {
 
+        bool bDone = false;
         public override void Update(float dt)
         {
+
+            if (bDone) return;
             //srandom(0);
 
             // 15 percent
@@ -47,6 +50,7 @@ public override void Update(float dt)
                 //        CCProfilingEndTimingBlock(_profilingTimer);
                 //#endif
             }
+            bDone = true;
         }
 
         public override string title()
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/ReorderSpriteSheet.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/ReorderSpriteSheet.cs
@@ -8,8 +8,10 @@ namespace tests
 {
     public class ReorderSpriteSheet : AddRemoveSpriteSheet
     {
+        bool bDone = false;
         public override void Update(float dt)
         {
+            if (bDone) return;
             //srandom(0);
 
             // 15 percent
@@ -55,6 +57,7 @@ public override void Update(float dt)
                     batchNode.RemoveChildByTag(PerformanceNodeChildrenTest.kTagBase + i, true);
                 }
             }
+            bDone = true;
         }
 
         public override string title()

Original file line number	Diff line number	Diff line change
`@@ -952,8 +952,11 @@ public override void SortAllChildren()`
`952`	`952`	`{`
`953`	`953`	`int i, j, length = m_pChildren.count;`
`954`	`954`	`CCNode[] x = m_pChildren.Elements;`
`955`		`- CCNode tempItem;`
	`955`	`+// CCNode tempItem;`
`956`	`956`
	`957`	`+ CCNode.Quicksort(x, 0, length - 1);`
	`958`	`+`
	`959`	`+ /*`
`957`	`960`	`// insertion sort`
`958`	`961`	`for (i = 1; i < length; i++)`
`959`	`962`	`{`
`@@ -970,6 +973,7 @@ public override void SortAllChildren()`
`970`	`973`	`}`
`971`	`974`	`x[j + 1] = tempItem;`
`972`	`975`	`}`
	`976`	`+ */`
`973`	`977`
`974`	`978`	`if (m_pobBatchNode != null)`
`975`	`979`	`{`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,6 @@ public override void initWithQuantityOfNodes(int nNodes)`
`49`	`49`
`50`	`50`	`public override void Update(float dt)`
`51`	`51`	`{`
`52`		`- throw new NotFiniteNumberException();`
`53`	`52`	`}`
`54`	`53`
`55`	`54`	`public virtual string profilerName()`
Original file line number	Diff line number	Diff line change
`@@ -9,11 +9,16 @@ namespace tests`
`9`	`9`	`{`
`10`	`10`	`public class AddSpriteSheet : AddRemoveSpriteSheet`
`11`	`11`	`{`
	`12`	`+ private bool bTested = false;`
	`13`	`+`
`12`	`14`	`public override void Update(float dt)`
`13`	`15`	`{`
`14`	`16`	`// reset seed`
`15`	`17`	`//srandom(0);`
`16`		`-`
	`18`	`+ if (bTested)`
	`19`	`+ {`
	`20`	`+ return;`
	`21`	`+ }`
`17`	`22`	`// 15 percent`
`18`	`23`	`int totalToAdd = (int)(currentQuantityOfNodes * 0.15f);`
`19`	`24`
`@@ -24,35 +29,45 @@ public override void Update(float dt)`
`24`	`29`	`int[] zs = new int[totalToAdd];`
`25`	`30`
`26`	`31`	`// Don't include the sprite creation time and random as part of the profiling`
	`32`	`+ long lStart = DateTime.Now.Ticks;`
`27`	`33`	`for (int i = 0; i < totalToAdd; i++)`
`28`	`34`	`{`
`29`	`35`	`CCSprite pSprite = new CCSprite(batchNode.Texture, new CCRect(0, 0, 32, 32));`
`30`	`36`	`sprites.Add(pSprite);`
`31`	`37`	`zs[i] = (int)(CCMacros.CCRandomBetweenNegative1And1() * 50);`
`32`	`38`
`33`	`39`	`}`
	`40`	`+ long ldiff = DateTime.Now.Ticks - lStart;`
	`41`	`+ CCLog.Log("Add Sprite took {0} sec", (new TimeSpan(ldiff)).TotalSeconds);`
`34`	`42`
`35`	`43`	`// add them with random Z (very important!)`
`36`	`44`	`//#if CC_ENABLE_PROFILERS`
`37`	`45`	`// CCProfilingBeginTimingBlock(_profilingTimer);`
`38`	`46`	`//#endif`
`39`	`47`
	`48`	`+ lStart = DateTime.Now.Ticks;`
`40`	`49`	`for (int i = 0; i < totalToAdd; i++)`
`41`	`50`	`{`
`42`	`51`	`batchNode.AddChild((CCNode)(sprites[i]), zs[i], PerformanceNodeChildrenTest.kTagBase + i);`
`43`	`52`	`}`
	`53`	`+ ldiff = DateTime.Now.Ticks - lStart;`
	`54`	`+ CCLog.Log("Add Child to Batch took {0} sec", (new TimeSpan(ldiff)).TotalSeconds);`
`44`	`55`
`45`	`56`	`//#if CC_ENABLE_PROFILERS`
`46`	`57`	`// CCProfilingEndTimingBlock(_profilingTimer);`
`47`	`58`	`//#endif`
`48`	`59`
`49`	`60`	`// remove them`
	`61`	`+ lStart = DateTime.Now.Ticks;`
`50`	`62`	`for (int i = 0; i < totalToAdd; i++)`
`51`	`63`	`{`
`52`	`64`	`batchNode.RemoveChildByTag(PerformanceNodeChildrenTest.kTagBase + i, true);`
`53`	`65`	`}`
	`66`	`+ ldiff = DateTime.Now.Ticks - lStart;`
	`67`	`+ CCLog.Log("Remove Child took {0} sec", (new TimeSpan(ldiff)).TotalSeconds);`
`54`	`68`
`55`	`69`	`}`
	`70`	`+ bTested = true;`
`56`	`71`	`}`
`57`	`72`
`58`	`73`	`public override string title()`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,6 @@ public override void initWithQuantityOfNodes(int nNodes)`
`50`	`50`
`51`	`51`	`public override void Update(float dt)`
`52`	`52`	`{`
`53`		`- throw new NotFiniteNumberException();`
`54`	`53`	`}`
`55`	`54`
`56`	`55`	`public virtual string profilerName()`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,10 @@ namespace tests`
`8`	`8`	`{`
`9`	`9`	`public class IterateSpriteSheetCArray : IterateSpriteSheet`
`10`	`10`	`{`
	`11`	`+ bool bDone = false;`
`11`	`12`	`public override void Update(float dt)`
`12`	`13`	`{`
	`14`	`+ if (bDone) return;`
`13`	`15`	`// iterate using fast enumeration protocol`
`14`	`16`	`var pChildren = batchNode.Children;`
`15`	`17`
`@@ -26,6 +28,7 @@ public override void Update(float dt)`
`26`	`28`	`//#if CC_ENABLE_PROFILERS`
`27`	`29`	`// CCProfilingEndTimingBlock(_profilingTimer);`
`28`	`30`	`//#endif`
	`31`	`+ bDone = true;`
`29`	`32`	`}`
`30`	`33`
`31`	`34`	`public override string title()`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,10 @@ namespace tests`
`8`	`8`	`{`
`9`	`9`	`public class IterateSpriteSheetFastEnum : IterateSpriteSheet`
`10`	`10`	`{`
	`11`	`+ bool bDone = false;`
`11`	`12`	`public override void Update(float dt)`
`12`	`13`	`{`
	`14`	`+ if (bDone) return;`
`13`	`15`	`// iterate using fast enumeration protocol`
`14`	`16`	`var pChildren = batchNode.Children;`
`15`	`17`
`@@ -26,6 +28,7 @@ public override void Update(float dt)`
`26`	`28`	`//#if CC_ENABLE_PROFILERS`
`27`	`29`	`// CCProfilingEndTimingBlock(_profilingTimer);`
`28`	`30`	`//#endif`
	`31`	`+ bDone = true;`
`29`	`32`	`}`
`30`	`33`
`31`	`34`	`public override string title()`
Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,11 @@ namespace tests`
`9`	`9`	`public class RemoveSpriteSheet : AddRemoveSpriteSheet`
`10`	`10`	`{`
`11`	`11`
	`12`	`+ bool bDone = false;`
`12`	`13`	`public override void Update(float dt)`
`13`	`14`	`{`
	`15`	`+`
	`16`	`+ if (bDone) return;`
`14`	`17`	`//srandom(0);`
`15`	`18`
`16`	`19`	`// 15 percent`
`@@ -47,6 +50,7 @@ public override void Update(float dt)`
`47`	`50`	`// CCProfilingEndTimingBlock(_profilingTimer);`
`48`	`51`	`//#endif`
`49`	`52`	`}`
	`53`	`+ bDone = true;`
`50`	`54`	`}`
`51`	`55`
`52`	`56`	`public override string title()`