TechPrufer
Get started
Meta
Meta logoMeta · Feature trail

Python Runtime and GIL Evolution

1 post · Jun 2015 – May 2025

What this trail covers

Meta's Python runtime evolution continues with the introduction of Immortal Objects (PEP-683), enabling true object immutability by bypassing reference count and garbage collection checks. This significantly reduces private memory usage by increasing shared memory and minimizing copy-on-write operations in multi-process architectures like Instagram's Django frontend servers. This advancement is a foundational step towards a multi-core Python runtime, supporting proposals like Per-Interpreter GIL. Additionally, Meta and Quansight have collaborated to improve type annotations in key Python libraries like pandas and numpy, increasing type coverage and developing tooling to streamline the process. They are also actively contributing to making the Python ecosystem compatible with free-threaded Python (Python 3.13+), which removes the Global Interpreter Lock (GIL) to enable true parallelism within a single process.

All Meta trails
  1. Enhancing the Python ecosystem with type checking and free threadingThis post details Meta's and Quansight's contributions to the Python ecosystem, focusing on two key areas: 1. Enhancing type annotations in libraries like pandas-stubs and numpy, increasing type coverage from 36% to over 50% and developing tooling to manage independent stub distribution. Key introductions include replacing raw Series types with UnknownSeries and improving types for core DataFrame operations. 2. Preparing the Python ecosystem for free-threaded Python (Python 3.13+) by adding compatibility support to popular scientific computing packages (numpy, scipy, scikit-learn) and language bindings (Cython, nanobind, pybind, PyO3).
  2. Introducing Immortal Objects for PythonIntroduced Immortal Objects (PEP-683) to Python, allowing objects to bypass reference count and GC checks for true immutability. This reduces private memory pressure in multi-process Python applications by increasing shared memory usage and minimizing copy-on-write operations. The implementation involved addressing backward compatibility, platform compatibility, and a ~2% performance regression in reference count routines.
  3. How the Cinder JIT’s function inliner helps us optimize InstagramThis post introduces the function inliner within Meta's Cinder JIT compiler. It details the process of translating Python bytecode to native code, including the intermediate representations (CFG, HIR, SSA, LIR) and the benefits of removing stack and dispatch overhead. The core contribution is the explanation of how function inlining works: collecting call sites, constructing the callee's HIR within the caller's CFG, SSA-ifying the callee's graph, and rewriting return instructions. This enables further optimizations like type specialization, constant folding, and reduced overhead for function calls, leading to performance improvements for Python applications.
  4. Simon Marlow, Simon Peyton Jones, and Satnam Singh win Most Influential ICFP Paper AwardThis post highlights the award given to Simon Marlow, Simon Peyton Jones, and Satnam Singh for their 2009 paper on 'Runtime Support for Multicore Haskell.' Their work addressed bottlenecks in the Glasgow Haskell Compiler (GHC) runtime system, enabling Haskell to run efficiently on parallel hardware and achieve up to 8x speedups in benchmarks. This research was crucial for making Haskell suitable for large-scale computing, as demonstrated by its use in Facebook's abuse protection system, Sigma, which handles over 1 million requests per second and processes 20-30% more traffic than its predecessor.
  5. Fighting spam with HaskellThis post details the migration of Facebook's spam-fighting system, Sigma, from an in-house FXL language to Haskell. This involved replacing the interpreter-based FXL with a compiled, purely functional, and strongly typed language. Key technical contributions include the development and integration of the Haxl framework for automatic batching and concurrent data fetching, and the implementation of Applicative do-notation in GHC to exploit concurrency. The system also incorporates hot-swapping of compiled code for rapid deployment. Performance improvements of 20-30% were achieved, with specific optimizations in memoization, GHC heap management, and data marshaling. Resource limits were also implemented for stability.