Sweep dead process slots only when slots are scarce

init_proc_slot_withlock() swept every occupied slot for liveness on every
join. The sweep reads /proc/<pid>/stat once per slot and runs with the
region lock held, so N processes starting together perform O(N^2)
serialised filesystem work. On the harness from #252, init p50 grows from
0.35ms to 6.06ms going from 1 to 64 concurrent processes.

Reclaiming a slot whose process already died is not needed for a join to
be correct: oom_check() sweeps before it reports OOM, which is where a
stale slot actually changes an outcome. Sweep on join only once occupancy
reaches three quarters of the table, and do it before the capacity check
so a table filled with dead slots is recovered instead of being fatal.
Slots that exit cleanup already marked with PID 0 are still compacted on
every join; that path reads no files.

With this change init p50 at 64 concurrent processes is 1.11ms.

Signed-off-by: keshav9926 <kkakani160@gmail.com>

Author: keshav9926

src/multiprocess/multiprocess_memory_limit.c

@@ -1072,6 +1072,20 @@ void init_proc_slot_withlock() {
     shared_region_t* region = region_info.shared_region;
 
     int proc_num = atomic_load_explicit(&region->proc_num, memory_order_acquire);
+
+    // A full sweep reads /proc/<pid>/stat once per occupied slot, so it costs
+    // O(proc_num) filesystem syscalls while the region lock is held. Running it
+    // on every join makes N processes starting together O(N^2) serialised work.
+    // Reclaiming a slot whose process already died is not needed for the join
+    // itself to be correct: oom_check() sweeps before it reports OOM, which is
+    // where a stale slot actually changes an outcome. So sweep here only when
+    // slots are scarce -- and do it before deciding the table is full, so a
+    // table filled with dead slots is recovered instead of being fatal.
+    if (proc_num >= SHARED_REGION_SWEEP_THRESHOLD) {
+        clear_proc_slot_nolock(1);
+        proc_num = atomic_load_explicit(&region->proc_num, memory_order_acquire);
+    }
+
     if (proc_num >= SHARED_REGION_MAX_PROCESS_NUM) {
         exit_withlock(-1);
     }
@@ -1123,7 +1137,9 @@ void init_proc_slot_withlock() {
         atomic_fetch_add_explicit(&region->proc_num, 1, memory_order_release);
     }
 
-    clear_proc_slot_nolock(1);
+    // Slots that exit cleanup already marked dead carry PID 0, and dropping
+    // those reads no files at all, so that part stays on the join path.
+    clear_proc_slot_nolock(0);
     unlock_shrreg();
 }
 

src/multiprocess/multiprocess_memory_limit.h

@@ -40,6 +40,12 @@
 
 #define SHARED_REGION_SIZE_MAGIC  sizeof(shared_region_t)
 #define SHARED_REGION_MAX_PROCESS_NUM 1024
+// Slot-table occupancy at which joining a process performs a full liveness
+// sweep. See init_proc_slot_withlock(). Overridable at build time so the
+// regression test can reach the sweep without spawning 768 processes.
+#ifndef SHARED_REGION_SWEEP_THRESHOLD
+    #define SHARED_REGION_SWEEP_THRESHOLD ((SHARED_REGION_MAX_PROCESS_NUM * 3) / 4)
+#endif
 
 // macros for debugging
 #define SEQ_FIX_SHRREG_ACQUIRE_FLOCK_OK 0