Apr 22, 2023 · Apr 11, 2020 · Apr 11, 2020 · Apr 11, 2020 · Apr 11, 2020 · Apr 11, 2020
diff --git a/Include/object.h b/Include/object.h
 #define Py_TYPE(ob)             (_PyObject_CAST(ob)->ob_type)
 #define Py_SIZE(ob)             (_PyVarObject_CAST(ob)->ob_size)


 /* [RFC] Should we enable Immortal Instances by Default? */
 #define Py_IMMORTAL_INSTANCES

 /* Immortalizing causes the instance to not participate in reference counting.
 * Thus, an immortal object will be kept alive until the runtime finalization.
 * This avoids an unnecessary copy-on-write for applications that share
 * a common python heap across many processes. */
 #ifdef Py_IMMORTAL_INSTANCES

 /* The GC bit-shifts refcounts left by two, and after that shift we still
 * need this to be >> 0, so leave three high zero bits (the sign bit and
 * room for a shift of two.) */
 static const Py_ssize_t kImmortalBit = 1L << (8 * sizeof(Py_ssize_t) - 4);

 static inline int _Py_IsImmortal(PyObject *op)
 {
    return (op->ob_refcnt & kImmortalBit) != 0;
 }

 static inline void _Py_SetImmortal(PyObject *op)
 {
    op->ob_refcnt = kImmortalBit;
 }

 #endif  /* Py_IMMORTAL_INSTANCES */


 static inline int _Py_IS_TYPE(const PyObject *ob, const PyTypeObject *type) {
    return ob->ob_type == type;
 }
 #define Py_IS_TYPE(ob, type) _Py_IS_TYPE(_PyObject_CAST_CONST(ob), type)

 static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) {
 #ifdef Py_IMMORTAL_INSTANCES
    if (_Py_IsImmortal(ob)) {
        return;
    }
 #endif  /* Py_IMMORTAL_INSTANCES */
    ob->ob_refcnt = refcnt;
 }
 #define Py_SET_REFCNT(ob, refcnt) _Py_SET_REFCNT(_PyObject_CAST(ob), refcnt)
 /* Type structure has tp_finalize member (3.4) */
 #define Py_TPFLAGS_HAVE_FINALIZE (1UL << 0)


 /*
 The macros Py_INCREF(op) and Py_DECREF(op) are used to increment or decrement
 reference counts.  Py_DECREF calls the object's deallocator function when

 static inline void _Py_INCREF(PyObject *op)
 {
 #ifdef Py_IMMORTAL_INSTANCES
    if (_Py_IsImmortal(op)) {
        return;
    }
 #endif  /* Py_IMMORTAL_INSTANCES */
 #ifdef Py_REF_DEBUG
    _Py_RefTotal++;
 #endif
 #endif
    PyObject *op)
 {
 #ifdef Py_IMMORTAL_INSTANCES
    if (_Py_IsImmortal(op)) {
        return;
    }
 #endif  /* Py_IMMORTAL_INSTANCES */
 #ifdef Py_REF_DEBUG
    _Py_RefTotal--;
 #endif
diff --git a/Lib/test/test_gc.py b/Lib/test/test_gc.py
        gc.enable()


 # These tests need to be run in a separate process since gc.immortalize_heap
 # will mess up with the reference count of other tests
 class GCImmortalizeTests(unittest.TestCase):
    def test_not_immortal(self):
        obj = []
        self.assertFalse(gc.is_immortal(obj))

    def test_is_immortal(self):
        code = """if 1:
            import gc
            obj = []
            gc.immortalize_heap()
            print(gc.is_immortal(obj))
            """
        rc, out, err = assert_python_ok('-c', code)
        self.assertEqual(out.strip(), b'True')

    def test_post_immortalize(self):
        code = """if 1:
            import gc
            gc.immortalize_heap()
            obj = []
            print(gc.is_immortal(obj))
            """
        rc, out, err = assert_python_ok('-c', code)
        self.assertEqual(out.strip(), b'False')

    def test_become_tracked_after_immortalize(self):
        code = """if 1:
            import gc
            d = {}  # untracked by gc
            gc.immortalize_heap()
            d["foo"] = []  # now becomes gc-tracked
            gc.collect()  # gc should not collect immortal objects
            print(len(d))
            """
        rc, out, err = assert_python_ok('-c', code)
        self.assertEqual(out.strip(), b'1')


 class GCCallbackTests(unittest.TestCase):
    def setUp(self):
        # Save gc state and disable it.

    try:
        gc.collect() # Delete 2nd generation garbage
        run_unittest(GCTests, GCTogglingTests, GCCallbackTests)
        run_unittest(
            GCTests, GCTogglingTests, GCCallbackTests, GCImmortalizeTests)
    finally:
        gc.set_debug(debug)
        # test gc.enable() even if GC is disabled by default
diff --git a/Modules/clinic/gcmodule.c.h b/Modules/clinic/gcmodule.c.h
diff --git a/Modules/gcmodule.c b/Modules/gcmodule.c
    return gc_list_size(&gcstate->permanent_generation.head);
 }

 /*[clinic input]
 gc.is_immortal -> bool

    instance: object
        The instance to perform the immortal check on.

 Check if an object has been immortalized.
 [clinic start generated code]*/

 static int
 gc_is_immortal_impl(PyObject *module, PyObject *instance)
 /*[clinic end generated code: output=743a163cb6aaf384 input=815182ca5c5d81e4]*/
 {
    return _Py_IsImmortal(instance);
 }


 static int
 immortalize_object(PyObject *obj, PyObject *Py_UNUSED(ignored))
 {
    _Py_SetImmortal(obj);
    /* Special case for PyCodeObjects since they don't have a tp_traverse */
    if (PyCode_Check(obj)) {
        PyCodeObject *code = (PyCodeObject *)obj;
        _Py_SetImmortal(code->co_code);
        _Py_SetImmortal(code->co_consts);
        _Py_SetImmortal(code->co_names);
        _Py_SetImmortal(code->co_varnames);
        _Py_SetImmortal(code->co_freevars);
        _Py_SetImmortal(code->co_cellvars);
        _Py_SetImmortal(code->co_filename);
        _Py_SetImmortal(code->co_name);
        _Py_SetImmortal(code->co_lnotab);
    }
    return 0;
 }

 /*[clinic input]
 gc.immortalize_heap

 Immortalize all instances accessible through the GC roots.
 [clinic start generated code]*/

 static PyObject *
 gc_immortalize_heap_impl(PyObject *module)
 /*[clinic end generated code: output=a7bb85fe2e27e4ae input=ca1709e4667c0623]*/
 {
    PyGC_Head *gc, *list;
    PyThreadState *tstate = _PyThreadState_GET();
    GCState *gcstate = &tstate->interp->gc;

    /* Remove any dead objects to avoid immortalizing them */
    PyGC_Collect();

    /* Move all instances into the permanent generation */
    gc_freeze_impl(module);

    /* Immortalize all instances in the permanent generation */
    list = &gcstate->permanent_generation.head;
    for (gc = GC_NEXT(list); gc != list; gc = GC_NEXT(gc)) {
        _Py_SetImmortal(FROM_GC(gc));
        /* This can traverse to non-GC-tracked objects, and some of those
         * non-GC-tracked objects (e.g. dicts) can later become GC-tracked, and
         * not be in the permanent generation. So it is possible for immortal
         * objects to enter GC collection. Currently what happens in that case
         * is that their immortal bit makes it look like they have a very large
         * refcount, so they are not collected.
         */
        Py_TYPE(FROM_GC(gc))->tp_traverse(
              FROM_GC(gc), (visitproc)immortalize_object, NULL);
    }
    Py_RETURN_NONE;
 }

 PyDoc_STRVAR(gc__doc__,
 "This module provides access to the garbage collector for reference cycles.\n"
 "is_finalized() -- Returns true if a given object has been already finalized.\n"
 "get_referrers() -- Return the list of objects that refer to an object.\n"
 "get_referents() -- Return the list of objects that an object refers to.\n"
 #ifdef Py_IMMORTAL_INSTANCES
 "immortalize_heap() -- Immortalize all instances accessible through the GC roots.\n"
 "is_immortal() -- Check if an object has been immortalized.\n"
 #endif
 "freeze() -- Freeze all tracked objects and ignore them for future collections.\n"
 "unfreeze() -- Unfreeze all objects in the permanent generation.\n"
 "get_freeze_count() -- Return the number of objects in the permanent generation.\n");
    GC_FREEZE_METHODDEF
    GC_UNFREEZE_METHODDEF
    GC_GET_FREEZE_COUNT_METHODDEF
 #ifdef Py_IMMORTAL_INSTANCES
    GC_IMMORTALIZE_HEAP_METHODDEF
    GC_IS_IMMORTAL_METHODDEF
 #endif
    {NULL,      NULL}           /* Sentinel */
 };
