Use per-threadstate allocated memory chunks for local variables. Dumb and slow implementation.

Author: markshannon

Include/cpython/frameobject.h

@@ -63,7 +63,7 @@ PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *,
 
 /* only internal use */
 PyFrameObject*
-_PyFrame_New_NoTrack(PyThreadState *, PyFrameConstructor *, PyObject *);
+_PyFrame_New_NoTrack(PyThreadState *, PyFrameConstructor *, PyObject *, PyObject **);
 
 
 /* The rest of the interface is specific for frame objects */
@@ -78,3 +78,5 @@ PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *);
 PyAPI_FUNC(void) _PyFrame_DebugMallocStats(FILE *out);
 
 PyAPI_FUNC(PyFrameObject *) PyFrame_GetBack(PyFrameObject *frame);
+
+int _PyFrame_MakeCopyOfLocals(PyFrameObject *f);

Include/internal/pycore_pystate.h

@@ -147,6 +147,9 @@ 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_sys.py

@@ -1274,11 +1274,7 @@ class C(object): pass
         # frame
         import inspect
         x = inspect.currentframe()
-        ncells = len(x.f_code.co_cellvars)
-        nfrees = len(x.f_code.co_freevars)
-        localsplus = x.f_code.co_stacksize + x.f_code.co_nlocals +\
-                  ncells + nfrees
-        check(x, vsize('8P3i3c' + localsplus*'P'))
+        check(x, size('8P3i4cP'))
         # function
         def func(): pass
         check(func, size('14P'))

Objects/frameobject.c

@@ -593,25 +593,23 @@ frame_dealloc(PyFrameObject *f)
     PyCodeObject *co = f->f_code;
 
     /* Kill all local variables */
