Tier 2 interpreter experiment (diff only for viewing, DO NOT MERGE)

.gitattributes

@@ -83,6 +83,7 @@ Parser/token.c                                      generated
 Programs/test_frozenmain.h                          generated
 Python/Python-ast.c                                 generated
 Python/generated_cases.c.h                          generated
+Python/tier2_typepropagator.c.h                     generated
 Python/opcode_targets.h                             generated
 Python/stdlib_module_names.h                        generated
 Tools/peg_generator/pegen/grammar_parser.py         generated

CS4215.md

@@ -0,0 +1,40 @@
+# A Lazy Basic Block Versioning Interpreter for CPython.
+
+# Build instructions
+
+You should follow the official CPython build instructions for your platform.
+https://devguide.python.org/getting-started/setup-building/
+
+We have one major difference - you must have a pre-existing Python installation.
+Preferrably Python 3.9 or higher. On MacOS/Unix systems, that Python installation
+*must* be located at `python3`.
+
+The main reason for this limitation is that Python is used to bootstrap the compilation
+of Python. However, since our interpreter is unable to run a large part of the Python
+language, our interpreter cannot be used as a bootstrap Python.
+
+During the build process, errors may be printed, and the build process may error. However,
+the final Python executable should still be generated.
+
+# Where are files located?
+
+The majority of the changes and functionality are in `Python/tier2.c` where Doxygen documentation
+is written alongside the code, and in `Tools/cases_generator/` which contains the DSL implementation.
+
+# Running tests
+
+We've written simple tests of the main functionalities.
+Unfortunately we did not have time to write comprehensive tests, and it doesn't seem worth it eitherways given the experimental nature of this project.
+
+After building, run `python tier2_test.py` in the repository's root folder.
+
+# Debugging output
+
+In `tier2.c`, two flags can be set to print debug messages:
+```c
+// Prints codegen debug messages
+#define BB_DEBUG 0
+
+// Prints typeprop debug messages
+#define TYPEPROP_DEBUG 0
+```

Include/cpython/code.h

@@ -56,6 +56,95 @@ typedef struct {
     PyObject *_co_freevars;
 } _PyCoCached;
 
+// TYPENODE is a tagged pointer that uses the last 2 LSB as the tag
+#define _Py_TYPENODE_t uintptr_t
+
+// TYPENODE Tags
+typedef enum _Py_TypeNodeTags {
+    // Node is unused
+    TYPE_NULL = 0,
+    // TYPE_ROOT can point to a PyTypeObject or be a NULL
+    TYPE_ROOT = 1,
+    // TYPE_REF points to a TYPE_ROOT or a TYPE_REF
+    TYPE_REF  = 2
+} _Py_TypeNodeTags;
+
+#define _Py_TYPENODE_GET_TAG(typenode) ((typenode) & (0b11))
+#define _Py_TYPENODE_CLEAR_TAG(typenode) ((typenode) & (~(uintptr_t)(0b11)))
+
+#define _Py_TYPENODE_MAKE_ROOT(ptr) (_Py_TYPENODE_CLEAR_TAG(ptr) | TYPE_ROOT)
+#define _Py_TYPENODE_MAKE_REF(ptr) (_Py_TYPENODE_CLEAR_TAG(ptr) | TYPE_REF)
+
+#define _Py_TYPENODE_NULL 0
+#define _Py_TYPENODE_NULLROOT _Py_TYPENODE_MAKE_ROOT(_Py_TYPENODE_NULL)
+
+// Tier 2 types meta interpreter
+typedef struct _PyTier2TypeContext {
+    // points into type_stack, points to one element after the stack
+    _Py_TYPENODE_t *type_stack_ptr;
+    int type_locals_len;
+    int type_stack_len;
+    _Py_TYPENODE_t *type_stack;
+    _Py_TYPENODE_t *type_locals;
+} _PyTier2TypeContext;
+
+// Tier 2 interpreter information
+typedef struct _PyTier2BBMetadata {
+    // Index into _PyTier2Info->bb_data
+    int id;
+    _PyTier2TypeContext *type_context;
+    _Py_CODEUNIT *tier2_start;
+    // Note, this is the first tier 1 instruction to execute AFTER the BB ends.
+    _Py_CODEUNIT *tier1_end;
+} _PyTier2BBMetadata;
+
+// Bump allocator for basic blocks (overallocated)
+typedef struct _PyTier2BBSpace  {
+    // (in bytes)
+    Py_ssize_t max_capacity;
+    // How much space has been consumed in bbs. (in bytes)
+    Py_ssize_t water_level;
+    // There's extra memory at the end of this.
+    _Py_CODEUNIT u_code[1];
+} _PyTier2BBSpace;
+
+typedef struct _PyTier2BBStartTypeContextTriplet {
+    int id;
+    _Py_CODEUNIT *tier1_start;
+    // This is a strong reference. So during cleanup we need to free this.
+    _PyTier2TypeContext *start_type_context;
+} _PyTier2BBStartTypeContextTriplet;
+
+// Tier 2 info stored in the code object. Lazily allocated.
+typedef struct _PyTier2Info {
+    /* the tier 2 basic block to execute (if any) */
+    _PyTier2BBMetadata *_entry_bb;
+    _PyTier2BBSpace *_bb_space;
+    // Keeps track of offset of jump targets (in number of codeunits)
+    // from co_code_adaptive.
+    int backward_jump_count;
+    int *backward_jump_offsets;
+    // Each backward jump offset will have a corresponding array of _PyTier2BBMetadata *
+    // This allows us to find a suitable BB on a backward jump.
+    // So backward jump offset [1, 2, 3 ,4]
+    // will have [[BB_ID1, BB_ID2], [BB_ID3,], [], []]
+    // etc.
+    _PyTier2BBStartTypeContextTriplet **backward_jump_target_bb_pairs;
+    // Max len of bb_data
+    int bb_data_len;
+    // Current index to write into in bb_data. Incremented after each write.
+    // This also assigns the BB ID.
+    int bb_data_curr;
+    _PyTier2BBMetadata **bb_data;
+
+    // @TODO:
+    //   Potentially optimise _PyTier2TypeContext by allocating the stacksize
+    //   to the size needed for the snapshot, and the type propagation is performed
+    //   on type_metainterpreter_stack_scratch which is allocated only once per
+    //   code object.
+    // PyTypeObject** type_metainterpreter_stack_scratch;
+} _PyTier2Info;
+
 // To avoid repeating ourselves in deepfreeze.py, all PyCodeObject members are
 // defined in this macro:
 #define _PyCode_DEF(SIZE) {                                                    \
@@ -116,6 +205,8 @@ typedef struct {
     _PyCoCached *_co_cached;      /* cached co_* attributes */                 \
     int _co_firsttraceable;       /* index of first traceable instruction */   \
     char *_co_linearray;          /* array of line offsets */                  \
+    int _tier2_warmup;            /* warmup counter for tier 2 */              \
+    _PyTier2Info *_tier2_info;        /* info required for tier 2, lazily alloc */ \
     /* Scratch space for extra data relating to the code object.               \
        Type is a void* to keep the format private in codeobject.c to force     \
        people to go through the proper APIs. */                                \

Include/internal/pycore_code.h

@@ -6,6 +6,16 @@ extern "C" {
 
 #define CODE_MAX_WATCHERS 8
 
+typedef struct {
+    // Unique ID (for this code object) for this basic block. This indexes into
+    // the PyTier2Info bb_data field.
+    // The LSB indicates whether the bb branch is a type guard or not.
+    // To get the actual BB ID, do a right bit shift by one.
+    uint16_t bb_id_tagged;
+} _PyBBBranchCache;
+
+#define INLINE_CACHE_ENTRIES_BB_BRANCH CACHE_ENTRIES(_PyBBBranchCache)
+
 /* PEP 659
  * Specialization and quickening structs and helper functions
  */
@@ -238,14 +248,44 @@ extern void _Py_Specialize_CompareOp(PyObject *lhs, PyObject *rhs,
                                      _Py_CODEUNIT *instr, int oparg);
 extern void _Py_Specialize_UnpackSequence(PyObject *seq, _Py_CODEUNIT *instr,
                                           int oparg);
-extern void _Py_Specialize_ForIter(PyObject *iter, _Py_CODEUNIT *instr, int oparg);
+extern void _Py_Specialize_ForIter(PyObject *iter, _Py_CODEUNIT *instr, int oparg, char is_bb);
 extern void _Py_Specialize_Send(PyObject *receiver, _Py_CODEUNIT *instr);
 
 /* Finalizer function for static codeobjects used in deepfreeze.py */
 extern void _PyStaticCode_Fini(PyCodeObject *co);
 /* Function to intern strings of codeobjects and quicken the bytecode */
 extern int _PyStaticCode_Init(PyCodeObject *co);
 
+/* Tier 2 interpreter */
+
+// gen_bb_is_successor:
+//   true = successor
+//   false = alternate
+// gen_bb_requires_pop (maximum 7):
+//   For tier2 type propagation, handling of jump instructions with
+//   runtime-dependent stack effect.
+//   This flag is used to determine if the type context of a new bb
+//   requires a stack element to be popped.
+#define BB_TEST(gen_bb_is_successor, gen_bb_requires_pop) \
+    (((gen_bb_is_successor) << 4) | (gen_bb_requires_pop))
+#define BB_TEST_IS_SUCCESSOR(bb_test) ((bb_test) >> 4)
+#define BB_TEST_GET_N_REQUIRES_POP(bb_test) ((bb_test) & 0b1111)
+
+extern _Py_CODEUNIT *_PyCode_Tier2Warmup(struct _PyInterpreterFrame *,
+    _Py_CODEUNIT *);
+extern _Py_CODEUNIT *_PyTier2_GenerateNextBB(
+    struct _PyInterpreterFrame *frame,
+    uint16_t bb_id_tagged,
+    _Py_CODEUNIT *curr_executing_instr,
+    int jumpby,
+    _Py_CODEUNIT **tier1_fallback,
+    char bb_flag);
+extern _Py_CODEUNIT *_PyTier2_LocateJumpBackwardsBB(
+    struct _PyInterpreterFrame *frame, uint16_t bb_id, int jumpby,
+    _Py_CODEUNIT **tier1_fallback, _Py_CODEUNIT *curr, int stacksize);
+extern void _PyTier2_RewriteForwardJump(_Py_CODEUNIT *bb_branch, _Py_CODEUNIT *target);
+extern void _PyTier2_RewriteBackwardJump(_Py_CODEUNIT *jump_backward_lazy, _Py_CODEUNIT *target);
+void _PyTier2TypeContext_Free(_PyTier2TypeContext *type_context);
 #ifdef Py_STATS
 
 
@@ -503,7 +543,6 @@ extern uint32_t _Py_next_func_version;
 
 #define COMPARISON_NOT_EQUALS (COMPARISON_UNORDERED | COMPARISON_LESS_THAN | COMPARISON_GREATER_THAN)
 
-
 #ifdef __cplusplus
 }
 #endif

Include/internal/pycore_frame.h

@@ -62,12 +62,19 @@ typedef struct _PyInterpreterFrame {
     int stacktop;  /* Offset of TOS from localsplus  */
     uint16_t yield_offset;
     char owner;
-    /* Locals and stack */
+    /* Locals and stack and unboxed bit mask */
     PyObject *localsplus[1];
 } _PyInterpreterFrame;
 
-#define _PyInterpreterFrame_LASTI(IF) \
-    ((int)((IF)->prev_instr - _PyCode_CODE((IF)->f_code)))
+static inline int
+_PyInterpreterFrame_LASTI(_PyInterpreterFrame *f) {
+    if (f->f_code->_tier2_info != NULL) {
+        return ((int)((f)->prev_instr - f->f_code->_tier2_info->_bb_space->u_code));
+    }
+    return ((int)((f)->prev_instr - _PyCode_CODE((f)->f_code)));
+}
+//#define _PyInterpreterFrame_LASTI(IF) \
+//    ((int)((IF)->prev_instr - _PyCode_CODE((IF)->f_code)))
 
 static inline PyObject **_PyFrame_Stackbase(_PyInterpreterFrame *f) {
     return f->localsplus + f->f_code->co_nlocalsplus;
@@ -98,7 +105,10 @@ _PyFrame_NumSlotsForCodeObject(PyCodeObject *code)
     /* This function needs to remain in sync with the calculation of
      * co_framesize in Tools/build/deepfreeze.py */
     assert(code->co_framesize >= FRAME_SPECIALS_SIZE);
-    return code->co_framesize - FRAME_SPECIALS_SIZE;
+    int res = code->co_framesize - FRAME_SPECIALS_SIZE -
+        (code->co_nlocalsplus * sizeof(char) / sizeof(PyObject *) + 1);
+    assert(res > 0);
+    return res;
 }
 
 void _PyFrame_Copy(_PyInterpreterFrame *src, _PyInterpreterFrame *dest);
@@ -119,7 +129,12 @@ _PyFrame_Initialize(
     frame->f_locals = locals;
     frame->stacktop = code->co_nlocalsplus;
     frame->frame_obj = NULL;
-    frame->prev_instr = _PyCode_CODE(code) - 1;
+    if (code->_tier2_info != NULL) {
+        frame->prev_instr = code->_tier2_info->_entry_bb->tier2_start - 1;
+    }
+    else {
+        frame->prev_instr = _PyCode_CODE(code) - 1;
+    }
     frame->yield_offset = 0;
     frame->owner = FRAME_OWNED_BY_THREAD;
 
@@ -128,6 +143,15 @@ _PyFrame_Initialize(
     }
 }
 
+// The unboxed bitmask. true indicates an unboxed value. false indicates a normal PyObject.
+static inline char*
+_PyFrame_GetUnboxedBitMask(_PyInterpreterFrame *frame)
+{
+    PyCodeObject *co = frame->f_code;
+    return (char *)(frame + co->co_framesize -
+        (co->co_nlocalsplus * sizeof(char) / sizeof(PyObject *) + 1));
+}
+
 /* Gets the pointer to the locals array
  * that precedes this frame.
  */