Original file line number	Diff line number	Diff line change
Expand Up		@@ -124,12 +124,45 @@ typedef struct {
		#define Py_TYPE(ob) (_PyObject_CAST(ob)->ob_type)
		#define Py_SIZE(ob) (_PyVarObject_CAST(ob)->ob_size)


		/* [RFC] Should we enable Immortal Instances by Default? */
		#define Py_IMMORTAL_INSTANCES
eduardo-elizondo marked this conversation as resolved. OutdatedShow resolvedHide resolved

		/* Immortalizing causes the instance to not participate in reference counting.
		* Thus, an immortal object will be kept alive until the runtime finalization.
		* This avoids an unnecessary copy-on-write for applications that share
		* a common python heap across many processes. */
		#ifdef Py_IMMORTAL_INSTANCES

		/* The GC bit-shifts refcounts left by two, and after that shift we still
		* need this to be >> 0, so leave three high zero bits (the sign bit and
		* room for a shift of two.) */
		static const Py_ssize_t kImmortalBit = 1L << (8 * sizeof(Py_ssize_t) - 4);
eduardo-elizondo marked this conversation as resolved. OutdatedShow resolvedHide resolved

		static inline int _Py_IsImmortal(PyObject *op)
		{
		return (op->ob_refcnt & kImmortalBit) != 0;
eduardo-elizondo marked this conversation as resolved. OutdatedShow resolvedHide resolved
		}

		static inline void _Py_SetImmortal(PyObject *op)
		{
		op->ob_refcnt = kImmortalBit;
		}

		#endif /* Py_IMMORTAL_INSTANCES */


		static inline int _Py_IS_TYPE(const PyObject ob, const PyTypeObject type) {
		return ob->ob_type == type;
		}
		#define Py_IS_TYPE(ob, type) _Py_IS_TYPE(_PyObject_CAST_CONST(ob), type)

		static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) {
		#ifdef Py_IMMORTAL_INSTANCES
		if (_Py_IsImmortal(ob)) {
eduardo-elizondo marked this conversation as resolved. Show resolvedHide resolved
		return;
		}
eduardo-elizondo marked this conversation as resolved. Show resolvedHide resolved
		#endif /* Py_IMMORTAL_INSTANCES */
		ob->ob_refcnt = refcnt;
		}
		#define Py_SET_REFCNT(ob, refcnt) _Py_SET_REFCNT(_PyObject_CAST(ob), refcnt)
