F# Performance of events

Events in F# are first class citizens, and this is in fact feature with vast amount of applications. We can compose events using combinators, pass events to functions, return them as a results… IDelegateEvent wrap delegates and under the hood use Delegate.DynamicInvoke for invoking methods bound to delegate, causing significant performance degradation. Rick Minerich has made good description of this problem and also suggested solution that has brilliant performance characteristics but binds event to particular delegate type.

So, is is possible to have both possibility to use arbitraty delegates and good performance characteristics? Linq expression trees come to the rescue. We cannot access Invoke method of delegate directly but we can create typed helper that will do this instead of us.

// helper type that will perform invocation
type Invoker<'D, 'A> = delegate of 'D * obj * 'A -> unit

// :)
type EventV2<'D, 'A when 'D :> Delegate and 'D : delegate<'A, unit> and 'D : null>() = 
    static let invoker = 
        let d = Expression.Parameter(typeof<'D>, "dlg")
        let sender = Expression.Parameter(typeof<obj>, "sender")
        let arg = Expression.Parameter(typeof<'A>, "arg")
        let lambda = Expression.Lambda<Invoker<'D, 'A>>(Expression.Invoke(d, sender, arg), d, sender, arg)
        lambda.Compile()
    
    let mutable multicast : 'D = null     
    
    member x.Trigger(sender:obj,args: 'A) =
        match multicast with
        | null -> ()
        | d -> invoker.Invoke(d, sender, args) // DelegateEvent used: d.DynamicInvoke(args) |> ignore

    member x.Publish =
        { new IDelegateEvent<'D> with
            member x.AddHandler(d) =
                multicast <- System.Delegate.Combine(multicast, d) :?> 'D
            member x.RemoveHandler(d) =
                multicast <- System.Delegate.Remove(multicast, d)  :?> 'D }            

// helper to be used in test
type GenFastEventClass(num) =
   let event = new EventV2<EventHandler<EventArgs>, _>()

   [<CLIEvent>]
   member this.Event = event.Publish

   member this.Run () =
       for i in 1 .. num do           
           event.Trigger(this, new System.EventArgs())

Performance measurements (I took code for other tests from Rick’s post):

class Program
    {
        const int Iters = 1000000;

        static void Run(string caption, Action action)
        {
            Console.WriteLine("{0} started", caption);
            var sw = Stopwatch.StartNew();
            action();
            sw.Stop();
            Console.WriteLine("{0}:{1}", caption, sw.Elapsed);
        }


        static void Main(string[] args)
        {
            Run("F# events", RunFSEventTest);
            Run("Fast events", RunFastEventTest);
            
            // initial pass to trigger generation of invoker (so generation time is not included in tests) 
            RunEventV2Test(1);
            Run("Precomputed events", () => RunEventV2Test(Iters));
        }

        private static void RunFSEventTest()
        {
            var fs = new Events.FsEventClass(Iters);
            int fsCalled = 0;
            fs.Event += (s, a) => fsCalled++;
            fs.Run();
        }

        private static void RunFastEventTest()
        {
            var fs = new Events.FsFastEventClass(Iters);
            int fsCalled = 0;
            fs.Event += (s, a) => fsCalled++;
            fs.Run();
        }

        private static void RunEventV2Test(int n)
        {
            var fs = new Events.GenFastEventClass(n);
            int fsCalled = 0;
            fs.Event += (s, a) => fsCalled++;
            fs.Run();
        }

        /*
F# events started
F# events:00:00:08.4989916
Fast events started
Fast events:00:00:00.0316716
Precomputed events started
Precomputed events:00:00:00.0821696
         */
    }

As you see the results of events with pregenerated indirect caller is very close to fast events, but we preserve ability to use arbitraty delegate. Cool, isn't it?