WIP bpo-44800: Rename _PyInterpreterFrame to _Py_framedata

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, struct _interpreter_frame *f, int exc);
+PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(PyThreadState *tstate, _Py_framedata *fdata, int exc);
 
 PyAPI_FUNC(void) _PyEval_SetSwitchInterval(unsigned long microseconds);
 PyAPI_FUNC(unsigned long) _PyEval_GetSwitchInterval(void);

Include/cpython/frameobject.h

@@ -4,10 +4,26 @@
 #  error "this header file must not be included directly"
 #endif
 
+/* Starting in CPython 3.11, CPython separates the frame state between the
+ * full frame objects exposed by the Python and C runtime state introspection
+ * APIs, and internal lighter weight frame data structs, which are simple C
+ * structures owned by either the interpreter eval loop (while executing
+ * ordinary functions), by a generator or coroutine object (for frames that
+ * are able to be suspended), or by their corresponding full frame object (if
+ * a state instrospection API has been invoked and the full frame object has
+ * taken responsibility for the lifecycle of the frame data storage).
+ *
+ * This split storage eliminates a lot of allocation and deallocation of full
+ * Python objects during code execution, providing a significant speed gain
+ * over the previous approach of using full Python objects for both
+ * introspection and code execution.
+ */
+// Declaration of _Py_framedata is in cpython/pystate.h for use in PyThreadState
+
 struct _frame {
     PyObject_HEAD
     struct _frame *f_back;      /* previous frame, or NULL */
-    struct _interpreter_frame *f_frame; /* points to the frame data */
+    _Py_framedata *f_fdata;     /* points to the frame runtime data */
     PyObject *f_trace;          /* Trace function */
     int f_lineno;               /* Current line number. Only valid if non-zero */
     char f_trace_lines;         /* Emit per-line trace events? */
@@ -24,11 +40,6 @@ PyAPI_DATA(PyTypeObject) PyFrame_Type;
 PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *,
                                         PyObject *, PyObject *);
 
-/* only internal use */
-PyFrameObject*
-_PyFrame_New_NoTrack(struct _interpreter_frame *, int);
-
-
 /* The rest of the interface is specific for frame objects */
 
 /* Conversions between "fast locals" and locals in dictionary */

Include/cpython/pystate.h

@@ -69,6 +69,12 @@ typedef struct _stack_chunk {
     PyObject * data[1]; /* Variable sized */
 } _PyStackChunk;
 
+
+// Declared here so the thread state can use it without creating an include loop
+// See cpython/frameobject.h for an explanation of the type
+// See internal/pycore_framedata.h for the struct definition
+typedef struct _Py_execution_frame _Py_framedata;
+
 // The PyThreadState typedef is in Include/pystate.h.
 struct _ts {
     /* See Python/ceval.c for comments explaining most fields */
@@ -77,8 +83,8 @@ struct _ts {
     struct _ts *next;
     PyInterpreterState *interp;
 
-    /* Borrowed reference to the current frame (it can be NULL) */
-    struct _interpreter_frame *frame;
+    /* Borrowed reference to the current execution frame (it can be NULL) */
+    _Py_framedata *fdata;
     int recursion_depth;
     int recursion_headroom; /* Allow 50 more calls to handle any errors. */
     int stackcheck_counter;
@@ -223,7 +229,7 @@ PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
 
 /* Frame evaluation API */
 
-typedef PyObject* (*_PyFrameEvalFunction)(PyThreadState *tstate, struct _interpreter_frame *, int);
+typedef PyObject* (*_PyFrameEvalFunction)(PyThreadState *tstate, _Py_framedata *, int);
 
 PyAPI_FUNC(_PyFrameEvalFunction) _PyInterpreterState_GetEvalFrameFunc(
     PyInterpreterState *interp);

Include/genobject.h

@@ -15,8 +15,8 @@ extern "C" {
    and coroutine objects. */
 #define _PyGenObject_HEAD(prefix)                                           \
     PyObject_HEAD                                                           \
-    /* Note: gi_frame can be NULL if the generator is "finished" */         \
-    struct _interpreter_frame *prefix##_xframe;                             \
+    /* Note: gi_fdata can be NULL if the generator is "finished" */        \
+    _Py_framedata *prefix##_fdata;                                          \
     /* The code object backing the generator */                             \
     PyCodeObject *prefix##_code;                                            \
     /* List of weak reference. */                                           \

Include/internal/pycore_ceval.h

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

Include/internal/pycore_framedata.h

@@ -0,0 +1,133 @@
+#ifndef Py_INTERNAL_FRAMEDATA_H
+#define Py_INTERNAL_FRAMEDATA_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Internal-use-only frame object constructor */
+PyFrameObject*
+_PyFrame_New_NoTrack(_Py_framedata *, int);
+
+/* 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;
+
+// The _Py_framedata typedef is in Include/pyframeobject.h
+struct _Py_execution_frame {
+    PyObject *globals;
+    PyObject *builtins;
+    PyObject *locals;
+    PyCodeObject *code;
+    PyFrameObject *frame_obj; // Full frame object (if created)
+    /* Borrowed reference to a generator, or NULL */
+    PyObject *generator;
+    _Py_framedata *previous;
+    int lasti;       /* Last instruction if called */
+    int stackdepth;  /* Depth of value stack */
+    int nlocalsplus;
+    PyFrameState state;       /* What state the frame is in */
+    PyObject *stack[1];
+};
+
+static inline int _Py_framedata_IsRunnable(_Py_framedata *fdata) {
+    return fdata->state < FRAME_EXECUTING;
+}
+
+static inline int _Py_framedata_IsExecuting(_Py_framedata *fdata) {
+    return fdata->state == FRAME_EXECUTING;
+}
+
+static inline int _Py_framedata_HasCompleted(_Py_framedata *fdata) {
+    return fdata->state > FRAME_EXECUTING;
+}
+
+#define FRAME_SPECIALS_SIZE ((sizeof(_Py_framedata)-1)/sizeof(PyObject *))
+
+_Py_framedata *
+_Py_framedata_HeapAlloc(PyFrameConstructor *con, PyObject *locals);
+
+static inline void
+_Py_framedata_InitializeSpecials(
+    _Py_framedata *fdata, PyFrameConstructor *con,
+    PyObject *locals, int nlocalsplus)
+{
+    fdata->code = (PyCodeObject *)Py_NewRef(con->fc_code);
+    fdata->builtins = Py_NewRef(con->fc_builtins);
+    fdata->globals = Py_NewRef(con->fc_globals);
+    fdata->locals = Py_XNewRef(locals);
+    fdata->nlocalsplus = nlocalsplus;
+    fdata->stackdepth = 0;
+    fdata->frame_obj = NULL;
+    fdata->generator = NULL;
+    fdata->lasti = -1;
+    fdata->state = FRAME_CREATED;
+}
+
+/* Gets the pointer to the locals array
+ * that precedes this frame.
+ */
+static inline PyObject**
+_Py_framedata_GetLocalsArray(_Py_framedata *fdata)
+{
+    return ((PyObject **)fdata) - fdata->nlocalsplus;
+}
+
+/* For use by _Py_framedata_GetFrameObject
+  Do not call directly. */
+PyFrameObject *
+_Py_framedata_MakeAndSetFrameObject(_Py_framedata *fdata);
+
+/* Gets the PyFrameObject for this frame, lazily
+ * creating it if necessary.
+ * Returns a borrowed referennce */
+static inline PyFrameObject *
+_Py_framedata_GetFrameObject(_Py_framedata *fdata)
+{
+    PyFrameObject *res = fdata->frame_obj;
+    if (res != NULL) {
+        return res;
+    }
+    return _Py_framedata_MakeAndSetFrameObject(fdata);
+}
+
+/* Clears all references in the frame.
+ * If take is non-zero, then the execution 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
+_Py_framedata_Clear(_Py_framedata *fdata, int take);
+
+int
+_Py_framedata_Traverse(_Py_framedata *fdata, visitproc visit, void *arg);
+
+int
+_Py_framedata_FastToLocalsWithError(_Py_framedata *frame);
+
+void
+_Py_framedata_LocalsToFast(_Py_framedata *frame, int clear);
+
+_Py_framedata *_PyThreadState_Push_framedata(
+    PyThreadState *tstate, PyFrameConstructor *con, PyObject *locals);
+
+void _PyThreadState_Pop_framedata(PyThreadState *tstate, _Py_framedata *frame);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_FRAMEDATA_H */

Lib/test/test_socket.py

@@ -2090,11 +2090,11 @@ def _testSendFrame(self):
         self.cf = self.build_can_frame(0x00, b'\x01\x02\x03\x04\x05')
         self.cli.send(self.cf)
 
-    def testSendMaxFrame(self):
+    def testSendMafdata(self):
         cf, addr = self.s.recvfrom(self.bufsize)
         self.assertEqual(self.cf, cf)
 
-    def _testSendMaxFrame(self):
+    def _testSendMafdata(self):
         self.cf = self.build_can_frame(0x00, b'\x07' * 8)
         self.cli.send(self.cf)