Expand DownExpand Up		@@ -358,7 +391,6 @@ given type object has a specified feature.
		/* Type structure has tp_finalize member (3.4) */
		#define Py_TPFLAGS_HAVE_FINALIZE (1UL << 0)


		/*
		The macros Py_INCREF(op) and Py_DECREF(op) are used to increment or decrement
		reference counts. Py_DECREF calls the object's deallocator function when
Expand DownExpand Up		@@ -397,6 +429,11 @@ PyAPI_FUNC(void) _Py_Dealloc(PyObject *);

		static inline void _Py_INCREF(PyObject *op)
		{
		#ifdef Py_IMMORTAL_INSTANCES
		if (_Py_IsImmortal(op)) {
		return;
		}
		#endif /* Py_IMMORTAL_INSTANCES */
		#ifdef Py_REF_DEBUG
		_Py_RefTotal++;
		#endif
Expand All		@@ -411,6 +448,11 @@ static inline void _Py_DECREF(
		#endif
		PyObject *op)
		{
		#ifdef Py_IMMORTAL_INSTANCES
		if (_Py_IsImmortal(op)) {
		return;
		}
		#endif /* Py_IMMORTAL_INSTANCES */
		#ifdef Py_REF_DEBUG
		_Py_RefTotal--;
		#endif
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1039,6 +1039,46 @@ class Z:
		gc.enable()


		# These tests need to be run in a separate process since gc.immortalize_heap
		# will mess up with the reference count of other tests
		class GCImmortalizeTests(unittest.TestCase):
eduardo-elizondo marked this conversation as resolved. OutdatedShow resolvedHide resolved eduardo-elizondo marked this conversation as resolved. OutdatedShow resolvedHide resolved
		def test_not_immortal(self):
		obj = []
		self.assertFalse(gc.is_immortal(obj))

		def test_is_immortal(self):
		code = """if 1:
		import gc
		obj = []
		gc.immortalize_heap()
		print(gc.is_immortal(obj))
		"""
		rc, out, err = assert_python_ok('-c', code)
		self.assertEqual(out.strip(), b'True')

		def test_post_immortalize(self):
		code = """if 1:
		import gc
		gc.immortalize_heap()
		obj = []
		print(gc.is_immortal(obj))
		"""
		rc, out, err = assert_python_ok('-c', code)
		self.assertEqual(out.strip(), b'False')

		def test_become_tracked_after_immortalize(self):
		code = """if 1:
		import gc
		d = {} # untracked by gc
		gc.immortalize_heap()
		d["foo"] = [] # now becomes gc-tracked
		gc.collect() # gc should not collect immortal objects
		print(len(d))
		"""
		rc, out, err = assert_python_ok('-c', code)
		self.assertEqual(out.strip(), b'1')


		class GCCallbackTests(unittest.TestCase):
		def setUp(self):
		# Save gc state and disable it.
Expand DownExpand Up		@@ -1369,7 +1409,8 @@ def test_main():

		try:
		gc.collect() # Delete 2nd generation garbage
		run_unittest(GCTests, GCTogglingTests, GCCallbackTests)
		run_unittest(
		GCTests, GCTogglingTests, GCCallbackTests, GCImmortalizeTests)
		finally:
		gc.set_debug(debug)
		# test gc.enable() even if GC is disabled by default
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1939,6 +1939,79 @@ gc_get_freeze_count_impl(PyObject *module)
		return gc_list_size(&gcstate->permanent_generation.head);
		}

		/*[clinic input]
		gc.is_immortal -> bool

		instance: object
		The instance to perform the immortal check on.

		Check if an object has been immortalized.
		[clinic start generated code]*/

		static int
		gc_is_immortal_impl(PyObject module, PyObject instance)
