Comments on: Runnables as Function Pointers

By: Uwe Holland

Uwe Holland — Sat, 26 Sep 2009 21:48:03 +0000

Find my answers here. :)

By: Troy Gilbert

Troy Gilbert — Sat, 26 Sep 2009 01:44:04 +0000

Wow, Flash Player on Windows performs so much better when it comes to memory allocations (the real difference between events and callbacks):

numListeners: 100, events: 3470ms, callbacks: 187ms, observers: 74ms

That’s the release standalone Flash Player 10, the fastest way to run Flash on the Mac.

By: jackson

jackson — Sat, 26 Sep 2009 01:34:14 +0000

I saw and commented about it. Thanks for doing the writeup. Between the three of us we have really explored the options an AS3 programmer has for doing callbacks!

By: Uwe Holland

Uwe Holland — Sat, 26 Sep 2009 01:30:35 +0000

I’m following your discussion interested and I’ve just posted our approch on my blog relying to this. http://blog.rauschgenerator.com/2009/09/26/using-callback-commands-instead-of-events/

By: Using Callback Commands instead of Events | RGB(log)

Using Callback Commands instead of Events | RGB(log) — Sat, 26 Sep 2009 01:21:29 +0000

[...] read posts about the speed advantages of callbacks over events on the blogs of Troy Gilbert and Jackson Dustan. But instead of using a strategy like stated in the comment here we use something which we call [...]

By: jackson

jackson — Fri, 25 Sep 2009 22:11:14 +0000

Thanks for the demo. I edited your comment to fix the HTML safety stuff. My results on a 3.0Ghz Intel Core 2 Duo with 2GB of RAM on Windows XP are:

numListeners: 100, events: 152ms, callbacks: 109ms, observers: 34ms

So right away the “observer” technique is 3x faster than callbacks, just like you say. It sure looks like your observer technique is almost the same as my runnable technique; perhaps the more correct terminology. Wikipedia seems to think so. In any case, it seems as though your observer technique test validates my runnable technique test, which is good to hear.

Thanks very much for providing the test!

By: Troy Gilbert

Troy Gilbert — Fri, 25 Sep 2009 20:55:10 +0000

Well, some of its been eaten up by making it HTML-safe, so cut-n-paste with care!

By: Troy Gilbert

Troy Gilbert — Fri, 25 Sep 2009 20:53:51 +0000

Okay, here’s my test harness:

package {
 
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.text.TextField;
    import flash.utils.getTimer;
    import flash.utils.setTimeout;
 
    public class EventsVsFunctions extends Sprite
    {
        public function EventsVsFunctions() { addEventListener(Event.ADDED_TO_STAGE, onStage); }
        private function onStage(event:Event):void { setTimeout(doTests, 5000); }
 
        private function doTests():void
        {
            var results:String = testListeners(100);
 
            // output results
            var tf:TextField = new TextField();
            tf.autoSize = "left";
            tf.text = results;
            addChild(tf);
        }
 
        private function testListeners(numListeners:int = 1):String
        {
            const NUM_ITERATIONS:int = 10000;
            var startTime:int, stopTime:int;
            var eventsDuration:int, callbacksDuration:int, observersDuration:int;
            var i:int;
            var event:Event;
 
            // setup event listeners
            var dispatcher:EventDispatcher = new EventDispatcher();
            for (i = 0; i < numListeners; i++) dispatcher.addEventListener(Event.CHANGE, new ChangeObserver().onChange);
 
            // time event dispatchs
            startTime = getTimer();
            for (i; i < NUM_ITERATIONS; i++) dispatcher.dispatchEvent(new Event(Event.CHANGE));
            stopTime = getTimer();
            eventsDuration = stopTime - startTime;
 
            // setup callbacks
            for (i = 0; i < numListeners; i++) callbacks.push(new ChangeObserver().onChange);
 
            // time function calls
            startTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; i++) doCallback(new Event(Event.CHANGE));
            stopTime = getTimer();
            callbacksDuration = stopTime - startTime;
 
            // setup observers
            for (i = 0; i < numListeners; i++) observers.push(new ChangeObserver());
 
            // time observers
            startTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; i++) doObserver(new Event(Event.CHANGE));
            stopTime = getTimer();
            observersDuration = stopTime - startTime;
 
            // results as a CSV
            return "numListeners: " + numListeners + ", events: " + eventsDuration + "ms, callbacks: " +
                callbacksDuration + "ms, observers: " + observersDuration + "ms";
        }
 
        private var callbacks:Array = [ ];
        private function doCallback(event:Event):void
        {
            for each (var callback:Function in callbacks) callback(event);
        }
 
        private var observers:Array = [ ];
        private function doObserver(event:Event):void
        {
            for each (var observer:IChangeObserver in observers) observer.onChange(event);
        }
    }
}
 
import flash.events.Event;
interface IChangeObserver {  function onChange(event:Event):void; }
class ChangeObserver implements IChangeObserver { public function onChange(event:Event):void { } }

It tries to be a slightly more real-world usage scenario. I allocate multiple objects to receive notification (via event, callback or observer), and iterate through the targets through a container (you call directly on a local instance, which will make it seem even faster).

Looking back at my times, there is a difference between callbacks (Function references) and observers (runnables). A not insignificant difference, to be honest, particularly if you look at the times in the standalone Flash Player (as opposed to debug browser plug-in). But when compared to events, callbacks and observers are in the same class.

All that being said, observers look to give a 2x-3x improvement over callbacks, but that’s only measurable over hundreds of thousands of calls. Given the huge drawback of having to implement a specific interface and being limited to a single function per-class, I think callbacks (Function references) are the winner.

By: jackson

jackson — Fri, 25 Sep 2009 20:46:22 +0000

We might be talking about two different comparisons. I think you're talking about events versus callbacks and I'm talking about callbacks via Function variables versus callbacks via runnables. I totally agree about events being slower than callbacks via Function variables and am trying to show that there's a further speedup. It's kind of like this:

Events (slowest)
Callbacks via Function variables (slow)
Callbacks via runnables (fast)

This article is an attempt to improve even on callbacks via Function variables by implementing callbacks via runnables. There's nothing limiting runnables to callbacks, so I covered it in general rather than just the callbacks case. Now I'm wondering if you have discovered a technique that improves even on callbacks via runnables. That would be awesome to see! You can either e-mail it to me directly or post it in comments by wrapping it up:

// code goes here

Thanks!

By: Troy Gilbert

Troy Gilbert — Fri, 25 Sep 2009 20:36:46 +0000

I’ve got a test case that compares events, callbacks and observers. What’s the best way to post code to the blog (or I could email it to you)?