Callback optimization.

[amcgregor]

All of the Extension callback sites are list iterators calling functions. That's a lot of stack allocation and deallocation. This is no big deal under Pypy's JIT; it'd pretty quickly figure out the game. CPython on the other hand won't. Each callback is provided the same arguments, excepting one case which is more like a reduce call.

The process would be roughly:

• Our Application._application method gets disassembled to AST on start, prior to middleware wrapping.
• Each set of callbacks is similarly disassembled to AST.
• The call sites are located (i.e. using a sentinel call to a method on self) in _application and ASTs of the callbacks concatenated and injected.
• Add a little tracking of locals and del clean-up between them, with the context object passed through. Re-naming, deleting, or reassigning this label would be a Bad Thing™, but we can check for that and explode carefully.
• Also, when snagging each callback, capture the callback's module-level globals and merge to ensure they'll have access to the imports and other miscellaneous things they'll expect. Both locals and globals may require automatic prefixing to ensure no conflicts.
• Re-compile the thing back to a method, and pass it down the WSGI wrapping loop.

Huzzah, function inlining to remove call frame / stack overhead on those repeated calls.

[amcgregor]

Impractical to implement; for this type of optimization just run your application under the Pypy runtime, utilizing its JIT compilation functionality. The loops in operation to implement current callback functionality would be rapidly optimized.