Awesome

Fast delegates implementation

Summary

The intention of this project is to make a fast implementation in C++17 that will work on multiple platforms at maximum speed.

The main code is in delegate.h and delegate.cpp, abi.h contains ABI feature macros, and main.cpp contains some test cases to exercise the code.

Status so far:

Ultimately, situations where MAME_DELEGATE_TYPE_COMPATIBLE is used should be minimised.

Benchmarks

Note that the benchmarks are outdated.

Doing 100000000 to a virtual method

     typedef delegate<void(int j)> callback_delegate;
     callback_delegate cb = callback_delegate(FUNC(MyClass2::docount), &mc);

     typedef std::function<void(int)> callback_delegate_std;
     callback_delegate_std  cb_std = std::bind(&MyClass2::docount, &mc, std::placeholders::_1);

Please note that times will be different from run to run, but values are near

Windows machine Intel i7-4790K @4.00GHz

Description

There are many implementations of delegate-like functionality for C++ code, but none of them is a perfect drop-in fit for use in MAME. In order to be useful in MAME, we need the following properties:

• No significant overhead; we want to use these for memory accessors, and memory accessor overhead is already the dominant performance aspect for most drivers.

• Existing static functions need to be bound with an additional pointer parameter as the first argument. All existing implementations that allow static function binding assume the same signature as the member functions.

• We must be able to bind the function separately from the object. This is to allow configurations to bind functions before the objects are created.

Thus, the implementations below are based on existing works but are really a new implementation that is specific to MAME.

The "compatible" version of delegates is based on an implementation from Sergey Ryazanov, found here:

https://www.codeproject.com/Articles/11015/The-Impossibly-Fast-C-Delegates

These delegates essentially generate a templated static stub function for each target function. The static function takes the first parameter, uses it as the object pointer, and calls through the member function. For static functions, the stub is compatible with the signature of a static function, so we just set the stub directly.

Pros:

• should work with any modern compiler
• static bindings are just as fast as direct calls

Cons:

• lots of little stub functions generated
• double-hops on member function calls means more overhead
• calling through stub functions repackages parameters

The "Itanium" version of delegates makes use of the internal structure of member function pointers in order to convert them at binding time into simple static function pointers. This only works on platforms where object->func(p1, p2) is equivalent in calling convention to func(object, p1, p2).

Pros:

• as fast as a standard function call in static and member cases
• no stub functions or double-hops needed

Cons:

• requires internal knowledge of the member function pointer
• only works for two popular variants of the Itanium C++ ABI

The "MSVC" version of delegates makes use of the internal structure of member function pointers in order to convert them at binding time into simple static function pointers. This only works on platforms where object->func(p1, p2) is equivalent in calling convention to func(object, p1, p2).

Pros:

• as fast as a standard function call in static and non-virtual member cases
• no stub functions needed

Cons:

• requires internal knowledge of the member function pointer
• only works works with MSVC ABI, and not on 32-bit x86
• does not work for classes with virtual bases
• structure return does not work with member function pointers
• virtual member function lookup cannot be done in advance

Further reading:

• http://itanium-cxx-abi.github.io/cxx-abi/abi.html#member-pointers Formal specification for the most common member function pointer implementations.

• https://www.codeproject.com/Articles/7150/Member-Function-Pointers-and-the-Fastest-Possible Discusses many member function pointer implementations. Based on reverse-engineering, so not entirely accurate. In particular, various fields are incorrectly assumed to be int-sized which is not true in the general case.

• https://devblogs.microsoft.com/oldnewthing/20040209-00/?p=40713 Describes the MSVC implementation of pointers to member functions for classes with single or multiple inheritance. Does not mention the additional variants for virtual or unknown inheritance. Incorrectly states that the "this" pointer displacement is a size_t when in reality it is an int (important for 64-bit architectures).

License (BSD-3-clause)

Copyright 2010-2022 Aaron Giles, Couriersud, Miodrag Milanovic, Vas Crabb.
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

   1. Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

   2. Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
EVENT SHALL COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.