Python, compilation and acceleration of

1.1 Jax, TensorFlow etc

TBC

2.1 Cython

Lowish-friction, well-tested, well-documented, works everywhere that CPython extensions can be compiled. Compiles most Python code (apart from generators and inner functions). Optimises Python code using type definitions and extended syntax. Here, read Max Burstein’s intro.

Highlights: It works seamlessly with NumPy. It makes calling C-code easy.

Problems: No generic dispatch. Debugging is nasty, like debugging C with extra crap in your way.

2.2 Pythran

pythran, a Python library that compiles a subset of Python (including some SciPy) to C++. The documentation could be better, but a researcher I follow made the use-case clear:

As a researcher/engineer (really, an algorithm developer) in the general area of audio and speech processing, I’ve always run into the same difficulty at all the companies I’ve worked at: How to quickly prototype and develop algorithms, and subsequently turn them into efficient code that can be deployed to customers.[…]

But when came time to deploy the prototype algorithm, we typically had to bite the bullet and rewrite it in C or C++: For one thing, it was not possible or practical to ship Matlab or NumPy to our customers so our prototype code could be run in their environment. It was also crucial to squeeze every drop of efficiency out of the processor, and predictability and reproducibility of performance was also very important![…]

Then I discovered Pythran. Unlike Cython and Numba, Pythran not only accelerates your Python code (by compiling modules into fast .so files) but Pythran also generates self-contained C++ code that implements your Python/NumPy algorithm. The C++ code is fully portable, does not require any Python or NumPy libraries, does not rely at all on Python, and can easily be incorporated into a C++ project. Once compiled, your prototype code becomes extremely efficient, optimized for the target architecture, and its performance is predictable and reproducible.

2.3 Numba

More specialised than Cython, uses LLVM instead of the generic C compiler. Numba makes optimising inner numeric loops easy.

Highlights: JIT-compiles plain Python, so it’s easy to use normal debuggers then switch on the compiler for performance improvements using the @jit. Generic dispatch using the @generated_jit decorator. Compiles to multi-core vectorisations as well as CUDA. In principle, this means you can do your calculations on the GPU.

Problems: LLVM is a shifty beast and sensitive version dependencies are annoying. Documentation is a bit crap, or at least unfriendly to outsiders. Practically, getting performance out of a GPU is trickier than working out you can optimise away one tedious matrix op, and doing it at this level is hard. There is too much messing with details of how many processors to allocate what to.

You might find it easier to use Julia if a well-maintained and documented LLVM infrastructure is a real selling point for you.