SendActionScriptWorkerMessages2.5xFaster

package
{
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.utils.getTimer;
	import flash.utils.ByteArray;
	import flash.text.TextField;
	import flash.text.TextFieldAutoSize;
	import flash.system.Worker;
	import flash.system.WorkerDomain;
	import flash.system.WorkerState;
	import flash.system.MessageChannel;
 
	/**
	* Test to show the speed of passing messages between workers
	* @author Jackson Dunstan (JacksonDunstan.com)
	*/
	public class MessagePassingTest extends Sprite
	{
	/** Output logger */
	private var logger:TextField = new TextField();
 
	/**
	* Log a CSV row
	* @param cols Columns of the row
	*/
	private function row(...cols): void
	{
	logger.appendText(cols.join(",")+"\n");
	}
 
	/** Message channel from the main thread to the worker thread */
	private var mainToWorker:MessageChannel;
 
	/** Message channel from the worker thread to the main thread */
	private var workerToMain:MessageChannel;
 
	/** The worker thread (main thread only) */
	private var worker:Worker;
 
	/** Number of messages to send back and forth in the test */
	private var REPS:int = 1000;
 
	/** Time before the message passing test started */
	private var beforeTime:int;
 
	/** Current message index */
	private var cur:int;
 
	/**
	* Start the app in main thread or worker thread mode
	*/
	public function MessagePassingTest()
	{
	// Setup the logger
	logger.autoSize = TextFieldAutoSize.LEFT;
	addChild(logger);
 
	// If this is the main SWF, start the main thread
	if (Worker.current.isPrimordial)
	{
	startMainThread();
	}
	// If this is the worker thread SWF, start the worker thread
	else
	{
	startWorkerThread();
	}
	}
 
	/**
	* Start the main thread
	*/
	private function startMainThread(): void
	{
	// Try to get the best framerate possible
	stage.frameRate = 1000;
 
	// Create the worker from our own SWF bytes
	worker = WorkerDomain.current.createWorker(this.loaderInfo.bytes);
 
	// Create a message channel to send to the worker thread
	mainToWorker = Worker.current.createMessageChannel(worker);
	worker.setSharedProperty("mainToWorker", mainToWorker);
 
	// Create a message channel to receive from the worker thread
	workerToMain = worker.createMessageChannel(Worker.current);
	workerToMain.addEventListener(Event.CHANNEL_MESSAGE, onWorkerToMainDirect);
	worker.setSharedProperty("workerToMain", workerToMain);
 
	// Start the worker
	worker.start();
 
	// Begin the test where we use MessageChannel to send messages
	// between the threads by sending the first message
	beforeTime = getTimer();
	mainToWorker.send("1");
	}
 
	/**
	* Start the worker thread
	*/
	private function startWorkerThread(): void
	{
	// Get the message channels the main thread set up for communication
	// between the threads
	mainToWorker = Worker.current.getSharedProperty("mainToWorker");
	workerToMain = Worker.current.getSharedProperty("workerToMain");
	mainToWorker.addEventListener(Event.CHANNEL_MESSAGE, onMainToWorker);
	}
 
	/**
	* Callback for when a message has been received from the main thread to
	* the worker thread on a MessageChannel
	* @param ev CHANNEL_MESSAGE event
	*/
	private function onMainToWorker(ev:Event): void
	{
	// Record the message and send a response
	cur++;
	workerToMain.send("1");
 
	// If this was the last message, prepare for the next test where the
	// two threads communicate with shared properties
	if (cur == REPS)
	{
	// We receive "1" on our own Thread (the worker thread) and send
	// "2" in response
	setSharedPropertyTest(Worker.current, "1", "2", false);
	}
	}
 
	/**
	* Callback for when the worker thread sends a message to the main thread
	* via a MessageChannel
	* @param ev CHANNEL_MESSAGE event
	*/
	private function onWorkerToMainDirect(ev:Event): void
	{
	// Record the message and show progress (this version is slow)
	cur++;
	logger.text = "MessageChannel: " + cur + " / " + REPS;
 
	// If this wasn't the last message, send another message to the
	// worker thread
	if (cur < REPS)
	{
	mainToWorker.send("1");
	return;
	}
 
	// The MessageChannel test is done. Record the time it took.
	var afterTime:int = getTimer();
	var messageChannelTime:int = afterTime - beforeTime;
 
	// Run the setSharedProperty test where the two threads communicate
	// by directly setting shared properties on the worker thread. The
	// main thread receives "2", sends "1", and is responsible for
	// starting the process with an initial "1" message.
	beforeTime = getTimer();
	setSharedPropertyTest(worker, "2", "1", true);
	afterTime = getTimer();
	var setSharedPropertyTime:int = afterTime - beforeTime;
 
	// Clear the logger and show the results instead
	logger.text = "";
	row("Type", "Time", "Messages/sec");
	var messagesPerSecond:Number = messageChannelTime/Number(REPS);
	row("MessageChannel", messageChannelTime, messagesPerSecond);
	messagesPerSecond = setSharedPropertyTime/Number(REPS);
	row("setSharedProperty", setSharedPropertyTime, messagesPerSecond);
	}
 
	/**
	* Perform the setSharedProperty test where the two threads communicate
	* by directly setting shared properties on the worker thread
	* @param worker Worker the shared properties are set on
	* @param inMessage Expected message this thread receives from the other
	* @param outMessage Message to send to the other thread
	* @param sendInitial If an initial message should be sent
	*/
	private function setSharedPropertyTest(
	worker:Worker,
	inMsg:String,
	outMsg:String,
	sendInitial:Boolean
	): void
	{
	// Reset the count from the first test
	cur = 0;
 
	// Optionally send an initial outgoing message to start the process
	if (sendInitial)
	{
	worker.setSharedProperty("message", outMsg);
	}
 
	// Send messages until we've hit the limit
	while (cur < REPS)
	{
	// Check to see if the shared property is the incoming message
	if (worker.getSharedProperty("message") == inMsg)
	{
	// Record the message and send a response by setting the
	// shared property to the outgoing message
	cur++;
	worker.setSharedProperty("message", outMsg);
	}
	}
	}
	}
}