With this, my results are: Starting tests... [Array 0a] Array access test: 462 [Array 1a] Implicit cast test: 258 [Array 2a] Explicit cast test: 406 [Array 3a] As cast test: 429 [Array 0b] Array access test (two operations): 1062 [Array 1b] Implicit cast test (two operations): 477 [Array 2b] Explicit cast test (two operations): 647 [Array 3b] As cast test (two operations): 652 [Vector 0a] Vector access test: 458 [Vector 1a] Implicit cast test: 252 [Vector 2a] Explicit cast test: 402 [Vector 3a] As cast test: 425 [Vector 0b] Vector access test (two operations): 1034 [Vector 1b] Implicit cast test (two operations): 483 [Vector 2b] Explicit cast test (two operations): 624 [Vector 3b] As cast test (two operations): 679
-----Original Message----- From: [email protected] [mailto:[email protected]] On Behalf Of Piers Cowburn Sent: zondag 27 december 2009 14:07 To: Flash Coders List Subject: Re: [Flashcoders] Performance from casting array/vector? Hi Cor, This was my test class, just a couple of dummy methods that do a variable declaration and an increment: package { /** * Internal test class */ public class TestClass { public function someMethod():void { var i:int = 0; i++; } public function someOtherMethod():void { var i:int = 0; i++; } } } Piers On 27 Dec 2009, at 11:52, Cor wrote: > Hi piers, > > I am trying to follow your topic. > What is in your TestClass.as?? > > Kind regards > Cor > > -----Original Message----- > From: [email protected] > [mailto:[email protected]] On Behalf Of Piers > Cowburn > Sent: zondag 27 december 2009 12:35 > To: Flash Coders List > Subject: Re: [Flashcoders] Performance from casting array/vector? > > Hi Steve, > > I thought it'd be useful to have some actual figures, so I put together a > quick test. Test code was as follows: > > package > { > import flash.display.Sprite; > import flash.utils.getTimer; > > /** > * @author Piers Cowburn > */ > public class ArrayAccessTest extends Sprite > { > private const ITERATIONS:int = 1000000; > > public function ArrayAccessTest() > { > trace("Starting tests..."); > > var startTimer:int; > var i:int; > var j:int; > > var array:Array = [new TestClass(), new TestClass(), new > TestClass()]; > var vector:Vector.<TestClass> = new Vector.<TestClass>(); > vector.push(new TestClass()); > vector.push(new TestClass()); > vector.push(new TestClass()); > var numItems:int = array.length; > var implicitCast:TestClass; > var explicitCast:TestClass; > var asCast:TestClass; > > // > // [Array 0a] Array access test > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > array[j].someMethod(); > } > } > trace("[Array 0a] Array access test: " + > (getTimer()-startTimer)); > > // > // [Array 1a] Implicit cast test > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > implicitCast = array[j]; > implicitCast.someMethod(); > } > } > trace("[Array 1a] Implicit cast test: " + > (getTimer()-startTimer)); > > // > // [Array 2a] Explicit cast test > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > explicitCast = TestClass(array[j]); > explicitCast.someMethod(); > } > } > trace("[Array 2a] Explicit cast test: " + > (getTimer()-startTimer)); > > // > // [Array 3a] As cast test > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > asCast = array[j] as TestClass; > asCast.someMethod(); > } > } > trace("[Array 3a] As cast test: " + (getTimer()-startTimer)); > > // > // [Array 0b] Array access test (two operations) > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > array[j].someMethod(); > array[j].someOtherMethod(); > } > } > trace("[Array 0b] Array access test (two operations): " + > (getTimer()-startTimer)); > > // > // [Array 1b] Implicit cast test (two operations) > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > implicitCast = array[j]; > implicitCast.someMethod(); > implicitCast.someOtherMethod(); > } > } > trace("[Array 1b] Implicit cast test (two operations): " + > (getTimer()-startTimer)); > > // > // [Array 2b] Explicit cast test (two operations) > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > explicitCast = TestClass(array[j]); > explicitCast.someMethod(); > explicitCast.someOtherMethod(); > } > } > trace("[Array 2b] Explicit cast test (two operations): " + > (getTimer()-startTimer)); > > // > // [Array 3b] As cast test (two operations) > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > asCast = array[j] as TestClass; > asCast.someMethod(); > asCast.someOtherMethod(); > } > } > trace("[Array 3b] As cast test (two operations): " + > (getTimer()-startTimer)); > > > > // > // [Vector 0a] Vector access test > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > vector[j].someMethod(); > } > } > trace("[Vector 0a] Vector access test: " + > (getTimer()-startTimer)); > > // > // [Vector 1a] Implicit cast test > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > implicitCast = vector[j]; > implicitCast.someMethod(); > } > } > trace("[Vector 1a] Implicit cast test: " + > (getTimer()-startTimer)); > > // > // [Vector 2a] Explicit cast test > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > explicitCast = TestClass(vector[j]); > explicitCast.someMethod(); > } > } > trace("[Vector 2a] Explicit cast test: " + > (getTimer()-startTimer)); > > // > // [Vector 3a] As cast test > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > asCast = vector[j] as TestClass; > asCast.someMethod(); > } > } > trace("[Vector 3a] As cast test: " + (getTimer()-startTimer)); > > > // > // [Vector 0b] Vector access test (two operations) > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > vector[j].someMethod(); > vector[j].someOtherMethod(); > } > } > trace("[Vector 0b] Vector access test (two operations): " + > (getTimer()-startTimer)); > > // > // [Vector 1b] Implicit cast test (two operations) > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > implicitCast = vector[j]; > implicitCast.someMethod(); > implicitCast.someOtherMethod(); > } > } > trace("[Vector 1b] Implicit cast test (two operations): " + > (getTimer()-startTimer)); > > // > // [Vector 2b] Explicit cast test (two operations) > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > explicitCast = TestClass(vector[j]); > explicitCast.someMethod(); > explicitCast.someOtherMethod(); > } > } > trace("[Vector 2b] Explicit cast test (two operations): " + > (getTimer()-startTimer)); > > // > // [Vector 3b] As cast test (two operations) > startTimer = getTimer(); > for (i = 0; i < ITERATIONS; ++i) > { > for (j = 0; j < numItems; ++j) > { > asCast = vector[j] as TestClass; > asCast.someMethod(); > asCast.someOtherMethod(); > } > } > trace("[Vector 3b] As cast test (two operations): " + > (getTimer()-startTimer)); > } > } > } > > And the results were: > > [Array 0a] Array access test: 1631 > [Array 1a] Implicit cast test: 1527 > [Array 2a] Explicit cast test: 1689 > [Array 3a] As cast test: 1745 > [Array 0b] Array access test (two operations): 3172 > [Array 1b] Implicit cast test (two operations): 2636 > [Array 2b] Explicit cast test (two operations): 2817 > [Array 3b] As cast test (two operations): 2841 > [Vector 0a] Vector access test: 1624 > [Vector 1a] Implicit cast test: 1520 > [Vector 2a] Explicit cast test: 1707 > [Vector 3a] As cast test: 1722 > [Vector 0b] Vector access test (two operations): 3160 > [Vector 1b] Implicit cast test (two operations): 2638 > [Vector 2b] Explicit cast test (two operations): 2790 > [Vector 3b] As cast test (two operations): 2828 > > > I was surprised to see that using an implicit cast was fastest in all > situations, even faster than using the array access operator to make one > method call (test Array 0a vs. Array 1b). Also, you can see that storing a > temporary variable really starts to make a difference when you're making > more than one method call (difference between Array 0b and Array 1b). > > HTH, > Piers > > > On 27 Dec 2009, at 01:26, Piers Cowburn wrote: > >> *Disclaimer* This is un-benchmarked, but it's what I usually work to! If > anyone has any corrections re. speed, I'd be glad to hear them :) >> >> AFAIK, using implicit casting rather than explicit in this case is faster, > so A1 in your examples is faster than A2. Also, it's better to move your > variable declaration outside the loop: >> >> var i:int = myArray.length; >> // Variable is declared once here and then reused >> var myClass:MyClass; >> while (i--) >> { >> myClass = myArray[i]; >> } >> >> >> With vectors, you don't need to cast at all. However, though you can > access your references directly from the vector using [ ], like you've done > in V3, it will be faster to store a local reference if you're using it more > than once. So for example: >> >> var i:int = myVector.length; >> var myClass:MyClass; >> while (i--) >> { >> // Store the reference in a temporary variable to avoid using [ ] > unnecessarily >> myClass = myVector[i]; >> myClass.someMethod(); >> myClass.someOtherMethod(); >> } >> >> will be faster than: >> >> var i:int = myVector.length; >> while (i--) >> { >> // This uses [ ] twice >> myVector[i].someMethod(); >> myVector[i].someOtherMethod(); >> } >> >> >> If you're only using the reference once though, it should be faster just > to use [ ], so: >> >> var i:int = myVector.length; >> while (i--) >> { >> // Just using the reference once, so not defining a temporary variable: >> myVector[i].someMethod(); >> } >> >> will be faster than: >> >> var i:int = myVector.length; >> var myClass:MyClass; >> while (i--) >> { >> // This is a waste as we're only using it once >> myClass = myVector[i]; >> myClass.someMethod(); >> } >> >> >> As I said, I don't have benchmarked figures for these, so don't take it as > gospel, but I think this was what I read when I read it. >> >> Piers >> >> >> >> >> On 27 Dec 2009, at 00:24, Steven Sacks wrote: >> >>> var instance1:MyClass = new MyClass(); >>> var instance2:MyClass = new MyClass(); >>> var instance3:MyClass = new MyClass(); >>> >>> var myArray:Array = [instance1, instance2, instance3]; >>> >>> // QUESTION A: CASTING WITH ARRAYS >>> >>> var i:int = myArray.length; >>> while (i--) >>> { >>> // [A1] - Does Flash have to do a look up here? >>> var myClass:MyClass = myArray[i]; >>> >>> // [A2] - Does casting it like this boost performance >>> var myClass:MyClass = MyClass(myArray[i]); >>> >>> // [A3] - I know using "as" is slower than direct casting >>> var myClass:MyClass = myArray[i] as MyClass; >>> } >>> >>> // QUESTION B: CASTING WITH VECTORS >>> >>> var myVector:Vector.<MyClass> = Vector.<MyClass>(myArray); >>> >>> var i:int = myVector.length; >>> >>> while (i--) >>> { >>> // [V1] - Will this avoid the lookup? >>> var myClass:MyClass = myVector[i]; >>> >>> // [V2] - Or do I need to cast here even though it's a Vector? >>> var myClass:MyClass = MyClass(myVector[i]); >>> >>> // [V3] - And if so, can I do this without a lookup? >>> myVector[i].someMethod(); >>> >>> // [V4] - Or do I need to do this? >>> MyClass(myVector[i]).someMethod(); >>> } >>> >>> >>> Thanks in advance for anyone who can shed some light here. I believe > A2/V2 is "fastest" but I'm not certain, and I also don't know if it's > required for Vector. >>> _______________________________________________ >>> Flashcoders mailing list >>> [email protected] >>> http://chattyfig.figleaf.com/mailman/listinfo/flashcoders >> >> >> _______________________________________________ >> Flashcoders mailing list >> [email protected] >> http://chattyfig.figleaf.com/mailman/listinfo/flashcoders > > > _______________________________________________ > Flashcoders mailing list > [email protected] > http://chattyfig.figleaf.com/mailman/listinfo/flashcoders > No virus found in this incoming message. > Checked by AVG - www.avg.com > Version: 9.0.722 / Virus Database: 270.14.119/2586 - Release Date: 12/26/09 > 20:02:00 > > _______________________________________________ > Flashcoders mailing list > [email protected] > http://chattyfig.figleaf.com/mailman/listinfo/flashcoders _______________________________________________ Flashcoders mailing list [email protected] http://chattyfig.figleaf.com/mailman/listinfo/flashcoders No virus found in this incoming message. Checked by AVG - www.avg.com Version: 9.0.722 / Virus Database: 270.14.120/2588 - Release Date: 12/26/09 20:02:00 _______________________________________________ Flashcoders mailing list [email protected] http://chattyfig.figleaf.com/mailman/listinfo/flashcoders
