Category: ActionScript

package
{
	import flash.utils.getTimer;
	import flash.events.Event;
	import flash.display.Sprite;
 
	public final class LinkedListPerformanceCheck extends Sprite
	{
		private var _firstItemWithPublicVar : ItemWithPublicVar;
		private var _firstFinalItemWithPublicVar : FinalItemWithPublicVar;
		private var _firstItemWithGetter : ItemWithGetter;
		private var _firstFinalItemWithGetter : FinalItemWithGetter;
		private var _firstIItemWithGetter : IItemWithGetter;
		private var _firstIFinalItemWithGetter : IFinalItemWithGetter;
 
		private var _c : int;
		private var _i : int;
 
		public function LinkedListPerformanceCheck()
		{
			loaderInfo.addEventListener( Event.COMPLETE, run );
		}
 
		private function run( event : Event ) : void
		{
			_c = 5000000;
			_i = 0;
			addEventListener( Event.ENTER_FRAME, onEnterFrame );
		}
 
		private function onEnterFrame( event : Event ) : void
		{
			switch( _i++ )
			{
				case 0 : createItemWithPublicVarTest(); break;
				case 1 : createFinalItemWithPublicVarTest(); break;
				case 2 : createItemWithGetterTest(); break;
				case 3 : createFinalItemWithGetterTest(); break;
				case 4 : createImplementedIItemWithGetterTest(); break;
				case 5 : createImplementedIFinalItemWithGetterTest(); break;
				case 6 : break; // wait
				case 7 : break; // wait
				case 8 : break; // wait
				case 9 : break; // wait
				case 10 : runItemWithPublicVarTest(); break;
				case 11 : runFinalItemWithPublicVarTest(); break;
				case 12 : runItemWithGetterTest(); break;
				case 13 : runFinalItemWithGetterTest(); break;
				case 14 : runImplementedIItemWithGetterTest(); break;
				case 15 : runImplementedIFinalItemWithGetterTest(); break;
				case 16 : runItemWithPublicVarTest(); break; // again - just to make sure...
				case 17 : runFinalItemWithPublicVarTest(); break; // again - just to make sure...
				default: removeEventListener( Event.ENTER_FRAME, onEnterFrame );
			}
		}
 
		private function createItemWithPublicVarTest() : void
		{
			var item : ItemWithPublicVar = _firstItemWithPublicVar = new ItemWithPublicVar();
			for ( var i : int = 0; i < _c; i++ ) { item = item.next = new ItemWithPublicVar(); }
		}
 
		private function runItemWithPublicVarTest() : void
		{
			var item : ItemWithPublicVar = _firstItemWithPublicVar;
			var startTime : int = getTimer();
			while( item ){ item = item.next; }
			var duration : int = getTimer() - startTime;
			trace("LinkedListPerformanceCheck.runItemWithPublicVarTest( " +duration + " )");
		}
 
		private function createFinalItemWithPublicVarTest() : void
		{
			var item : FinalItemWithPublicVar = _firstFinalItemWithPublicVar = new FinalItemWithPublicVar();
			for ( var i : int = 0; i < _c; i++ ) { item = item.next = new FinalItemWithPublicVar(); }
		}
 
		private function runFinalItemWithPublicVarTest() : void
		{
			var item : FinalItemWithPublicVar = _firstFinalItemWithPublicVar;
			var startTime : int = getTimer();
			while( item ){ item = item.next; }
			var duration : int = getTimer() - startTime;
			trace("LinkedListPerformanceCheck.runFinalItemWithPublicVarTest( " +duration + " )");
		}
 
		private function createItemWithGetterTest() : void
		{
			var item : ItemWithGetter = _firstItemWithGetter = new ItemWithGetter();
			for ( var i : int = 0; i < _c; i++ ) { item = item.next = new ItemWithGetter(); }
		}
 
		private function runItemWithGetterTest() : void
		{
			var item : ItemWithGetter = _firstItemWithGetter;
			var startTime : int = getTimer();
			while( item ){ item = item.next; }
			var duration : int = getTimer() - startTime;
			trace("LinkedListPerformanceCheck.runItemWithGetterTest( " +duration + " )");
		}
 
		private function createFinalItemWithGetterTest() : void
		{
			var item : FinalItemWithGetter = _firstFinalItemWithGetter = new FinalItemWithGetter();
			for ( var i : int = 0; i < _c; i++ ) { item = item.next = new FinalItemWithGetter(); }
		}
 
		private function runFinalItemWithGetterTest() : void
		{
			var item : FinalItemWithGetter = _firstFinalItemWithGetter;
			var startTime : int = getTimer();
			while( item ){ item = item.next; }
			var duration : int = getTimer() - startTime;
			trace("LinkedListPerformanceCheck.runFinalItemWithGetterTest( " +duration + " )");
		}
 
		private function createImplementedIItemWithGetterTest() : void
		{
			var item : IItemWithGetter = _firstIItemWithGetter = new ImplementedIItemWithGetter();
			for ( var i : int = 0; i < _c; i++ ) { item = item.next = new ImplementedIItemWithGetter(); }
		}
 
		private function runImplementedIItemWithGetterTest() : void
		{
			var item : IItemWithGetter = _firstIItemWithGetter;
			var startTime : int = getTimer();
			while( item ){ item = item.next; }
			var duration : int = getTimer() - startTime;
			trace("LinkedListPerformanceCheck.runImplementedIItemWithGetterTest( " +duration + " )");
		}
 
		private function createImplementedIFinalItemWithGetterTest() : void
		{
			var item : IFinalItemWithGetter = _firstIFinalItemWithGetter = new ImplementedIFinalItemWithGetter();
			for ( var i : int = 0; i < _c; i++ ) { item = item.next = new ImplementedIFinalItemWithGetter(); }
		}
 
		private function runImplementedIFinalItemWithGetterTest() : void
		{
			var item : IFinalItemWithGetter = _firstIFinalItemWithGetter;
			var startTime : int = getTimer();
			while( item ){ item = item.next; }
			var duration : int = getTimer() - startTime;
			trace("LinkedListPerformanceCheck.runImplementedIFinalItemWithGetterTest( " +duration + " )");
		}
	}
}
 
class ItemWithPublicVar { public var next : ItemWithPublicVar; }
 
final class FinalItemWithPublicVar { public var next : FinalItemWithPublicVar; }
 
class ItemWithGetter
{
	private var _next : ItemWithGetter;
	public function get next() : ItemWithGetter { return _next; }
	public function set next( value : ItemWithGetter ) : void { _next = value; }
}
 
final class FinalItemWithGetter
{
	private var _next : FinalItemWithGetter;
	public function get next() : FinalItemWithGetter { return _next; }
	public function set next( value : FinalItemWithGetter ) : void { _next = value; }
}
 
interface IItemWithGetter
{
	function get next() : IItemWithGetter;
	function set next( value : IItemWithGetter ) : void;
}
 
class ImplementedIItemWithGetter implements IItemWithGetter
{
	private var _next : IItemWithGetter;
	public function get next() : IItemWithGetter { return _next; }
	public function set next( value : IItemWithGetter ) : void { _next = value; }
}
 
interface IFinalItemWithGetter
{
	function get next() : IFinalItemWithGetter;
	function set next( value : IFinalItemWithGetter ) : void;
}
 
final class ImplementedIFinalItemWithGetter implements IFinalItemWithGetter
{
	private var _next : IFinalItemWithGetter;
	public function get next() : IFinalItemWithGetter { return _next; }
	public function set next( value : IFinalItemWithGetter ) : void { _next = value; }
}

LinkedListPerformanceCheck.runItemWithPublicVarTest( 86 )
LinkedListPerformanceCheck.runFinalItemWithPublicVarTest( 88 )
LinkedListPerformanceCheck.runItemWithGetterTest( 1247 )
LinkedListPerformanceCheck.runFinalItemWithGetterTest( 1148 )
LinkedListPerformanceCheck.runImplementedIItemWithGetterTest( 1161 )
LinkedListPerformanceCheck.runImplementedIFinalItemWithGetterTest( 1160 )
LinkedListPerformanceCheck.runItemWithPublicVarTest( 64 )
LinkedListPerformanceCheck.runFinalItemWithPublicVarTest( 62 )

