Victor Stinner schrieb am 18.06.2018 um 15:09:

I tried two options to add support for FASTCALL on calling an object: add a flag in tp_flags and reuse tp_call, or add a new tp_fastcall slot. I failed to implement correctly any of these two options.

There are multiple issues with tp_fastcall:

* ABI issue: it's possible to load a C extension using the old ABI, without tp_fastcall: it's not possible to write type->tp_fastcall on such type. This limitation causes different issues.

Not a problem if we rededicate the unused (since Py3.0) "tp_print" slot for it. Even better, since the slot exists already in Py3.0+, tools like Cython, NumPy (with its ufuncs etc.) or generic function dispatchers, basically anything that benefits from fast calls, can enable support for it in all CPython 3.x versions and benefit from faster calls among each other, independent of the support in CPython. The explicit type flag opt-in that the PEP proposes makes this completely safe.

* If tp_call is modified, tp_fastcall may be outdated. Same if tp_fastcall is modified.

Slots are fixed at type creation and should never be modified afterwards.

What happens on "del obj.__call__" or "del type.__call__"?

$ python3.7 -c 'del len.__call__' Traceback (most recent call last): File "<string>", line 1, in <module> AttributeError: 'builtin_function_or_method' object attribute '__call__' is read-only $ python3.7 -c 'del type.__call__' Traceback (most recent call last): File "<string>", line 1, in <module> TypeError: can't set attributes of built-in/extension type 'type' And a really lovely one: $ python3.7 -c 'del (lambda:0).__call__' Traceback (most recent call last): File "<string>", line 1, in <module> AttributeError: __call__

* Many public functions of the C API still requires the tuple and dict to pass positional and keyword arguments, so a compatibility layer is required to types who only want to implement FASTCALL.

Well, yes. It would require a trivial piece of code to map between the two. Fine with me.

Related issue: what is something calls tp_call with (args: tuple, kwargs: dict)? Crash or call a compatibility layer converting arguments to FASTCALL calling convention?

The latter, obviously. Also easy to implement, with the usual undefined dict order caveat (although that's probably solved when running in Py3.6+).

I abandoned my idea for two reasons:

1) in the worst case, my changes caused a crash which is not accepted for an optimization.

This isn't really an optimisation. It's a generalisation of the call protocol.

My first intent was to removed the property_descr_get() hack because its implementation is fragile and caused crashes.

Not sure which hack you mean.

2) we implemented a lot of other optimizations which made calls faster without having to touch tp_call nor tp_fastcall. The benefit of FASTCALL for tp_call/tp_fastcall was not really significant.

What Jeroen said. Cleaning up the implementation and generalising the call protocol is going to open up a wonderfully bright future for CPython. :) Stefan