-    for (int i = 0; i < co->co_nlocalsplus; i++) {
-        Py_CLEAR(f->f_localsptr[i]);
-    }
-
-    /* Free items on stack */
-    for (int i = 0; i < f->f_stackdepth; i++) {
-        Py_XDECREF(f->f_valuestack[i]);
+    if (f->f_own_locals_memory) {
+        for (int i = 0; i < co->co_nlocalsplus; i++) {
+            Py_CLEAR(f->f_localsptr[i]);
+        }
+        /* Free items on stack */
+        for (int i = 0; i < f->f_stackdepth; i++) {
+            Py_XDECREF(f->f_valuestack[i]);
+        }
+        PyMem_Free(f->f_localsptr);
+        f->f_own_locals_memory = 0;
     }
     f->f_stackdepth = 0;
     Py_XDECREF(f->f_back);
     Py_DECREF(f->f_builtins);
     Py_DECREF(f->f_globals);
     Py_CLEAR(f->f_locals);
     Py_CLEAR(f->f_trace);
-    if (f->f_own_locals_memory) {
-        PyMem_Free(f->f_localsptr);
-        f->f_localsptr = NULL;
-        f->f_own_locals_memory = 0;
-    }
     struct _Py_frame_state *state = get_frame_state();
 #ifdef Py_DEBUG
     // frame_dealloc() must not be called after _PyFrame_Fini()
@@ -709,10 +707,9 @@ static PyObject *
 frame_sizeof(PyFrameObject *f, PyObject *Py_UNUSED(ignored))
 {
     Py_ssize_t res;
-    PyCodeObject *code = f->f_code;
-    /* subtract one as it is already included in PyFrameObject */
     res = sizeof(PyFrameObject);
     if (f->f_own_locals_memory) {
+        PyCodeObject *code = f->f_code;
         res += (code->co_nlocalsplus+code->co_stacksize) * sizeof(PyObject *);
     }
     return PyLong_FromSsize_t(res);
@@ -777,19 +774,32 @@ PyTypeObject PyFrame_Type = {
 _Py_IDENTIFIER(__builtins__);
 
 static inline PyFrameObject*
-frame_alloc(PyCodeObject *code)
+frame_alloc(PyCodeObject *code, PyObject **localsarray)
 {
+    int owns;
     PyFrameObject *f;
-    PyObject **locals = PyMem_Malloc(sizeof(PyObject *)*(code->co_nlocalsplus+code->co_stacksize));
-    if (locals == NULL) {
-        PyErr_NoMemory();
-        return NULL;
+    if (localsarray == NULL) {
+        localsarray = PyMem_Malloc(sizeof(PyObject *)*(code->co_nlocalsplus+code->co_stacksize));
+        if (localsarray == NULL) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+        for (Py_ssize_t i=0; i < code->co_nlocalsplus; i++) {
+            localsarray[i] = NULL;
+        }
+        owns = 1;
+    }
+    else {
+        owns = 0;
     }
     struct _Py_frame_state *state = get_frame_state();
     if (state->free_list == NULL)
     {
         f = PyObject_GC_New(PyFrameObject, &PyFrame_Type);
         if (f == NULL) {
+            if (owns) {
+                PyMem_Free(localsarray);
+            }
             return NULL;
         }
     }
@@ -804,26 +814,44 @@ frame_alloc(PyCodeObject *code)
         state->free_list = state->free_list->f_back;
         _Py_NewReference((PyObject *)f);
     }
-    f->f_localsptr = locals;
-    f->f_own_locals_memory = 1;
+    f->f_localsptr = localsarray;
+    f->f_own_locals_memory = owns;
     f->f_valuestack = f->f_localsptr + code->co_nlocalsplus;
-    for (Py_ssize_t i=0; i < code->co_nlocalsplus; i++) {
-        f->f_localsptr[i] = NULL;
-    }
     return f;
 }
 
+int
+_PyFrame_MakeCopyOfLocals(PyFrameObject *f)
+{
+    if (f->f_own_locals_memory) {
+        return 0;
+    }
+    PyObject **copy = PyMem_Malloc(sizeof(PyObject *)*(f->f_code->co_nlocalsplus+f->f_code->co_stacksize));
+    if (copy == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    for (int i = 0; i < f->f_code->co_nlocalsplus+f->f_stackdepth; i++) {
+        PyObject *o = f->f_localsptr[i];
+        Py_XINCREF(o);
+        copy[i] = o;
+    }
+    f->f_own_locals_memory = 1;
+    f->f_localsptr = copy;
+    f->f_valuestack = f->f_localsptr + f->f_code->co_nlocalsplus;
+    return 0;
+}
 
 PyFrameObject* _Py_HOT_FUNCTION
-_PyFrame_New_NoTrack(PyThreadState *tstate, PyFrameConstructor *con, PyObject *locals)
+_PyFrame_New_NoTrack(PyThreadState *tstate, PyFrameConstructor *con, PyObject *locals, PyObject **localsarray)
 {
     assert(con != NULL);
     assert(con->fc_globals != NULL);
     assert(con->fc_builtins != NULL);
     assert(con->fc_code != NULL);
     assert(locals == NULL || PyMapping_Check(locals));
 
-    PyFrameObject *f = frame_alloc((PyCodeObject *)con->fc_code);
+    PyFrameObject *f = frame_alloc((PyCodeObject *)con->fc_code, localsarray);
     if (f == NULL) {
         return NULL;
     }
@@ -865,7 +893,7 @@ PyFrame_New(PyThreadState *tstate, PyCodeObject *code,
         .fc_kwdefaults = NULL,
         .fc_closure = NULL
     };
-    PyFrameObject *f = _PyFrame_New_NoTrack(tstate, &desc, locals);
+    PyFrameObject *f = _PyFrame_New_NoTrack(tstate, &desc, locals, NULL);
     if (f) {
         _PyObject_GC_TRACK(f);
     }

Python/ceval.c

@@ -4771,10 +4771,6 @@ positional_only_passed_as_keyword(PyThreadState *tstate, PyCodeObject *co,
 
 }
 
-/* Exception table parsing code.
- * See Objects/exception_table_notes.txt for details.
- */
-
 static inline unsigned char *
 parse_varint(unsigned char *p, int *result) {
     int val = p[0] & 63;
@@ -4862,25 +4858,14 @@ get_exception_handler(PyCodeObject *code, int index, int *level, int *handler, i
     return 0;
 }
 
-PyFrameObject *
-_PyEval_MakeFrameVector(PyThreadState *tstate,
-           PyFrameConstructor *con, PyObject *locals,
-           PyObject *const *args, Py_ssize_t argcount,
-           PyObject *kwnames)
+static int
+initialize_locals(PyThreadState *tstate, PyFrameConstructor *con,
+    PyObject **fastlocals, PyObject *const *args,
+    Py_ssize_t argcount, PyObject *kwnames)
 {
-    assert(is_tstate_valid(tstate));
-
     PyCodeObject *co = (PyCodeObject*)con->fc_code;
-    assert(con->fc_defaults == NULL || PyTuple_CheckExact(con->fc_defaults));
     const Py_ssize_t total_args = co->co_argcount + co->co_kwonlyargcount;
-
-    /* Create the frame */
-    PyFrameObject *f = _PyFrame_New_NoTrack(tstate, con, locals);
-    if (f == NULL) {
-        return NULL;
-    }
-    PyObject **fastlocals = f->f_localsptr;
-    PyObject **freevars = f->f_localsptr + co->co_nlocals;
+    PyObject **freevars = fastlocals + co->co_nlocals;
 
     /* Create a dictionary for keyword parameters (**kwags) */
     PyObject *kwdict;
@@ -5086,25 +5071,33 @@ _PyEval_MakeFrameVector(PyThreadState *tstate,
         freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o;
     }
 
-    return f;
+    return 0;
 
 fail: /* Jump here from prelude on failure */
+    return -1;
 
-    /* decref'ing the frame can cause __del__ methods to get invoked,
-       which can call back into Python.  While we're done with the
-       current Python frame (f), the associated C stack is still in use,
-       so recursion_depth must be boosted for the duration.
-    */
-    if (Py_REFCNT(f) > 1) {
-        Py_DECREF(f);
-        _PyObject_GC_TRACK(f);
+}
+
+
+PyFrameObject *
+_PyEval_MakeFrameVector(PyThreadState *tstate,
+           PyFrameConstructor *con, PyObject *locals,
+           PyObject *const *args, Py_ssize_t argcount,
+           PyObject *kwnames, PyObject** localsarray)
+{
+    assert(is_tstate_valid(tstate));
+    assert(con->fc_defaults == NULL || PyTuple_CheckExact(con->fc_defaults));
+
+    /* Create the frame */
+    PyFrameObject *f = _PyFrame_New_NoTrack(tstate, con, locals, localsarray);
+    if (f == NULL) {
+        return NULL;
     }
-    else {
-        ++tstate->recursion_depth;
+    if (initialize_locals(tstate, con, f->f_localsptr, args, argcount, kwnames)) {
         Py_DECREF(f);
-        --tstate->recursion_depth;
+        return NULL;
     }
-    return NULL;
+    return f;
 }
 
 static PyObject *
@@ -5142,15 +5135,31 @@ _PyEval_Vector(PyThreadState *tstate, PyFrameConstructor *con,
                PyObject* const* args, size_t argcount,
                PyObject *kwnames)
 {
+    PyObject **localsarray;
+    PyCodeObject *code = (PyCodeObject *)con->fc_code;
+    int is_coro = code->co_flags & (CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR);
+    if (is_coro) {
+        localsarray = NULL;
+    }
+    else {
+        localsarray = _PyThreadState_PushLocals(tstate, code->co_nlocalsplus + code->co_stacksize);
+        if (localsarray == NULL) {
+            return NULL;
+        }
+    }
     PyFrameObject *f = _PyEval_MakeFrameVector(
-        tstate, con, locals, args, argcount, kwnames);
+        tstate, con, locals, args, argcount, kwnames, localsarray);
     if (f == NULL) {
+        if (!is_coro) {
+            _PyThreadState_PopLocals(tstate, localsarray);
+        }
         return NULL;
     }
-    if (((PyCodeObject *)con->fc_code)->co_flags & (CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR)) {
+    if (is_coro) {
         return make_coro(con, f);
     }
     PyObject *retval = _PyEval_EvalFrame(tstate, f, 0);
+    assert(f->f_stackdepth == 0);
 
     /* decref'ing the frame can cause __del__ methods to get invoked,
        which can call back into Python.  While we're done with the
@@ -5160,12 +5169,22 @@ _PyEval_Vector(PyThreadState *tstate, PyFrameConstructor *con,
     if (Py_REFCNT(f) > 1) {
         Py_DECREF(f);
         _PyObject_GC_TRACK(f);
+        if (_PyFrame_MakeCopyOfLocals(f)) {
+            Py_XDECREF(retval);
+            return NULL;
+        }
     }
     else {
         ++tstate->recursion_depth;
         Py_DECREF(f);
         --tstate->recursion_depth;
     }
+    assert (!is_coro);
+
+    for (int i = 0; i < code->co_nlocalsplus; i++) {
+        Py_XDECREF(localsarray[i]);
+    }
+    _PyThreadState_PopLocals(tstate, localsarray);
     return retval;
 }
 

Python/pystate.c

@@ -1969,6 +1969,31 @@ _Py_GetConfig(void)
     return _PyInterpreterState_GetConfig(tstate->interp);
 }
 
+/* Dumbest possible (and very inefficient) implementation */
+
+PyObject **
+_PyThreadState_PushLocals(PyThreadState *tstate, int size)
+{
+    (void)tstate;
+    PyObject **res = PyMem_Malloc(sizeof(PyObject **)*size);
+    if (res == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (Py_ssize_t i=0; i < size; i++) {
+        res[i] = NULL;
+    }
+    return res;
+}
+
+void
+_PyThreadState_PopLocals(PyThreadState *tstate, PyObject **locals)
+{
+    (void)tstate;
+    PyMem_Free(locals);
+}
+
+
 #ifdef __cplusplus
 }
 #endif