added performance output for the node performance tests.

totallyeviljake · totallyeviljake · commit 7af8f6f17790 · 2013-09-03T16:37:09.000-07:00
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/AddRemoveSpriteSheet.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/AddRemoveSpriteSheet.cs
@@ -9,29 +9,34 @@ namespace tests
 {
     public class AddRemoveSpriteSheet : NodeChildrenMainScene
     {
+
         public override void updateQuantityOfNodes()
         {
             CCSize s = CCDirector.SharedDirector.WinSize;
 
             // increase nodes
             if (currentQuantityOfNodes < quantityOfNodes)
             {
+                StartTimer();
                 for (int i = 0; i < (quantityOfNodes - currentQuantityOfNodes); i++)
                 {
                     CCSprite sprite = new CCSprite(batchNode.Texture, new CCRect(0, 0, 32, 32));
                     batchNode.AddChild(sprite);
                     sprite.Position = new CCPoint(CCRandom.Next() * s.Width, CCRandom.Next() * s.Height);
                     sprite.Visible = false;
                 }
+                EndTimer("Current Quantity: add");
             }
             // decrease nodes
             else if (currentQuantityOfNodes > quantityOfNodes)
             {
+                StartTimer();
                 for (int i = 0; i < (currentQuantityOfNodes - quantityOfNodes); i++)
                 {
                     int index = currentQuantityOfNodes - i - 1;
                     batchNode.RemoveChildAtIndex(index, true);
                 }
+                EndTimer("Current Quantity: add");
             }
 
             currentQuantityOfNodes = quantityOfNodes;
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/IterateSpriteSheet.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/IterateSpriteSheet.cs
@@ -17,6 +17,7 @@ public override void updateQuantityOfNodes()
             // increase nodes
             if (currentQuantityOfNodes < quantityOfNodes)
             {
+                StartTimer();
                 for (int i = 0; i < (quantityOfNodes - currentQuantityOfNodes); i++)
                 {
                     CCSprite sprite = new CCSprite(batchNode.Texture, new CCRect(0, 0, 32, 32));
@@ -28,6 +29,7 @@ public override void updateQuantityOfNodes()
             // decrease nodes
             else if (currentQuantityOfNodes > quantityOfNodes)
             {
+                StartTimer();
                 for (int i = 0; i < (currentQuantityOfNodes - quantityOfNodes); i++)
                 {
                     int index = currentQuantityOfNodes - i - 1;
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/IterateSpriteSheetCArray.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/IterateSpriteSheetCArray.cs
@@ -19,11 +19,13 @@ public override void Update(float dt)
             //    CCProfilingBeginTimingBlock(_profilingTimer);
             //#endif
 
+            StartTimer();
             foreach (var pObject in pChildren)
             {
                 CCSprite pSprite = (CCSprite)pObject;
                 pSprite.Visible = false;
             }
+            EndTimer("Visible change array walk");
 
             //#if CC_ENABLE_PROFILERS
             //    CCProfilingEndTimingBlock(_profilingTimer);
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/IterateSpriteSheetFastEnum.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/IterateSpriteSheetFastEnum.cs
@@ -19,11 +19,13 @@ public override void Update(float dt)
             //    CCProfilingBeginTimingBlock(_profilingTimer);
             //#endif
 
+            StartTimer();
             foreach (var pObject in pChildren)
             {
                 CCSprite pSprite = (CCSprite)pObject;
                 pSprite.Visible = false;
             }
+            EndTimer("Set visible array walk");
 
             //#if CC_ENABLE_PROFILERS
             //    CCProfilingEndTimingBlock(_profilingTimer);
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/NodeChildrenMainScene.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/NodeChildrenMainScene.cs
@@ -8,6 +8,20 @@ namespace tests
 {
     public abstract class NodeChildrenMainScene : CCScene
     {
+        long lStart;
+
+        protected void StartTimer()
+        {
+            lStart = DateTime.Now.Ticks;
+        }
+
+        protected void EndTimer(string msg)
+        {
+            long diff = DateTime.Now.Ticks - lStart;
+            TimeSpan ts = new TimeSpan(diff);
+            CCLog.Log("{0} took {1} s, or {2} ms", msg, ts.TotalSeconds, ts.TotalMilliseconds);
+        }
+
         public virtual void initWithQuantityOfNodes(int nNodes)
         {
             //srand(time());
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/RemoveSpriteSheet.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/RemoveSpriteSheet.cs
@@ -24,27 +24,33 @@ public override void Update(float dt)
                 List<CCSprite> sprites = new List<CCSprite>();
 
                 // Don't include the sprite creation time as part of the profiling
+                StartTimer();
                 for (int i = 0; i < totalToAdd; i++)
                 {
                     CCSprite pSprite = new CCSprite(batchNode.Texture, new CCRect(0, 0, 32, 32));
                     sprites.Add(pSprite);
                 }
+                EndTimer("Add " + totalToAdd + " sprites");
 
                 // add them with random Z (very important!)
+                StartTimer();
                 for (int i = 0; i < totalToAdd; i++)
                 {
                     batchNode.AddChild((CCNode)(sprites[i]), (int)(CCMacros.CCRandomBetweenNegative1And1() * 50), PerformanceNodeChildrenTest.kTagBase + i);
                 }
+                EndTimer("Add sprites to a batch node");
 
                 // remove them
                 //#if CC_ENABLE_PROFILERS
                 //        CCProfilingBeginTimingBlock(_profilingTimer);
                 //#endif
 
+                StartTimer();
                 for (int i = 0; i < totalToAdd; i++)
                 {
                     batchNode.RemoveChildByTag(PerformanceNodeChildrenTest.kTagBase + i, true);
                 }
+                EndTimer("Remove children by tag from the batch node");
 
                 //#if CC_ENABLE_PROFILERS
                 //        CCProfilingEndTimingBlock(_profilingTimer);
diff --git a/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/ReorderSpriteSheet.cs b/tests/tests/classes/tests/PerformanceTest/PerformanceNodeChildrenTest/ReorderSpriteSheet.cs
@@ -22,17 +22,21 @@ public override void Update(float dt)
                 List<CCSprite> sprites = new List<CCSprite>();
 
                 // Don't include the sprite creation time as part of the profiling
+                StartTimer();
                 for (int i = 0; i < totalToAdd; i++)
                 {
                     CCSprite pSprite = new CCSprite(batchNode.Texture, new CCRect(0, 0, 32, 32));
                     sprites.Add(pSprite);
                 }
+                EndTimer("Add sprites to batch node");
 
                 // add them with random Z (very important!)
+                StartTimer();
                 for (int i = 0; i < totalToAdd; i++)
                 {
                     batchNode.AddChild((CCNode)(sprites[i]), (int)(CCMacros.CCRandomBetweenNegative1And1() * 50), PerformanceNodeChildrenTest.kTagBase + i);
                 }
+                EndTimer("Add sprites to batch node with random z");
 
                 //		[batchNode sortAllChildren];
 
@@ -41,21 +45,25 @@ public override void Update(float dt)
                 //        CCProfilingBeginTimingBlock(_profilingTimer);
                 //#endif
 
+                StartTimer();
                 for (int i = 0; i < totalToAdd; i++)
                 {
                     CCNode node = (CCNode)(batchNode.Children[i]);
                     batchNode.ReorderChild(node, (int)(CCMacros.CCRandomBetweenNegative1And1() * 50));
                 }
+                EndTimer("Reordering " + totalToAdd + " sprites in the node");
 
                 //#if CC_ENABLE_PROFILERS
                 //        CCProfilingEndTimingBlock(_profilingTimer);
                 //#endif
 
                 // remove them
+                StartTimer();
                 for (int i = 0; i < totalToAdd; i++)
                 {
                     batchNode.RemoveChildByTag(PerformanceNodeChildrenTest.kTagBase + i, true);
                 }
+                EndTimer("Remove the sprites from the batch node");
             }
             bDone = true;
         }

Original file line number	Diff line number	Diff line change
`@@ -9,29 +9,34 @@ namespace tests`
`9`	`9`	`{`
`10`	`10`	`public class AddRemoveSpriteSheet : NodeChildrenMainScene`
`11`	`11`	`{`
	`12`	`+`
`12`	`13`	`public override void updateQuantityOfNodes()`
`13`	`14`	`{`
`14`	`15`	`CCSize s = CCDirector.SharedDirector.WinSize;`
`15`	`16`
`16`	`17`	`// increase nodes`
`17`	`18`	`if (currentQuantityOfNodes < quantityOfNodes)`
`18`	`19`	`{`
	`20`	`+ StartTimer();`
`19`	`21`	`for (int i = 0; i < (quantityOfNodes - currentQuantityOfNodes); i++)`
`20`	`22`	`{`
`21`	`23`	`CCSprite sprite = new CCSprite(batchNode.Texture, new CCRect(0, 0, 32, 32));`
`22`	`24`	`batchNode.AddChild(sprite);`
`23`	`25`	`sprite.Position = new CCPoint(CCRandom.Next() * s.Width, CCRandom.Next() * s.Height);`
`24`	`26`	`sprite.Visible = false;`
`25`	`27`	`}`
	`28`	`+ EndTimer("Current Quantity: add");`
`26`	`29`	`}`
`27`	`30`	`// decrease nodes`
`28`	`31`	`else if (currentQuantityOfNodes > quantityOfNodes)`
`29`	`32`	`{`
	`33`	`+ StartTimer();`
`30`	`34`	`for (int i = 0; i < (currentQuantityOfNodes - quantityOfNodes); i++)`
`31`	`35`	`{`
`32`	`36`	`int index = currentQuantityOfNodes - i - 1;`
`33`	`37`	`batchNode.RemoveChildAtIndex(index, true);`
`34`	`38`	`}`
	`39`	`+ EndTimer("Current Quantity: add");`
`35`	`40`	`}`
`36`	`41`
`37`	`42`	`currentQuantityOfNodes = quantityOfNodes;`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ public override void updateQuantityOfNodes()`
`17`	`17`	`// increase nodes`
`18`	`18`	`if (currentQuantityOfNodes < quantityOfNodes)`
`19`	`19`	`{`
	`20`	`+ StartTimer();`
`20`	`21`	`for (int i = 0; i < (quantityOfNodes - currentQuantityOfNodes); i++)`
`21`	`22`	`{`
`22`	`23`	`CCSprite sprite = new CCSprite(batchNode.Texture, new CCRect(0, 0, 32, 32));`
`@@ -28,6 +29,7 @@ public override void updateQuantityOfNodes()`
`28`	`29`	`// decrease nodes`
`29`	`30`	`else if (currentQuantityOfNodes > quantityOfNodes)`
`30`	`31`	`{`
	`32`	`+ StartTimer();`
`31`	`33`	`for (int i = 0; i < (currentQuantityOfNodes - quantityOfNodes); i++)`
`32`	`34`	`{`
`33`	`35`	`int index = currentQuantityOfNodes - i - 1;`
Original file line number	Diff line number	Diff line change
`@@ -19,11 +19,13 @@ public override void Update(float dt)`
`19`	`19`	`// CCProfilingBeginTimingBlock(_profilingTimer);`
`20`	`20`	`//#endif`
`21`	`21`
	`22`	`+ StartTimer();`
`22`	`23`	`foreach (var pObject in pChildren)`
`23`	`24`	`{`
`24`	`25`	`CCSprite pSprite = (CCSprite)pObject;`
`25`	`26`	`pSprite.Visible = false;`
`26`	`27`	`}`
	`28`	`+ EndTimer("Visible change array walk");`
`27`	`29`
`28`	`30`	`//#if CC_ENABLE_PROFILERS`
`29`	`31`	`// CCProfilingEndTimingBlock(_profilingTimer);`
Original file line number	Diff line number	Diff line change
`@@ -24,27 +24,33 @@ public override void Update(float dt)`
`24`	`24`	`List<CCSprite> sprites = new List<CCSprite>();`
`25`	`25`
`26`	`26`	`// Don't include the sprite creation time as part of the profiling`
	`27`	`+ StartTimer();`
`27`	`28`	`for (int i = 0; i < totalToAdd; i++)`
`28`	`29`	`{`
`29`	`30`	`CCSprite pSprite = new CCSprite(batchNode.Texture, new CCRect(0, 0, 32, 32));`
`30`	`31`	`sprites.Add(pSprite);`
`31`	`32`	`}`
	`33`	`+ EndTimer("Add " + totalToAdd + " sprites");`
`32`	`34`
`33`	`35`	`// add them with random Z (very important!)`
	`36`	`+ StartTimer();`
`34`	`37`	`for (int i = 0; i < totalToAdd; i++)`
`35`	`38`	`{`
`36`	`39`	`batchNode.AddChild((CCNode)(sprites[i]), (int)(CCMacros.CCRandomBetweenNegative1And1() * 50), PerformanceNodeChildrenTest.kTagBase + i);`
`37`	`40`	`}`
	`41`	`+ EndTimer("Add sprites to a batch node");`
`38`	`42`
`39`	`43`	`// remove them`
`40`	`44`	`//#if CC_ENABLE_PROFILERS`
`41`	`45`	`// CCProfilingBeginTimingBlock(_profilingTimer);`
`42`	`46`	`//#endif`
`43`	`47`
	`48`	`+ StartTimer();`
`44`	`49`	`for (int i = 0; i < totalToAdd; i++)`
`45`	`50`	`{`
`46`	`51`	`batchNode.RemoveChildByTag(PerformanceNodeChildrenTest.kTagBase + i, true);`
`47`	`52`	`}`
	`53`	`+ EndTimer("Remove children by tag from the batch node");`
`48`	`54`
`49`	`55`	`//#if CC_ENABLE_PROFILERS`
`50`	`56`	`// CCProfilingEndTimingBlock(_profilingTimer);`
Original file line number	Diff line number	Diff line change
`@@ -22,17 +22,21 @@ public override void Update(float dt)`
`22`	`22`	`List<CCSprite> sprites = new List<CCSprite>();`
`23`	`23`
`24`	`24`	`// Don't include the sprite creation time as part of the profiling`
	`25`	`+ StartTimer();`
`25`	`26`	`for (int i = 0; i < totalToAdd; i++)`
`26`	`27`	`{`
`27`	`28`	`CCSprite pSprite = new CCSprite(batchNode.Texture, new CCRect(0, 0, 32, 32));`
`28`	`29`	`sprites.Add(pSprite);`
`29`	`30`	`}`
	`31`	`+ EndTimer("Add sprites to batch node");`
`30`	`32`
`31`	`33`	`// add them with random Z (very important!)`
	`34`	`+ StartTimer();`
`32`	`35`	`for (int i = 0; i < totalToAdd; i++)`
`33`	`36`	`{`
`34`	`37`	`batchNode.AddChild((CCNode)(sprites[i]), (int)(CCMacros.CCRandomBetweenNegative1And1() * 50), PerformanceNodeChildrenTest.kTagBase + i);`
`35`	`38`	`}`
	`39`	`+ EndTimer("Add sprites to batch node with random z");`
`36`	`40`
`37`	`41`	`// [batchNode sortAllChildren];`
`38`	`42`
`@@ -41,21 +45,25 @@ public override void Update(float dt)`
`41`	`45`	`// CCProfilingBeginTimingBlock(_profilingTimer);`
`42`	`46`	`//#endif`
`43`	`47`
	`48`	`+ StartTimer();`
`44`	`49`	`for (int i = 0; i < totalToAdd; i++)`
`45`	`50`	`{`
`46`	`51`	`CCNode node = (CCNode)(batchNode.Children[i]);`
`47`	`52`	`batchNode.ReorderChild(node, (int)(CCMacros.CCRandomBetweenNegative1And1() * 50));`
`48`	`53`	`}`
	`54`	`+ EndTimer("Reordering " + totalToAdd + " sprites in the node");`
`49`	`55`
`50`	`56`	`//#if CC_ENABLE_PROFILERS`
`51`	`57`	`// CCProfilingEndTimingBlock(_profilingTimer);`
`52`	`58`	`//#endif`
`53`	`59`
`54`	`60`	`// remove them`
	`61`	`+ StartTimer();`
`55`	`62`	`for (int i = 0; i < totalToAdd; i++)`
`56`	`63`	`{`
`57`	`64`	`batchNode.RemoveChildByTag(PerformanceNodeChildrenTest.kTagBase + i, true);`
`58`	`65`	`}`
	`66`	`+ EndTimer("Remove the sprites from the batch node");`
`59`	`67`	`}`
`60`	`68`	`bDone = true;`
`61`	`69`	`}`