JIT: Optimize common C calls via replication

[Fidget-Spinner]

Feature or enhancement

Proposal:

Currently, a C calls is executed roughly as follows in the specializing interpreter:

(py_func->m_ml->ml_meth)(...args)

This has two sources of overhead:

1. Double pointer lookup while cheap is still something we can remove.
2. JIT cannot inline the function without PGO (which the JIT currently does not have, and will probably never have).

We can optimize it to the following in the JIT:

PyCFunction cfunc = LOOKUP_TABLE[1..n]; // Via replicate(n)
DEOPT_IF(cfunc != py_func->m_ml->ml_meth);
cfunc(...args);

LOOKUP_TABLE will be populated with common C functions that we know Python code uses.
This will remove the overhead of 2. Allowing the JIT to inline and optimize these calls.

If we want, there's an even more extreme optimization we could do. We could just burn in the C function directly and call it. saving the overhead of 1. However, I don't think this could be done without breaking strange usages of ml_meth where it's dynamically set. So I would be more cautious here with that.

Has this already been discussed elsewhere?

No response given

Links to previous discussion of this feature:

No response

[Fidget-Spinner]

This doesn't work with the current copy and patch because calls to external functions are treated as holes. @brandtbucher are there any plans to make inlining work with functions that are external relocations? Would LTO work (I applied your LTO patch, but it seems to not be generating anything better).

[brandtbucher]

I'm certainly interested in being able to inline stuff into the stencils, but I don't have any obvious way to do it yet.

[markshannon]

This looks similar to faster-cpython/ideas#660.

[Fidget-Spinner]

Oh yeah it is