The component of the RPython toolchain that performs a form of type inference on the flow graph. See The Annotation Pass in the documentation.
Code generator that converts an RPython Language 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”.
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 RPython’s garbage collectors in Python itself.
a small test that checks if assumptions the JIT makes during tracing are still true
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 Typer.
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 typesystem.
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.
An object oriented type model <oo-type> containing classes and instances. A backend that uses this type system is also called a high-level backend. The JVM and CLI backends (now removed) used this typesystem.
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.
RPython Language, 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 in.
RPython toolchain
The Annotation Pass, The RPython Typer, and various backends.
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.
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 Annotation Pass section.