Sessions at EuroPython 2011 about Performance and JIT with video

Thursday 23rd June 2011

• PyPy in production

  by Antonio Cuni and Armin Rigo

  The PyPy project has recently gathered a lot of attention for its
  progress in speeding up the Python language -- it is the fastest
  Python interpreter, and the most compatible and most stable
  'alternative´ one. No longer merely a research project, PyPy
  is now suitable for production use. We are working on improvements
  on calling into C libraries and generally integrating with
  the existing Python extensions ecosystem.

  We will give an overview on how the tracing Just-in-Time compiler
  works in PyPy. From there, we will then focus on what the PyPy
  project has achieved, particularly in the past two years:

  • most Python benchmarks run much faster than with CPython or Psyco
  • the real-world PyPy compiler toolchain itself (200 KLocs) runs twice as fast
  • already supports 32 and 64bit x86 and is in the process of supporting ARM
  • full compatibility with CPython (more than Jython/IronPython)
  • full (and JIT-ed) ctypes support to call C libraries from Python
  • supports Stackless Python (in-progress)
  • new "cpyext" layer which integrates existing CPython C extensions
  • an experimental super-fast JIT-compilation of calls to C++ libraries

  We want to reserve time for discussing potential future work like SWIG
  and/or Cython compatibility and other areas brought up by the audience.
  There are many interesting details that can be explored further;
  we will focus on the points the audience is most interested in.

  For more info:

  • http://pypy.org/
  • Our blog: http://morepypy.blogspot.com/
  • Eureka program: http://www.eurostars-eureka.eu/ [1]

  [1] Eurostars Eureka is our funding source since 2009. It is a
  cross-European funding collaboration that targets small firms
  which produce research.

  • JIT
  • Performance
  • PyPy

  At 3:30pm to 4:30pm, Thursday 23rd June

  Coverage video

Friday 24th June 2011

• Making CPython Fast Using Trace-based Optimisations

  by Mark Shannon

  CPython can be made faster by implementing the sort of
  optimizations used in the PyPy VM, and in my HotPy VM.
  All the necessary changes can be made without modifying the language or the API.

  The CPython VM can be modified to support optimizations by adding
  an effective garbage collector and by separating the
  virtual-machine state from the real-machine state (like Stackless).

  Optimizations can be implemented incrementally.
  Since almost all of the optimizations are implemented in the interpreter,
  all hardware platforms can benefit.
  JIT compiler(s) can then be added for common platforms (intel, ARM, etc.).

  For more information see http://hotpy.blogspot.com/

  • JIT
  • Performance
  • Python

  At 2:30pm to 3:30pm, Friday 24th June

  Coverage video