PyPy, like any large project, has developed a jargon of its own. This
document gives brief definition of some of these terms and provides
links to more information.
- The component of the RPython toolchain that performs a form
of type inference on the flow graph. See the annotator pass
in the documentation.
- application level
- applevel code is normal Python code running on top of the PyPy or
CPython interpreter (see interpreter level)
- Code generator that converts an RPython program to a target
language using the RPython toolchain.
- In the context of the JIT, compile time is when the JIT is
generating machine code “just in time”.
- The “default” implementation of Python, written in C and
distributed by the PSF on http://www.python.org.
- external function
- Functions that we don’t want to implement in Python for various
reasons (e.g. they need to make calls into the OS) and whose
implementation will be provided by the backend.
- garbage collection framework
- Code that makes it possible to write PyPy’s garbage collectors
in Python itself.
- interpreter level
- Code running at this level is part of the implementation of the
PyPy interpreter and cannot interact normally with application
level code; it typically provides implementation for an object
space and its builtins.
- just in time compiler.
- Piece of code that is able to interpret flow graphs. This is very
useful for testing purposes, especially if you work on the RPython
- A C-like type model that contains
structs and pointers. A backend that uses this type system is also
called a low-level backend. The C backend uses this
- low-level helper
- A function that the RTyper can use a call to as part of implementing
some operation in terms of the target type system.
- mixed module
- a module that accesses PyPy’s interpreter level. The name comes
from the fact that the module’s implementation can be a mixture of
application level and interpreter level code.
- object space
- The object space (often abbreviated to
“objspace”) creates all objects and knows how to perform operations
on the objects. You may think of an object space as being a library
offering a fixed API, a set of operations, with implementations
that a) correspond to the known semantics of Python objects, b)
extend or twist these semantics, or c) serve whole-program analysis
- prebuilt constant
- In RPython module globals are considered constants. Moreover,
global (i.e. prebuilt) lists and dictionaries are supposed to be
immutable (“prebuilt constant” is sometimes abbreviated to “pbc”).
- JIT terminology. promotion is a way of “using” a run-time
value at compile-time, essentially by deferring compilation
until the run-time value is known. See if the jit docs help.
- Restricted Python, a limited subset of the Python language.
The limitations make type inference possible.
It is also the language that the PyPy interpreter itself is written
- RPython toolchain
- The annotator pass, The RPython Typer, and various
- Based on the type annotations, the RPython Typer turns the flow
graph into one that fits the model of the target platform/backend
using either the lltypesystem or the ootypesystem.
- In the context of the JIT, run time is when the code the JIT has
generated is executing.
- A way of controlling how a specific function is handled by the
annotator. One specialization is to treat calls to a function
with different argument types as if they were calls to different
functions with identical source.
- Technology that enables various forms of non conventional control
flow, such as coroutines, greenlets and tasklets. Inspired by
Christian Tismer’s Stackless Python.
- standard interpreter
- It is the subsystem implementing the Python language, composed
of the bytecode interpreter and of the standard objectspace.
- Code that modifies flowgraphs to weave in translation aspects
- In the context of the JIT, translation time is when the PyPy
source is being analyzed and the JIT itself is being created.
- Tool based on the PyPy interpreter which can translate
sufficiently static Python programs into low-level code.
- type system
- The RTyper can target either the lltypesystem or the ootypesystem.
- type inference
- Deduces either partially or fully the type of expressions as
described in this type inference article on Wikipedia.
The RPython toolchain‘s flavour of type inference is described
in the annotator pass section.