Specializing JIT compiler.

By far the biggest cost in executing python is that for any operation, you need to first figure out what that operation even means.

i.e. a = b + c actually executes something like:

• b is a dynamically typed object. (PyObject *)
• load the type of b from a pointer in the object. turns out b is an int.
• from the int type object, load the add method pointer.
• execute the add method, which does:
• check what type c is
• if c isn't an int, load the type object from c, and from that load its int method
• execute that, to get an int object (or an exception)
• do the actual integer addition (keeping in mind that integers in python have arbitrary precision so be sure to check for possible overflow etc).
• allocate a new PyObject for the result.
• return it

And then I'm still ignoring a lot of things. like radd also being a thing, the different type rules which might apply, class resolution which might happen for subclasses.

And this is all done at runtime. Which is pretty slow, but also flexible.

Now what pypy does is something akin to:

• hey this method usually gets called with its arguments being int.

• What if we compile a version of this function that at the start checks if its arguments are just of type int, and in that case, just skips all the type stuff at runtime and just does the addition.

• and in case anything diverges from that path (like an overflow, or an error), we fall back to the slow interpreted version.

It turns out that most time in any program is just spent in a small subset of functions, and those functions generally get called with arguments of the same type. So such an approach can end up saving a lot of time.

Now this is a very oversimplified explanation, the actual method in which pypy accomplishes this effect is weird. Essentially pypy isn't the actual JIT compiler even, it's an algorithm that takes as input an interpreter and then creates a JIT compiler from that interpreter. Which is then run over a python interpreter to create the final thing.