eduardo-elizondo marked this conversation as resolved. OutdatedShow resolvedHide resolved
		/[clinic end generated code: output=743a163cb6aaf384 input=815182ca5c5d81e4]/
		{
		return _Py_IsImmortal(instance);
		}


		static int
		immortalize_object(PyObject obj, PyObject Py_UNUSED(ignored))
		{
		_Py_SetImmortal(obj);
		/* Special case for PyCodeObjects since they don't have a tp_traverse */
eduardo-elizondo marked this conversation as resolved. OutdatedShow resolvedHide resolved
		if (PyCode_Check(obj)) {
		PyCodeObject code = (PyCodeObject )obj;
		_Py_SetImmortal(code->co_code);
		_Py_SetImmortal(code->co_consts);
		_Py_SetImmortal(code->co_names);
		_Py_SetImmortal(code->co_varnames);
		_Py_SetImmortal(code->co_freevars);
		_Py_SetImmortal(code->co_cellvars);
		_Py_SetImmortal(code->co_filename);
		_Py_SetImmortal(code->co_name);
		_Py_SetImmortal(code->co_lnotab);
		}
		return 0;
		}

		/*[clinic input]
		gc.immortalize_heap

		Immortalize all instances accessible through the GC roots.
		[clinic start generated code]*/

		static PyObject *
		gc_immortalize_heap_impl(PyObject *module)
		/[clinic end generated code: output=a7bb85fe2e27e4ae input=ca1709e4667c0623]/
		{
		PyGC_Head gc, list;
		PyThreadState *tstate = _PyThreadState_GET();
		GCState *gcstate = &tstate->interp->gc;

		/* Remove any dead objects to avoid immortalizing them */
		PyGC_Collect();
eduardo-elizondo marked this conversation as resolved. OutdatedShow resolvedHide resolved

		/* Move all instances into the permanent generation */
		gc_freeze_impl(module);

		/* Immortalize all instances in the permanent generation */
		list = &gcstate->permanent_generation.head;
		for (gc = GC_NEXT(list); gc != list; gc = GC_NEXT(gc)) {
		_Py_SetImmortal(FROM_GC(gc));
		/* This can traverse to non-GC-tracked objects, and some of those
		* non-GC-tracked objects (e.g. dicts) can later become GC-tracked, and
		* not be in the permanent generation. So it is possible for immortal
		* objects to enter GC collection. Currently what happens in that case
		* is that their immortal bit makes it look like they have a very large
		* refcount, so they are not collected.
		*/
		Py_TYPE(FROM_GC(gc))->tp_traverse(
		FROM_GC(gc), (visitproc)immortalize_object, NULL);
		}
		Py_RETURN_NONE;
		}

		PyDoc_STRVAR(gc__doc__,
		"This module provides access to the garbage collector for reference cycles.\n"
Expand All		@@ -1958,6 +2031,10 @@ PyDoc_STRVAR(gc__doc__,
		"is_finalized() -- Returns true if a given object has been already finalized.\n"
		"get_referrers() -- Return the list of objects that refer to an object.\n"
		"get_referents() -- Return the list of objects that an object refers to.\n"
		#ifdef Py_IMMORTAL_INSTANCES
		"immortalize_heap() -- Immortalize all instances accessible through the GC roots.\n"
		"is_immortal() -- Check if an object has been immortalized.\n"
		#endif
		"freeze() -- Freeze all tracked objects and ignore them for future collections.\n"
		"unfreeze() -- Unfreeze all objects in the permanent generation.\n"
		"get_freeze_count() -- Return the number of objects in the permanent generation.\n");
Expand All		@@ -1983,6 +2060,10 @@ static PyMethodDef GcMethods[] = {
		GC_FREEZE_METHODDEF
		GC_UNFREEZE_METHODDEF
		GC_GET_FREEZE_COUNT_METHODDEF
		#ifdef Py_IMMORTAL_INSTANCES
		GC_IMMORTALIZE_HEAP_METHODDEF
		GC_IS_IMMORTAL_METHODDEF
		#endif
		{NULL, NULL} /* Sentinel */
		};

Expand Down