Lock free _STORE_ATTR_SLOT

[eendebakpt]

Both the bytecode handler (_STORE_ATTR_SLOT) and the C-API path (PyMember_SetOne for Py_T_OBJECT_EX / _Py_T_OBJECT) currently take per-object locks (ob_mutex via LOCK_OBJECT or Py_BEGIN_CRITICAL_SECTION) to sequence the read-of-old-value, store-of-new-value, and decref-of-old.

Replace the lock with a single atomic exchange on the slot pointer, similar with how the read side already works: _LOAD_ATTR_SLOT and PyMember_GetOne are lock-free for the fast path, using FT_ATOMIC_LOAD_PTR plus _Py_TryIncrefCompare to cope with mid-flight pointer changes.

Three changes are required:

1. _STORE_ATTR_SLOT in Python/bytecodes.c: drop LOCK_OBJECT / UNLOCK_OBJECT and the DEOPT_IF on lock-acquire failure; use _Py_atomic_exchange_ptr on Py_GIL_DISABLED, plain read/write on the GIL build.

2. PyMember_SetOne in Python/structmember.c, Py_T_OBJECT_EX and _Py_T_OBJECT cases: drop Py_BEGIN_CRITICAL_SECTION; use _Py_atomic_exchange_ptr to match the bytecode path. The two write paths must change together: if only the bytecode were lock-free, PyMember_SetOne's plain "oldv = *addr" inside the CS would race with concurrent atomic-exchange writers, returning a "stolen" old value that another writer is also about to DECREF (double-free).

3. PyMember_GetOne in Python/structmember.c, Py_T_OBJECT_EX and _Py_T_OBJECT cases: replace the CS+Py_XINCREF fallback (taken on _Py_TryIncrefCompare failure) with _Py_XGetRef, which retries the atomic-load + try-incref loop. The previous fallback relied on writers also taking ob_mutex to keep the slot stable inside the CS; with lock-free writers, the CS no longer excludes them, and a plain Py_XINCREF on a re-loaded slot value could resurrect a refcount-0 (about-to-be-freed) object.

Benchmarks:

Workload	Unit	GIL (ref)	FT baseline	FT patched	This patch (patched − baseline)
STORE_ATTR_SLOT (alone)	ns/op	5.41	15.40	9.30	−6.10 (−39.6%)
attr_idiv (3× /= + 3× reset per iter)	ns/op	22.56	41.22	30.20	−11.02 (−26.7%)*
Point.normalize (per Point)	ns/Point	358.4	417.4	398.0	−19.4 (−4.6%)
pyperformance bm_float (best)	ms	46.6	53.2	48.5	−4.7 (−8.8%)
pyperformance bm_float (median)	ms	47.7	56.4	51.7	−4.7 (−8.3%)
pyperformance bm_nbody (best, control)	ms	57.3	78.7	78.0	−0.7 (−0.9%)

Interpretation

• STORE_ATTR_SLOT itself: closes 61% of the FT-vs-GIL per-op gap (2.85× slower → 1.72× slower).
• attr_idiv (the self.x /= norm pattern in Point.normalize): closes 59% of the gap.
• bm_float: closes 71% of the FT-vs-GIL benchmark gap (was +14% slower, now +4%).
• bm_nbody (control): unchanged. Confirms the improvement is from STORE_ATTR specifically, not a global side-effect. bm_nbody's STORE-heavy work is on STORE_SUBSCR_LIST_INT, which still takes a per-object lock.