Function BatchedWaitForMultipleObjects

crates/vm/src/stdlib/_winapi.rs:1566–1899

(
        handle_seq: PyObjectRef,
        wait_all: bool,
        milliseconds: OptionalArg<u32>,
        vm: &VirtualMachine,
    )

    /// BatchedWaitForMultipleObjects - Wait for multiple handles, supporting more than 64.
    #[pyfunction]
    fn BatchedWaitForMultipleObjects(
        handle_seq: PyObjectRef,
        wait_all: bool,
        milliseconds: OptionalArg<u32>,
        vm: &VirtualMachine,
    ) -> PyResult<PyObjectRef> {
        use alloc::sync::Arc;
        use core::sync::atomic::{AtomicU32, Ordering};
        use windows_sys::Win32::Foundation::{CloseHandle, WAIT_FAILED, WAIT_OBJECT_0};
        use windows_sys::Win32::System::SystemInformation::GetTickCount64;
        use windows_sys::Win32::System::Threading::{
            CreateEventW as WinCreateEventW, CreateThread, GetExitCodeThread,
            INFINITE as WIN_INFINITE, ResumeThread, SetEvent as WinSetEvent, TerminateThread,
            WaitForMultipleObjects,
        };

        let milliseconds = milliseconds.unwrap_or(WIN_INFINITE);

        // Get handles from sequence
        let seq = ArgSequence::<isize>::try_from_object(vm, handle_seq)?;
        let handles: Vec<isize> = seq.into_vec();
        let nhandles = handles.len();

        if nhandles == 0 {
            return if wait_all {
                Ok(vm.ctx.none())
            } else {
                Ok(vm.ctx.new_list(vec![]).into())
            };
        }

        let max_total_objects = (MAXIMUM_WAIT_OBJECTS - 1) * (MAXIMUM_WAIT_OBJECTS - 1);
        if nhandles > max_total_objects {
            return Err(vm.new_value_error(format!(
                "need at most {} handles, got a sequence of length {}",
                max_total_objects, nhandles
            )));
        }

        // Create batches of handles
        let batch_size = MAXIMUM_WAIT_OBJECTS - 1; // Leave room for cancel_event
        let mut batches: Vec<Vec<isize>> = Vec::new();
        let mut i = 0;
        while i < nhandles {
            let end = core::cmp::min(i + batch_size, nhandles);
            batches.push(handles[i..end].to_vec());
            i = end;
        }

        #[cfg(feature = "threading")]
        let sigint_event = {
            let is_main = crate::stdlib::_thread::get_ident() == vm.state.main_thread_ident.load();
            if is_main {
                let handle = crate::signal::get_sigint_event().unwrap_or_else(|| {
                    let handle = unsafe { WinCreateEventW(null(), 1, 0, null()) };
                    if !handle.is_null() {
                        crate::signal::set_sigint_event(handle as isize);
                    }