Chasm.Dispatching 1.1.0

Chasm.Dispatching

Provides a CompiledDispatch<T> class, that pre-compiles the invocation delegate to use static dispatch instead of dynamic dispatch.

CompiledDispatch<T>

Many frameworks tend to use the following pattern:

public interface ISystem {
    void Update(GameTime time);
}

foreach (System system in GetSystems())
    system.Update();

This often results in hundreds, or even thousands, of virtual calls. It's fine if these systems aren't called often, but if they are (e.g. in a game with ECS), it could cost the program entire seconds of CPU time! CompiledDispatch<T> aims to alleviate this problem, by compiling the methods statically (compilation only takes a fraction of a millisecond).

CompiledDispatch<GameTime> dispatch = new();

// all the ways methods can be added:
dispatch.Add(clockSystem.Update); // ← lambda (fastest)
dispatch.Add(timerSystem, "Update"); // with method name
dispatch.Add(npcSystem, updateMethod); // with MethodInfo

// you can even add static methods into the mix!
dispatch.Add(SomeStaticUpdateMethod);
// or even just regular lambdas:
dispatch.Add(time => Console.WriteLine(time));

dispatch.Compile();
dispatch.Dispatch(new GameTime(1000));

The compiled method would essentially look like this:

[MethodImpl(MethodImplOptions.NoInlining)]
static void Dispatch_Generated(GameTime time)
{
    clockSystem.Update(time);
    timerSystem.Update(time);
    npcSystem.Update(time);

    SomeStaticUpdateMethod();
    (time => Console.WriteLine(time))();
}

All of these method calls will have the ability to be inlined or even completely optimized away!

Benchmarks

Benchmarking: 100 objects with virtual no-op (but not inlinable) methods.

Compiled uses CompiledDispatch<…>, and calls each method statically. Virtual uses a specialized vtable (for class methods), to find the overridden methods more quickly. Interfaces have to look up their own vtable in the type's method table, so it's a bit harder to find the overridden methods. Delegates invoke Action<…> delegates, providing more flexibility to users, but also requiring more runtime checks.

| Method           | Mean        | Error     | StdDev    |
|----------------- |------------:|----------:|----------:|
| Compiled         |    163.9 ns |   1.57 ns |   1.47 ns |
| Virtual          |    180.5 ns |   0.43 ns |   0.38 ns |
| Interfaces       |    230.2 ns |   0.93 ns |   0.87 ns |
| Delegates        |    257.8 ns |   1.11 ns |   1.04 ns |
|----------------- |------------:|----------:|----------:|
| Create           |    11.32 us |  0.123 us |  0.115 us |
| CreateAndCompile |    91.21 us |  0.704 us |  0.588 us |
| ^ Compile        |    79.89 us |

• Compiled vs. Virtual: 16.6 ns difference [40s @120fps]
• Compiled vs. Interfaces: 66.3 ns difference [10s @120fps]
• Compiled vs. Delegates: 93.9 ns difference [7s @120fps]

Time in square brackets is the amount of time running a game with ECS on 120fps, after which this optimization's benefits become worthwhile after compiling the CompiledDispatch<…>'s methods once.

Conclusion

While virtual class methods can be almost just as efficient, the CompiledDispatch<…> class really shines when it comes to systems relying on interfaces or delegates. And another conclusion: abstract classes > interfaces > delegates.