Remove non-beneficial optimisations, consolidate benchmarks

Remove three optimisations that showed no measurable benefit in realistic
benchmarks:
- Cleanup workers (cw1+): parallel async cleanup showed no improvement
- BRC sharding: added overhead without measurable benefit
- Fast decref (Py_BRC_FAST_DECREF): no benefit in realistic workloads

Keep parallel GC scanning which provides proven benefits:
- ~4-12% throughput improvement on realistic workloads
- ~70-75% reduction in STW pause time

Consolidate four benchmark files into single gc_perf_benchmark.py:
- Focuses on realistic pyperformance-style workloads
- Reports best/mean/worst with clear +/- percentages
- Optional synthetic stress tests (--include-synthetic)
- Markdown output by default, JSON optional

Net change: -3000 lines of code

Author: SonicField

Include/internal/pycore_brc.h

@@ -15,42 +15,10 @@ extern "C" {
 
 #ifdef Py_GIL_DISABLED
 
-// Enable sharded BRC for reduced contention on cross-thread decrefs.
-// When enabled, each bucket has multiple shards indexed by the decrefing
-// thread's ID, reducing mutex contention by a factor of _Py_BRC_NUM_SHARDS.
-#define Py_BRC_SHARDED 1
-
-// Enable fast decref path using atomic ADD when object is already queued/merged.
-// When disabled, always uses CAS loop for all shared decrefs.
-// This optimisation avoids CAS retry loops for the common case.
-#define Py_BRC_FAST_DECREF 1
-
 // Prime number to avoid correlations with memory addresses.
 #define _Py_BRC_NUM_BUCKETS 257
 
-#ifdef Py_BRC_SHARDED
-// Prime number for shard count to avoid correlations with thread IDs.
-#define _Py_BRC_NUM_SHARDS 11
-
-// Per-shard mutex within a bucket
-struct _brc_shard {
-    PyMutex mutex;
-};
-
-// Hash table bucket with sharding
-struct _brc_bucket {
-    // Array of shards, each with its own mutex.
-    // Shard index = decrefing_thread_id % _Py_BRC_NUM_SHARDS
-    struct _brc_shard shards[_Py_BRC_NUM_SHARDS];
-
-    // Linked list of _PyThreadStateImpl objects hashed to this bucket.
-    // Protected by ALL shard mutexes (must hold all for modification).
-    struct llist_node root;
-};
-
-#else  /* !Py_BRC_SHARDED */
-
-// Hash table bucket (original non-sharded design)
+// Hash table bucket
 struct _brc_bucket {
     // Mutex protects both the bucket and thread state queues in this bucket.
     PyMutex mutex;
@@ -59,40 +27,14 @@ struct _brc_bucket {
     struct llist_node root;
 };
 
-#endif  /* Py_BRC_SHARDED */
-
 // Per-interpreter biased reference counting state
 struct _brc_state {
     // Hash table of thread states by thread-id. Thread states within a bucket
     // are chained using a doubly-linked list.
     struct _brc_bucket table[_Py_BRC_NUM_BUCKETS];
 };
 
-#ifdef Py_BRC_SHARDED
-
-// Per-thread biased reference counting state (sharded)
-struct _brc_thread_state {
-    // Linked-list of thread states per hash bucket
-    struct llist_node bucket_node;
-
-    // Thread-id as determined by _PyThread_Id()
-    uintptr_t tid;
-
-    // Objects with refcounts to be merged, one queue per shard.
-    // Queue[i] is protected by bucket->shards[i].mutex
-    _PyObjectStack queues[_Py_BRC_NUM_SHARDS];
-
-    // Bitmap tracking which queues are non-empty.
-    // Bit i set iff queues[i] is non-empty.
-    uint16_t non_empty_shards;
-
-    // Local stack of objects to be merged (not accessed by other threads)
-    _PyObjectStack local_objects_to_merge;
-};
-
-#else  /* !Py_BRC_SHARDED */
-
-// Per-thread biased reference counting state (original)
+// Per-thread biased reference counting state
 struct _brc_thread_state {
     // Linked-list of thread states per hash bucket
     struct llist_node bucket_node;
@@ -107,8 +49,6 @@ struct _brc_thread_state {
     _PyObjectStack local_objects_to_merge;
 };
 
-#endif  /* Py_BRC_SHARDED */
-
 // Initialize/finalize the per-thread biased reference counting state
 void _Py_brc_init_thread(PyThreadState *tstate);
 void _Py_brc_remove_thread(PyThreadState *tstate);

Include/internal/pycore_gc_ft_parallel.h

@@ -140,7 +140,6 @@ typedef enum {
     _PyGC_WORK_UPDATE_REFS,     // Initialize gc_refs on heap (deduce_unreachable phase 1)
     _PyGC_WORK_MARK_HEAP,       // Find roots and mark reachable (deduce_unreachable phase 2)
     _PyGC_WORK_SCAN_HEAP,       // Collect unreachable objects (deduce_unreachable phase 3)
-    _PyGC_WORK_ASYNC_CLEANUP,   // Single-threaded concurrent cleanup (runs in background)
     _PyGC_WORK_SHUTDOWN         // Shutdown workers
 } _PyGCWorkType;
 
@@ -193,13 +192,6 @@ typedef struct {
     // Shared worker state (deques, etc.)
     _PyGCWorkerState *workers;        // Now uses the full typedef
 
-    // For ASYNC_CLEANUP work (parallel concurrent background cleanup)
-    PyObject **async_cleanup_objects;   // Array of objects to clean up (owned)
-    Py_ssize_t async_cleanup_count;     // Number of objects
-    struct _gc_runtime_state *gcstate;  // GC state for clearing collecting flag
-    int async_cleanup_workers;          // Number of workers participating in cleanup (1..N)
-    _Atomic(int) workers_remaining;     // Counter for completion tracking (last to 0 clears collecting)
-
     // Result
     volatile int error_flag;    // Set if any worker encounters an error
 
@@ -235,7 +227,6 @@ typedef struct _PyGCThreadPool {
     _PyGCBarrier mark_barrier;     // Workers wait here for work
     _PyGCBarrier done_barrier;     // All workers wait here when done
     _PyGCBarrier phase_barrier;    // For multi-phase operations
-    _PyGCBarrier async_done_barrier; // For concurrent work (N-1 workers, excludes main thread)
 
     // Worker control
     volatile int shutdown;           // 1 = pool is shutting down
@@ -345,17 +336,6 @@ PyAPI_FUNC(int) _PyGC_ParallelScanHeapWithPool(
     _PyGCFTParState *state,
     struct _PyGCScanHeapResult *result);
 
-// Start concurrent cleanup in background worker (single-threaded).
-// Objects array is copied by the function (caller frees original).
-// The background worker will set gcstate->collecting = 0 when done.
-// Pool must exist (guaranteed if parallel_gc_enabled is true).
-// num_workers: how many workers to use for cleanup (1..pool_size, already clamped by caller)
-PyAPI_FUNC(void) _PyGC_StartAsyncCleanup(
-    PyInterpreterState *interp,
-    PyObject **objects,
-    Py_ssize_t count,
-    int num_workers);
-
 //-----------------------------------------------------------------------------
 // Ad-hoc thread versions (spawn threads per-collection instead of using pool)
 // These duplicate the pool-based functions but create threads on each call.

Include/internal/pycore_interp_structs.h

@@ -263,8 +263,6 @@ struct _gc_runtime_state {
     /* Parallel GC configuration for FTP */
     int parallel_gc_enabled;    /* 1 = enabled, 0 = disabled (default) */
     int parallel_gc_num_workers; /* Number of workers, 0 = auto (based on CPU count) */
-    int cleanup_workers;        /* Requested max cleanup workers (0=serial, N=parallel) */
-    int cleanup_workers_active; /* Actual cleanup workers for current cycle (set after STW) */
     struct _PyGCThreadPool *thread_pool;  /* Persistent thread pool for parallel GC */
 
     /* Phase timing for benchmarking (nanoseconds) */