Product Over View PPT Example

@@ -812,17 +812,21 @@ Object Protocol
 
 .. c:function:: int PyUnstable_SetImmortal(PyObject *op)
 
- Marks the object *op* :term:`immortal`. The argument should be uniquely referenced by
- the calling thread. This is intended to be used for reducing reference counting contention
- in the :term:`free-threaded build` for objects which are shared across threads.
+ Marks the object *op* :term:`immortal`. To successfully immortalize an object on a
+ :term:`free-threaded build` it must have been created by the calling thread.
+ Unicode objects are not immortalized and :c:func:`PyUnicode_InternInPlace` should
+ be used instead.
+ This function is intended to be used for reducing reference counting contention
+ in free-threaded builds for objects which are shared across threads.
 
  This is a one-way process: objects can only be made immortal; they cannot be
  made mortal once again. Immortal objects do not participate in reference counting
  and will never be garbage collected. If the object is GC-tracked, it is untracked.
 
  This function is intended to be used soon after *op* is created, by the code that
  creates it, such as in the object's :c:member:`~PyTypeObject.tp_new` slot.
- Returns 1 if the object was made immortal and returns 0 if it was not.
+ Returns 1 if the object was made immortal or is already immortal and returns 0
+ if it was not.
  This function cannot fail.
 
  .. versionadded:: 3.15

Template For A Journal Article

@@ -212,10 +212,10 @@ test_py_set_immortal(PyObject *self, PyObject *unused)
 #ifdef Py_GIL_DISABLED
  object.ob_tid = _Py_ThreadId();
  object.ob_gc_bits = 0;
- object.ob_ref_local = 1;
- object.ob_ref_shared = 0;
+ object.ob_ref_local = 3;
+ object.ob_ref_shared = 128;
 #else
- object.ob_refcnt = 1;
+ object.ob_refcnt = 3;
 #endif
  object.ob_type = &PyBaseObject_Type;
 
@@ -227,8 +227,18 @@ test_py_set_immortal(PyObject *self, PyObject *unused)
  assert(PyUnstable_IsImmortal(&object));
 
  // Check already immortal object
+ rc = PyUnstable_SetImmortal(&object);
+ assert(rc == 1);
+
+ // If not owned by the current thread cannot immortalize
+ #if Py_GIL_DISABLED
+ object.ob_tid = _Py_ThreadId() + 1;
+ object.ob_ref_local = 1; // reset refcount
+
  rc = PyUnstable_SetImmortal(&object);
  assert(rc == 0);
+ assert(!PyUnstable_IsImmortal(&object));
+ #endif
 
  // Check unicode objects
  PyObject *unicode = PyUnicode_FromString("test");

Business Credit Card Cash Advance

@@ -2885,7 +2885,17 @@ int
 PyUnstable_SetImmortal(PyObject *op)
 {
  assert(op != NULL);
- if (!_PyObject_IsUniquelyReferenced(op) || PyUnicode_Check(op)) {
+ if (_Py_IsImmortal(op)) {
+ // If the object is immortal, be idempotent.
+ return 1;
+ }
+#if Py_GIL_DISABLED
+ // Only the owning thread can immortalize the object safely
+ if (!_Py_IsOwnedByCurrentThread(op)) {
+ return 0;
+ }
+#endif
+ if (PyUnicode_Check(op)) {
  return 0;
  }
  _Py_SetImmortal(op);