Remove unused mark_barrier and done_barrier struct fields

Phase 5.3 replaced barrier-based dispatch with per-worker condvar
dispatch (see _PyGC_DispatchAndWait and the per-worker wake_mutex/
wake_cond plus pool-level done_mutex/done_cond). The mark_barrier
and done_barrier _PyGCBarrier fields stayed in _PyParallelGCState
with their Init/Fini calls but were no longer waited on.

Drop the two unused fields, their Init/Fini calls, and update the
struct + worker-loop documentation comments. startup_barrier stays
— still used for the once-per-pool worker-ready handshake during
ParallelStart.

Verified:
- Full distclean rebuild required (struct layout changed; the Makefile
  doesn't track header changes through all .o files — without distclean,
  stale .o files with the old struct offsets hit an assertion at runtime).
- GIL test suite: 124 tests pass (test_gc, test_gc_parallel_mark_alive,
  test_gc_ws_deque) — same as before the cleanup.

Part of post-Phase-5 cleanup. The corresponding cleanup of FTP's
mark_barrier/done_barrier/phase_barrier is deferred until FTP's pool
dispatch is also converted to per-worker condvars (a follow-up to the
adaptive-controller forward-port).

Author: SonicField

Include/internal/pycore_gc_parallel.h

@@ -204,8 +204,10 @@ typedef struct {
 // =============================================================================
 // Worker Thread Phases
 // =============================================================================
-// Workers wait on mark_barrier, then dispatch based on current phase.
-// The main GC thread sets the phase before signalling the barrier.
+// Workers wait on per-worker (wake_mutex, wake_cond) for dispatch, then
+// switch on current phase. The main GC thread sets the phase, then sets
+// wake_flag and signals wake_cond for each active worker.
+// See _PyGC_DispatchAndWait in gc_parallel.c.
 
 typedef enum {
     _PyGC_PHASE_IDLE,               // Waiting for work
@@ -308,15 +310,15 @@ struct _PyParallelGCState {
     // Populated during level-1 expansion, consumed by workers
     _PyGCWorkQueue work_queue;
 
-    // Synchronizes all workers before marking reachable objects
-    _PyGCBarrier mark_barrier;
-
-    // Synchronizes all worker threads and the main thread at the end of
-    // parallel collection
-    _PyGCBarrier done_barrier;
-
     // Synchronizes worker startup - ensures all workers are ready before
-    // ParallelStart returns (prevents race condition in Stop)
+    // ParallelStart returns (prevents race condition in Stop).
+    //
+    // The previous mark_barrier and done_barrier fields were retired in
+    // Phase 5.3 when broadcast-barrier dispatch was replaced with per-worker
+    // condvar dispatch (see _PyGC_DispatchAndWait in gc_parallel.c plus the
+    // wake_mutex/wake_cond on each worker and done_mutex/done_cond at the
+    // pool level). startup_barrier remains because the once-per-pool worker
+    // handshake during ParallelStart is a natural fit for a barrier.
     _PyGCBarrier startup_barrier;
 
     // Tracks the number of workers actively running. When this reaches zero

Python/gc_parallel.c

@@ -537,12 +537,9 @@ _PyGC_ParallelInit(PyInterpreterState *interp, size_t num_workers)
         return -1;
     }
 
-    // Initialize barriers
-    // mark_barrier: all workers + main thread (to signal start)
-    // done_barrier: all workers + main thread (to signal completion)
-    // startup_barrier: all workers + main thread (to ensure workers are ready)
-    _PyGCBarrier_Init(&par_gc->mark_barrier, (unsigned int)num_workers + 1);
-    _PyGCBarrier_Init(&par_gc->done_barrier, (unsigned int)num_workers + 1);
+    // Initialize startup_barrier (worker-ready handshake; only barrier still used).
+    // mark_barrier/done_barrier dispatch was replaced with per-worker condvars
+    // (see _PyGC_DispatchAndWait + per-worker wake_mutex/wake_cond).
     _PyGCBarrier_Init(&par_gc->startup_barrier, (unsigned int)num_workers + 1);
 
     // Initialize locks
@@ -557,8 +554,6 @@ _PyGC_ParallelInit(PyInterpreterState *interp, size_t num_workers)
         PyCOND_FINI(&par_gc->workers_done_cond);
         PyMUTEX_FINI(&par_gc->active_lock);
         _PyGCBarrier_Fini(&par_gc->startup_barrier);
-        _PyGCBarrier_Fini(&par_gc->done_barrier);
-        _PyGCBarrier_Fini(&par_gc->mark_barrier);
         _PyGCWorkQueue_Fini(&par_gc->work_queue);
         _PyGCSplitVector_Fini(&par_gc->split_vector);
         PyMem_Free(par_gc);
@@ -655,9 +650,8 @@ _PyGC_ParallelFini(PyInterpreterState *interp)
         }
     }
 
-    // Clean up barriers
-    _PyGCBarrier_Fini(&par_gc->mark_barrier);
-    _PyGCBarrier_Fini(&par_gc->done_barrier);
+    // Clean up startup_barrier (the only barrier still in use; mark/done
+    // were replaced with per-worker condvars in Phase 5.3).
     _PyGCBarrier_Fini(&par_gc->startup_barrier);
 
     // Clean up split vector
@@ -750,7 +744,7 @@ _PyGC_ParallelStop(PyInterpreterState *interp)
     // Wait for workers to finish (they exit after seeing should_exit)
     // After joining, clean up each worker's tstate from the main thread.
     // This avoids a race condition: if workers did cleanup themselves, there
-    // would be a window between done_barrier and thread exit where cleanup
+    // would be a window between worker exit and thread exit where cleanup
     // could race with re-initialization if enable_parallel() is called quickly.
     for (size_t i = 0; i < par_gc->num_workers; i++) {
         _PyParallelGCWorker *worker = &par_gc->workers[i];