Method park_detached_threads

crates/vm/src/vm/mod.rs:257–318

Try to CAS detached threads directly to SUSPENDED and check whether stop countdown reached zero after parking detached threads.

(&self, vm: &VirtualMachine)

    /// Try to CAS detached threads directly to SUSPENDED and check whether
    /// stop countdown reached zero after parking detached threads.
    fn park_detached_threads(&self, vm: &VirtualMachine) -> bool {
        use thread::{THREAD_ATTACHED, THREAD_DETACHED, THREAD_SUSPENDED};
        let requester = self.requester.load(Ordering::Relaxed);
        let registry = vm.state.thread_frames.lock();
        let mut attached_seen = 0u64;
        let mut forced_parks = 0u64;
        for (&id, slot) in registry.iter() {
            if id == requester {
                continue;
            }
            let state = slot.state.load(Ordering::Relaxed);
            if state == THREAD_DETACHED {
                // CAS DETACHED → SUSPENDED (park without thread cooperation)
                match slot.state.compare_exchange(
                    THREAD_DETACHED,
                    THREAD_SUSPENDED,
                    Ordering::AcqRel,
                    Ordering::Relaxed,
                ) {
                    Ok(_) => {
                        slot.stop_requested.store(false, Ordering::Release);
                        forced_parks = forced_parks.saturating_add(1);
                    }
                    Err(THREAD_ATTACHED) => {
                        // Set per-thread stop bit (_PY_EVAL_PLEASE_STOP_BIT).
                        slot.stop_requested.store(true, Ordering::Release);
                        // Raced with a thread re-attaching; it will self-suspend.
                        attached_seen = attached_seen.saturating_add(1);
                    }
                    Err(THREAD_DETACHED) => {
                        // Extremely unlikely race; next poll will handle it.
                    }
                    Err(THREAD_SUSPENDED) => {
                        slot.stop_requested.store(false, Ordering::Release);
                        // Another path parked it first.
                    }
                    Err(other) => {
                        debug_assert!(
                            false,
                            "unexpected thread state in park_detached_threads: {other}"
                        );
                    }
                }
            } else if state == THREAD_ATTACHED {
                // Set per-thread stop bit (_PY_EVAL_PLEASE_STOP_BIT).
                slot.stop_requested.store(true, Ordering::Release);
                // Thread is in bytecode — it will see `requested` and self-suspend
                attached_seen = attached_seen.saturating_add(1);
            }
            // THREAD_SUSPENDED → already parked
        }
        if attached_seen != 0 {
            self.stats_attached_seen
                .fetch_add(attached_seen, Ordering::Relaxed);
        }
        if forced_parks != 0 {
            self.decrement_thread_countdown(forced_parks);
            self.stats_forced_parks