package de.superclass 
{
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.TimerEvent;
	import flash.utils.Timer;
	import flash.utils.getTimer;
 
	public final class LinkedListTest extends Sprite 
	{
		private var _abstractItemLinkedList : AbstractItem;
		private var _dataItemLinkedList : DataItem;
		private var _vector : Vector.<DataItem>;
 
		public function LinkedListTest()
		{
			loaderInfo.addEventListener( Event.COMPLETE, onLoaderInfoComplete );
		}
 
		private function onLoaderInfoComplete( event : Event ) : void 
		{
			createData( );
 
			var timer : Timer = new Timer( 3000, 1 );
				timer.addEventListener( TimerEvent.TIMER_COMPLETE, onTimerComplete );
				timer.start();
		}
 
		private function onTimerComplete(event : TimerEvent) : void 
		{
			runTest( );
		}
 
		private function createData() : void 
		{
			var vector : Vector.<DataItem> = _vector = new Vector.<DataItem>();
			for ( var i : int = 0; i < 5000000; i++ )
			{
				var dataItem : DataItem = new DataItem();
					dataItem.index = i;
 
				vector.push( dataItem );
 
				var abstractItem : AbstractItem = new AbstractItem();
					abstractItem.data = dataItem;
 
				if ( i == 0 )
				{
					_dataItemLinkedList = dataItem;
					_abstractItemLinkedList = abstractItem;
				}
				else
				{
					previousDataItem.next = dataItem;
					previousAbstractItem.next = abstractItem;
				}
 
				var previousDataItem : DataItem = dataItem;
				var previousAbstractItem : AbstractItem = abstractItem;
			}
		}
 
		private function runTest() : void 
		{
			var dataItem : DataItem;
			var startTime : int;
 
			var vector : Vector.<DataItem> = _vector;
			var c : int = vector.length;
 
			startTime = getTimer();
			for ( var i : int = 0; i < c; i++ )
			{
				dataItem = vector[ i ];
				dataItem.index = dataItem.index;
			}
 
			var durationVector : int = getTimer() - startTime;
 
			startTime = getTimer();
			dataItem = _dataItemLinkedList;
			while ( dataItem )
			{
				dataItem.index = dataItem.index;
				dataItem = dataItem.next;
			}
 
			var durationDataItemLinkedList : int = getTimer() - startTime;
 
			startTime = getTimer( );
			var abstractItem : AbstractItem = _abstractItemLinkedList;
			while ( abstractItem )
			{
				dataItem = abstractItem.data;
				dataItem.index = dataItem.index;
				abstractItem = abstractItem.next;
			}
 
			var durationAbstractItemLinkedList : int = getTimer() - startTime;
 
			startTime = getTimer( );
			abstractItem = _abstractItemLinkedList;
			while ( abstractItem )
			{
				dataItem = DataItem( abstractItem.data );
				dataItem.index = dataItem.index;
				abstractItem = abstractItem.next;
			}
 
			var durationAbstractItemLinkedListWithCast : int = getTimer() - startTime;
 
			startTime = getTimer( );
			abstractItem = _abstractItemLinkedList;
			while ( abstractItem )
			{
				dataItem = abstractItem.data as DataItem;
				dataItem.index = dataItem.index;
				abstractItem = abstractItem.next;
			}
 
			var durationAbstractItemLinkedListWithAs : int = getTimer() - startTime;
 
			trace( "Durations:" );
			trace( "Vector", durationVector );
			trace( "DataItem LinkedList", durationDataItemLinkedList );
			trace( "AbstractItem LinkedList", durationAbstractItemLinkedList );
			trace( "AbstractItemLinkedList Using Cast", durationAbstractItemLinkedListWithCast );
			trace( "AbstractItemLinkedList Using As", durationAbstractItemLinkedListWithAs );
		}
	}
 
}
 
class AbstractItem
{
	public var data : *;
	public var next : AbstractItem;
}
 
class DataItem
{
	public var index : int;
	public var next : DataItem;
}