bpo-44590: Lazily allocate frame objects

Include/cpython/ceval.h

@@ -19,7 +19,7 @@ PyAPI_FUNC(PyObject *) _PyEval_GetBuiltinId(_Py_Identifier *);
    flag was set, else return 0. */
 PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf);
 
-PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int exc);
+PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(PyThreadState *tstate, struct _interpreter_frame *f, int exc);
 
 PyAPI_FUNC(void) _PyEval_SetSwitchInterval(unsigned long microseconds);
 PyAPI_FUNC(unsigned long) _PyEval_GetSwitchInterval(void);

Include/cpython/frameobject.h

@@ -4,50 +4,17 @@
 #  error "this header file must not be included directly"
 #endif
 
-/* These values are chosen so that the inline functions below all
- * compare f_state to zero.
- */
-enum _framestate {
-    FRAME_CREATED = -2,
-    FRAME_SUSPENDED = -1,
-    FRAME_EXECUTING = 0,
-    FRAME_RETURNED = 1,
-    FRAME_UNWINDING = 2,
-    FRAME_RAISED = 3,
-    FRAME_CLEARED = 4
-};
-
-typedef signed char PyFrameState;
-
 struct _frame {
     PyObject_HEAD
     struct _frame *f_back;      /* previous frame, or NULL */
-    PyObject **f_valuestack;    /* points after the last local */
+    struct _interpreter_frame *f_frame; /* points to the frame data */
     PyObject *f_trace;          /* Trace function */
-    /* Borrowed reference to a generator, or NULL */
-    PyObject *f_gen;
-    int f_stackdepth;           /* Depth of value stack */
-    int f_lasti;                /* Last instruction if called */
     int f_lineno;               /* Current line number. Only valid if non-zero */
-    PyFrameState f_state;       /* What state the frame is in */
     char f_trace_lines;         /* Emit per-line trace events? */
     char f_trace_opcodes;       /* Emit per-opcode trace events? */
     char f_own_locals_memory;   /* This frame owns the memory for the locals */
-    PyObject **f_localsptr;     /* Pointer to locals, cells, free */
 };
 
-static inline int _PyFrame_IsRunnable(struct _frame *f) {
-    return f->f_state < FRAME_EXECUTING;
-}
-
-static inline int _PyFrame_IsExecuting(struct _frame *f) {
-    return f->f_state == FRAME_EXECUTING;
-}
-
-static inline int _PyFrameHasCompleted(struct _frame *f) {
-    return f->f_state > FRAME_EXECUTING;
-}
-
 /* Standard object interface */
 
 PyAPI_DATA(PyTypeObject) PyFrame_Type;
@@ -59,7 +26,7 @@ PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *,
 
 /* only internal use */
 PyFrameObject*
-_PyFrame_New_NoTrack(PyThreadState *, PyFrameConstructor *, PyObject *, PyObject **);
+_PyFrame_New_NoTrack(struct _interpreter_frame *, int);
 
 
 /* The rest of the interface is specific for frame objects */

Include/cpython/pystate.h

