mirror of
https://github.com/python/cpython.git
synced 2025-08-01 15:43:13 +00:00
gh-84436: Implement Immortal Objects (gh-19474)
This is the implementation of PEP683 Motivation: The PR introduces the ability to immortalize instances in CPython which bypasses reference counting. Tagging objects as immortal allows up to skip certain operations when we know that the object will be around for the entire execution of the runtime. Note that this by itself will bring a performance regression to the runtime due to the extra reference count checks. However, this brings the ability of having truly immutable objects that are useful in other contexts such as immutable data sharing between sub-interpreters.
This commit is contained in:
Eddie Elizondo
GitHub
parent
916de04fd1
commit
ea2c001650
35 changed files with 483 additions and 171 deletions
133
Include/object.h
133
Include/object.h
|
|
@ -78,12 +78,76 @@ whose size is determined when the object is allocated.
|
|||
/* PyObject_HEAD defines the initial segment of every PyObject. */
|
||||
#define PyObject_HEAD PyObject ob_base;
|
||||
|
||||
#define PyObject_HEAD_INIT(type) \
|
||||
{ _PyObject_EXTRA_INIT \
|
||||
1, (type) },
|
||||
/*
|
||||
Immortalization:
|
||||
|
||||
#define PyVarObject_HEAD_INIT(type, size) \
|
||||
{ PyObject_HEAD_INIT(type) (size) },
|
||||
The following indicates the immortalization strategy depending on the amount
|
||||
of available bits in the reference count field. All strategies are backwards
|
||||
compatible but the specific reference count value or immortalization check
|
||||
might change depending on the specializations for the underlying system.
|
||||
|
||||
Proper deallocation of immortal instances requires distinguishing between
|
||||
statically allocated immortal instances vs those promoted by the runtime to be
|
||||
immortal. The latter should be the only instances that require
|
||||
cleanup during runtime finalization.
|
||||
*/
|
||||
|
||||
#if SIZEOF_VOID_P > 4
|
||||
/*
|
||||
In 64+ bit systems, an object will be marked as immortal by setting all of the
|
||||
lower 32 bits of the reference count field, which is equal to: 0xFFFFFFFF
|
||||
|
||||
Using the lower 32 bits makes the value backwards compatible by allowing
|
||||
C-Extensions without the updated checks in Py_INCREF and Py_DECREF to safely
|
||||
increase and decrease the objects reference count. The object would lose its
|
||||
immortality, but the execution would still be correct.
|
||||
|
||||
Reference count increases will use saturated arithmetic, taking advantage of
|
||||
having all the lower 32 bits set, which will avoid the reference count to go
|
||||
beyond the refcount limit. Immortality checks for reference count decreases will
|
||||
be done by checking the bit sign flag in the lower 32 bits.
|
||||
*/
|
||||
#define _Py_IMMORTAL_REFCNT UINT_MAX
|
||||
|
||||
#else
|
||||
/*
|
||||
In 32 bit systems, an object will be marked as immortal by setting all of the
|
||||
lower 30 bits of the reference count field, which is equal to: 0x3FFFFFFF
|
||||
|
||||
Using the lower 30 bits makes the value backwards compatible by allowing
|
||||
C-Extensions without the updated checks in Py_INCREF and Py_DECREF to safely
|
||||
increase and decrease the objects reference count. The object would lose its
|
||||
immortality, but the execution would still be correct.
|
||||
|
||||
Reference count increases and decreases will first go through an immortality
|
||||
check by comparing the reference count field to the immortality reference count.
|
||||
*/
|
||||
#define _Py_IMMORTAL_REFCNT (UINT_MAX >> 2)
|
||||
#endif
|
||||
|
||||
// Make all internal uses of PyObject_HEAD_INIT immortal while preserving the
|
||||
// C-API expectation that the refcnt will be set to 1.
|
||||
#ifdef Py_BUILD_CORE
|
||||
#define PyObject_HEAD_INIT(type) \
|
||||
{ \
|
||||
_PyObject_EXTRA_INIT \
|
||||
{ _Py_IMMORTAL_REFCNT }, \
|
||||
(type) \
|
||||
},
|
||||
#else
|
||||
#define PyObject_HEAD_INIT(type) \
|
||||
{ \
|
||||
_PyObject_EXTRA_INIT \
|
||||
{ 1 }, \
|
||||
(type) \
|
||||
},
|
||||
#endif /* Py_BUILD_CORE */
|
||||
|
||||
#define PyVarObject_HEAD_INIT(type, size) \
|
||||
{ \
|
||||
PyObject_HEAD_INIT(type) \
|
||||
(size) \
|
||||
},
|
||||
|
||||
/* PyObject_VAR_HEAD defines the initial segment of all variable-size
|
||||
* container objects. These end with a declaration of an array with 1
|
||||
|
|
@ -101,7 +165,12 @@ whose size is determined when the object is allocated.
|
|||
*/
|
||||
struct _object {
|
||||
_PyObject_HEAD_EXTRA
|
||||
Py_ssize_t ob_refcnt;
|
||||
union {
|
||||
Py_ssize_t ob_refcnt;
|
||||
#if SIZEOF_VOID_P > 4
|
||||
PY_UINT32_T ob_refcnt_split[2];
|
||||
#endif
|
||||
};
|
||||
PyTypeObject *ob_type;
|
||||
};
|
||||
|
||||
|
|
@ -152,6 +221,15 @@ static inline Py_ssize_t Py_SIZE(PyObject *ob) {
|
|||
# define Py_SIZE(ob) Py_SIZE(_PyObject_CAST(ob))
|
||||
#endif
|
||||
|
||||
static inline Py_ALWAYS_INLINE int _Py_IsImmortal(PyObject *op)
|
||||
{
|
||||
#if SIZEOF_VOID_P > 4
|
||||
return _Py_CAST(PY_INT32_T, op->ob_refcnt) < 0;
|
||||
#else
|
||||
return op->ob_refcnt == _Py_IMMORTAL_REFCNT;
|
||||
#endif
|
||||
}
|
||||
#define _Py_IsImmortal(op) _Py_IsImmortal(_PyObject_CAST(op))
|
||||
|
||||
static inline int Py_IS_TYPE(PyObject *ob, PyTypeObject *type) {
|
||||
return Py_TYPE(ob) == type;
|
||||
|
|
@ -162,6 +240,13 @@ static inline int Py_IS_TYPE(PyObject *ob, PyTypeObject *type) {
|
|||
|
||||
|
||||
static inline void Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) {
|
||||
// This immortal check is for code that is unaware of immortal objects.
|
||||
// The runtime tracks these objects and we should avoid as much
|
||||
// as possible having extensions inadvertently change the refcnt
|
||||
// of an immortalized object.
|
||||
if (_Py_IsImmortal(ob)) {
|
||||
return;
|
||||
}
|
||||
ob->ob_refcnt = refcnt;
|
||||
}
|
||||
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000
|
||||
|
|
@ -524,19 +609,33 @@ PyAPI_FUNC(void) Py_DecRef(PyObject *);
|
|||
PyAPI_FUNC(void) _Py_IncRef(PyObject *);
|
||||
PyAPI_FUNC(void) _Py_DecRef(PyObject *);
|
||||
|
||||
static inline void Py_INCREF(PyObject *op)
|
||||
static inline Py_ALWAYS_INLINE void Py_INCREF(PyObject *op)
|
||||
{
|
||||
#if defined(Py_REF_DEBUG) && defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000
|
||||
// Stable ABI for Python 3.10 built in debug mode.
|
||||
_Py_IncRef(op);
|
||||
#else
|
||||
_Py_INCREF_STAT_INC();
|
||||
// Non-limited C API and limited C API for Python 3.9 and older access
|
||||
// directly PyObject.ob_refcnt.
|
||||
#if SIZEOF_VOID_P > 4
|
||||
// Portable saturated add, branching on the carry flag and set low bits
|
||||
PY_UINT32_T cur_refcnt = op->ob_refcnt_split[PY_BIG_ENDIAN];
|
||||
PY_UINT32_T new_refcnt = cur_refcnt + 1;
|
||||
if (new_refcnt == 0) {
|
||||
return;
|
||||
}
|
||||
op->ob_refcnt_split[PY_BIG_ENDIAN] = new_refcnt;
|
||||
#else
|
||||
// Explicitly check immortality against the immortal value
|
||||
if (_Py_IsImmortal(op)) {
|
||||
return;
|
||||
}
|
||||
op->ob_refcnt++;
|
||||
#endif
|
||||
_Py_INCREF_STAT_INC();
|
||||
#ifdef Py_REF_DEBUG
|
||||
_Py_INC_REFTOTAL();
|
||||
#endif // Py_REF_DEBUG
|
||||
op->ob_refcnt++;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000
|
||||
|
|
@ -553,6 +652,9 @@ static inline void Py_DECREF(PyObject *op) {
|
|||
#elif defined(Py_REF_DEBUG)
|
||||
static inline void Py_DECREF(const char *filename, int lineno, PyObject *op)
|
||||
{
|
||||
if (_Py_IsImmortal(op)) {
|
||||
return;
|
||||
}
|
||||
_Py_DECREF_STAT_INC();
|
||||
_Py_DEC_REFTOTAL();
|
||||
if (--op->ob_refcnt != 0) {
|
||||
|
|
@ -567,11 +669,14 @@ static inline void Py_DECREF(const char *filename, int lineno, PyObject *op)
|
|||
#define Py_DECREF(op) Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op))
|
||||
|
||||
#else
|
||||
static inline void Py_DECREF(PyObject *op)
|
||||
static inline Py_ALWAYS_INLINE void Py_DECREF(PyObject *op)
|
||||
{
|
||||
_Py_DECREF_STAT_INC();
|
||||
// Non-limited C API and limited C API for Python 3.9 and older access
|
||||
// directly PyObject.ob_refcnt.
|
||||
if (_Py_IsImmortal(op)) {
|
||||
return;
|
||||
}
|
||||
_Py_DECREF_STAT_INC();
|
||||
if (--op->ob_refcnt == 0) {
|
||||
_Py_Dealloc(op);
|
||||
}
|
||||
|
|
@ -721,7 +826,7 @@ PyAPI_FUNC(int) Py_IsNone(PyObject *x);
|
|||
#define Py_IsNone(x) Py_Is((x), Py_None)
|
||||
|
||||
/* Macro for returning Py_None from a function */
|
||||
#define Py_RETURN_NONE return Py_NewRef(Py_None)
|
||||
#define Py_RETURN_NONE return Py_None
|
||||
|
||||
/*
|
||||
Py_NotImplemented is a singleton used to signal that an operation is
|
||||
|
|
@ -731,7 +836,7 @@ PyAPI_DATA(PyObject) _Py_NotImplementedStruct; /* Don't use this directly */
|
|||
#define Py_NotImplemented (&_Py_NotImplementedStruct)
|
||||
|
||||
/* Macro for returning Py_NotImplemented from a function */
|
||||
#define Py_RETURN_NOTIMPLEMENTED return Py_NewRef(Py_NotImplemented)
|
||||
#define Py_RETURN_NOTIMPLEMENTED return Py_NotImplemented
|
||||
|
||||
/* Rich comparison opcodes */
|
||||
#define Py_LT 0
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue