gh-158790: Improve performance for list.insert() and del list[i] in free-threaded builds

`ins1()`(used by `list.insert()`) and `list_ass_item_lock_held()` shift the list with one atomic release store per element in free-threaded builds.  Those atomic stores prevent the compiler from vectorizing the loops, making them much slower than `memmove()` for large shifts.  I propose using the existing `ptr_wise_atomic_memmove()` helper here. It uses `memmove()` as a fast path when the list is owned by the current thread and is not shared, and keeps the atomic element-wise stores for lists that other threads can observe.

The default (GIL) build keeps the current loops because the compiler can optimize them directly in the calling function, and they perform better in benchmarks.

pyperf, free-threaded release build (--disable-gil, -O3):

    del l[0]                 2.26x faster
    del l[len(l)//2]         2.14x faster
    l.insert(0, x)           1.95x faster
    l.insert(len(l)//2, x)   1.86x faster
    insert(0)+del[0], n=1000 2.86x faster
    sliding window, n=1000   2.46x faster

Compiling both versions in GIL mode produces the same code for `ins1()` and `list_ass_item_lock_held()`, so the default build is not affected.

This continues gh-129069, which introduced `ptr_wise_atomic_memmove()`.

Author: hetaozdh

Misc/NEWS.d/next/Core_and_Builtins/2026-10-04-01-40-31.gh-issue-158790.F3kQ7z.rst

@@ -0,0 +1 @@
+Speed up ``list.insert()`` and ``del list[i]`` in free-threaded builds by using ``memmove()`` to shift elements when the list is not shared.

Objects/listobject.c

@@ -478,10 +478,13 @@ end:;
     return ret;
 }
 
+static void ptr_wise_atomic_memmove(PyListObject *a, PyObject **dest,
+                                    PyObject **src, Py_ssize_t n);
+
 static int
 ins1(PyListObject *self, Py_ssize_t where, PyObject *v)
 {
-    Py_ssize_t i, n = Py_SIZE(self);
+    Py_ssize_t n = Py_SIZE(self);
     PyObject **items;
     if (v == NULL) {
         PyErr_BadInternalCall();
@@ -500,8 +503,17 @@ ins1(PyListObject *self, Py_ssize_t where, PyObject *v)
     if (where > n)
         where = n;
     items = self->ob_item;
-    for (i = n; --i >= where; )
+#ifdef Py_GIL_DISABLED
+    if (where < n) {
+        ptr_wise_atomic_memmove(self, &items[where + 1], &items[where],
+                                n - where);
+    }
+#else
+    /* The compiler expands this loop inline. This is faster than a
+       memmove() call for short lists. */
+    for (Py_ssize_t i = n; --i >= where; )
         FT_ATOMIC_STORE_PTR_RELEASE(items[i+1], items[i]);
+#endif
     FT_ATOMIC_STORE_PTR_RELEASE(items[where], Py_NewRef(v));
     return 0;
 }
@@ -1145,9 +1157,16 @@ list_ass_item_lock_held(PyListObject *a, Py_ssize_t i, PyObject *v)
     PyObject *tmp = a->ob_item[i];
     if (v == NULL) {
         Py_ssize_t size = Py_SIZE(a);
+#ifdef Py_GIL_DISABLED
+        if (i < size - 1) {
+            ptr_wise_atomic_memmove(a, &a->ob_item[i], &a->ob_item[i + 1],
+                                    size - 1 - i);
+        }
+#else
         for (Py_ssize_t idx = i; idx < size - 1; idx++) {
             FT_ATOMIC_STORE_PTR_RELEASE(a->ob_item[idx], a->ob_item[idx + 1]);
         }
+#endif
         Py_SET_SIZE(a, size - 1);
     }
     else {