@@ -78,7 +78,7 @@ struct _ts {
     PyInterpreterState *interp;
 
     /* Borrowed reference to the current frame (it can be NULL) */
-    PyFrameObject *frame;
+    struct _interpreter_frame *frame;
     int recursion_depth;
     int recursion_headroom; /* Allow 50 more calls to handle any errors. */
     int stackcheck_counter;
@@ -223,7 +223,7 @@ PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
 
 /* Frame evaluation API */
 
-typedef PyObject* (*_PyFrameEvalFunction)(PyThreadState *tstate, PyFrameObject *, int);
+typedef PyObject* (*_PyFrameEvalFunction)(PyThreadState *tstate, struct _interpreter_frame *, int);
 
 PyAPI_FUNC(_PyFrameEvalFunction) _PyInterpreterState_GetEvalFrameFunc(
     PyInterpreterState *interp);

Include/genobject.h

@@ -16,9 +16,9 @@ extern "C" {
 #define _PyGenObject_HEAD(prefix)                                           \
     PyObject_HEAD                                                           \
     /* Note: gi_frame can be NULL if the generator is "finished" */         \
-    PyFrameObject *prefix##_frame;                                          \
+    struct _interpreter_frame *prefix##_xframe;                             \
     /* The code object backing the generator */                             \
-    PyCodeObject *prefix##_code;                                                \
+    PyCodeObject *prefix##_code;                                            \
     /* List of weak reference. */                                           \
     PyObject *prefix##_weakreflist;                                         \
     /* Name of the generator. */                                            \

Include/internal/pycore_ceval.h

@@ -41,9 +41,9 @@ extern PyObject *_PyEval_BuiltinsFromGlobals(
 
 
 static inline PyObject*
-_PyEval_EvalFrame(PyThreadState *tstate, PyFrameObject *f, int throwflag)
+_PyEval_EvalFrame(PyThreadState *tstate, struct _interpreter_frame *frame, int throwflag)
 {
-    return tstate->interp->eval_frame(tstate, f, throwflag);
+    return tstate->interp->eval_frame(tstate, frame, throwflag);
 }
 
 extern PyObject *
@@ -107,6 +107,9 @@ static inline void _Py_LeaveRecursiveCall_inline(void)  {
 
 #define Py_LeaveRecursiveCall() _Py_LeaveRecursiveCall_inline()
 
+struct _interpreter_frame *_PyEval_GetFrame(void);
+
+PyObject *_Py_MakeCoro(PyFrameConstructor *, struct _interpreter_frame *);
 
 #ifdef __cplusplus
 }

Include/internal/pycore_frame.h

@@ -4,41 +4,123 @@
 extern "C" {
 #endif
 
-enum {
-    FRAME_SPECIALS_GLOBALS_OFFSET = 0,
-    FRAME_SPECIALS_BUILTINS_OFFSET = 1,
-    FRAME_SPECIALS_LOCALS_OFFSET = 2,
-    FRAME_SPECIALS_CODE_OFFSET = 3,
-    FRAME_SPECIALS_SIZE = 4
+/* These values are chosen so that the inline functions below all
+ * compare f_state to zero.
+ */
+enum _framestate {
+    FRAME_CREATED = -2,
+    FRAME_SUSPENDED = -1,
+    FRAME_EXECUTING = 0,
+    FRAME_RETURNED = 1,
+    FRAME_UNWINDING = 2,
+    FRAME_RAISED = 3,
+    FRAME_CLEARED = 4
 };
 
-static inline PyObject **
-_PyFrame_Specials(PyFrameObject *f) {
-    return &f->f_valuestack[-FRAME_SPECIALS_SIZE];
+typedef signed char PyFrameState;
+
+typedef struct _interpreter_frame {
+    PyObject *f_globals;
+    PyObject *f_builtins;
+    PyObject *f_locals;
+    PyCodeObject *f_code;
+    PyFrameObject *frame_obj;
+    /* Borrowed reference to a generator, or NULL */
+    PyObject *generator;
+    struct _interpreter_frame *previous;
+    int f_lasti;       /* Last instruction if called */
+    int stackdepth;  /* Depth of value stack */
+    int nlocalsplus;
+    PyFrameState f_state;       /* What state the frame is in */
+    PyObject *stack[1];
+} InterpreterFrame;
+
+static inline int _PyFrame_IsRunnable(InterpreterFrame *f) {
+    return f->f_state < FRAME_EXECUTING;
+}
+
+static inline int _PyFrame_IsExecuting(InterpreterFrame *f) {
+    return f->f_state == FRAME_EXECUTING;
 }
 
-/* Returns a *borrowed* reference. */
-static inline PyObject *
-_PyFrame_GetGlobals(PyFrameObject *f)
+static inline int _PyFrameHasCompleted(InterpreterFrame *f) {
+    return f->f_state > FRAME_EXECUTING;
+}
+
+#define FRAME_SPECIALS_SIZE ((sizeof(InterpreterFrame)-1)/sizeof(PyObject *))
+
+InterpreterFrame *
+_PyInterpreterFrame_HeapAlloc(PyFrameConstructor *con, PyObject *locals);
+
+static inline void
+_PyFrame_InitializeSpecials(
+    InterpreterFrame *frame, PyFrameConstructor *con,
+    PyObject *locals, int nlocalsplus)
 {
-    return _PyFrame_Specials(f)[FRAME_SPECIALS_GLOBALS_OFFSET];
+    frame->f_code = (PyCodeObject *)Py_NewRef(con->fc_code);
+    frame->f_builtins = Py_NewRef(con->fc_builtins);
+    frame->f_globals = Py_NewRef(con->fc_globals);
+    frame->f_locals = Py_XNewRef(locals);
+    frame->nlocalsplus = nlocalsplus;
+    frame->stackdepth = 0;
+    frame->frame_obj = NULL;
+    frame->generator = NULL;
+    frame->f_lasti = -1;
+    frame->f_state = FRAME_CREATED;
 }
 
-/* Returns a *borrowed* reference. */
-static inline PyObject *
-_PyFrame_GetBuiltins(PyFrameObject *f)
+/* Gets the pointer to the locals array
+ * that precedes this frame.
+ */
+static inline PyObject**
+_PyFrame_GetLocalsArray(InterpreterFrame *frame)
 {
-    return _PyFrame_Specials(f)[FRAME_SPECIALS_BUILTINS_OFFSET];
+    return ((PyObject **)frame) - frame->nlocalsplus;
 }
 
-/* Returns a *borrowed* reference. */
-static inline PyCodeObject *
-_PyFrame_GetCode(PyFrameObject *f)
+/* For use by _PyFrame_GetFrameObject
+  Do not call directly. */
+PyFrameObject *
+_PyFrame_MakeAndSetFrameObject(InterpreterFrame *frame);
+
+/* Gets the PyFrameObject for this frame, lazily
+ * creating it if necessary.
+ * Returns a borrowed referennce */
+static inline PyFrameObject *
+_PyFrame_GetFrameObject(InterpreterFrame *frame)
 {
-    return (PyCodeObject *)_PyFrame_Specials(f)[FRAME_SPECIALS_CODE_OFFSET];
+    PyFrameObject *res =  frame->frame_obj;
+    if (res != NULL) {
+        return res;
+    }
+    return _PyFrame_MakeAndSetFrameObject(frame);
 }
 
-int _PyFrame_TakeLocals(PyFrameObject *f);
+/* Clears all references in the frame.
+ * If take is non-zero, then the InterpreterFrame frame
+ * may be transfered to the frame object it references
+ * instead of being cleared. Either way
+ * the caller no longer owns the references
+ * in the frame.
+ * take should  be set to 1 for heap allocated
+ * frames like the ones in generators and coroutines.
+ */
+int
+_PyFrame_Clear(InterpreterFrame * frame, int take);
+
+int
+_PyFrame_Traverse(InterpreterFrame *frame, visitproc visit, void *arg);
+
+int
+_PyFrame_FastToLocalsWithError(InterpreterFrame *frame);
+
+void
+_PyFrame_LocalsToFast(InterpreterFrame *frame, int clear);
+
+InterpreterFrame *_PyThreadState_PushFrame(
+    PyThreadState *tstate, PyFrameConstructor *con, PyObject *locals);
+
+void _PyThreadState_PopFrame(PyThreadState *tstate, InterpreterFrame *frame);
 
 #ifdef __cplusplus
 }

Include/internal/pycore_pystate.h

@@ -147,9 +147,6 @@ PyAPI_FUNC(int) _PyState_AddModule(
 
 PyAPI_FUNC(int) _PyOS_InterruptOccurred(PyThreadState *tstate);
 
-PyObject **_PyThreadState_PushLocals(PyThreadState *, int size);
-void _PyThreadState_PopLocals(PyThreadState *, PyObject **);
-
 #ifdef __cplusplus
 }
 #endif

Lib/test/test_faulthandler.py

@@ -56,6 +56,7 @@ def temporary_filename():
         os_helper.unlink(filename)
 
 class FaultHandlerTests(unittest.TestCase):
+
     def get_output(self, code, filename=None, fd=None):
         """
         Run the specified code in Python (in a new child process) and read the

Lib/test/test_sys.py

@@ -1275,7 +1275,7 @@ class C(object): pass
         # frame
         import inspect
         x = inspect.currentframe()
-        check(x, size('4P3i4cP'))
+        check(x, size('3Pi3c'))
         # function
         def func(): pass
         check(func, size('14Pi'))

Makefile.pre.in

@@ -350,6 +350,7 @@ PYTHON_OBJS=	\
 		Python/context.o \
 		Python/dynamic_annotations.o \
 		Python/errors.o \
+		Python/frame.o \
 		Python/frozenmain.o \
 		Python/future.o \
 		Python/getargs.o \

Misc/NEWS.d/next/Core and Builtins/2021-07-09-12-08-17.bpo-44590.a2ntVX.rst

@@ -0,0 +1,5 @@
+All necessary data for executing a Python function (local variables, stack,
+etc) is now kept in a per-thread stack. Frame objects are lazily allocated
+on demand. This increases performance by about 7% on the standard benchmark
+suite. Introspection and debugging are unaffected as frame objects are
+always available when needed. Patch by Mark Shannon.

Modules/_tracemalloc.c

@@ -3,7 +3,7 @@
 #include "pycore_pymem.h"         // _Py_tracemalloc_config
 #include "pycore_traceback.h"
 #include "pycore_hashtable.h"
-#include "frameobject.h"          // PyFrame_GetBack()
+#include <pycore_frame.h>
 
 #include "clinic/_tracemalloc.c.h"
 /*[clinic input]
@@ -299,18 +299,16 @@ hashtable_compare_traceback(const void *key1, const void *key2)
 
 
 static void
-tracemalloc_get_frame(PyFrameObject *pyframe, frame_t *frame)
+tracemalloc_get_frame(InterpreterFrame *pyframe, frame_t *frame)
 {
     frame->filename = unknown_filename;
-    int lineno = PyFrame_GetLineNumber(pyframe);
+    int lineno = PyCode_Addr2Line(pyframe->f_code, pyframe->f_lasti*2);
     if (lineno < 0) {
         lineno = 0;
     }
     frame->lineno = (unsigned int)lineno;
 
-    PyCodeObject *code = PyFrame_GetCode(pyframe);
-    PyObject *filename = code->co_filename;
-    Py_DECREF(code);
+    PyObject *filename = pyframe->f_code->co_filename;
 
     if (filename == NULL) {
 #ifdef TRACE_DEBUG
@@ -395,7 +393,7 @@ traceback_get_frames(traceback_t *traceback)
         return;
     }
 
-    PyFrameObject *pyframe = PyThreadState_GetFrame(tstate);
+    InterpreterFrame *pyframe = tstate->frame;
     for (; pyframe != NULL;) {
         if (traceback->nframe < _Py_tracemalloc_config.max_nframe) {
             tracemalloc_get_frame(pyframe, &traceback->frames[traceback->nframe]);
@@ -406,8 +404,7 @@ traceback_get_frames(traceback_t *traceback)
             traceback->total_nframe++;
         }
 
-        PyFrameObject *back = PyFrame_GetBack(pyframe);
-        Py_DECREF(pyframe);
+        InterpreterFrame *back = pyframe->previous;
         pyframe = back;
     }
 }

Modules/_xxsubinterpretersmodule.c

@@ -4,6 +4,7 @@
 
 #include "Python.h"
 #include "frameobject.h"
+#include "pycore_frame.h"
 #include "interpreteridobject.h"
 
 
@@ -1834,13 +1835,12 @@ _is_running(PyInterpreterState *interp)
     }
 
     assert(!PyErr_Occurred());
-    PyFrameObject *frame = PyThreadState_GetFrame(tstate);
+    InterpreterFrame *frame = tstate->frame;
     if (frame == NULL) {
         return 0;
     }
 
     int executing = _PyFrame_IsExecuting(frame);
-    Py_DECREF(frame);
 
     return executing;
 }