html-to-markdown 2.27.2 → 2.27.3

data/rust-vendor/tokio/src/runtime/scheduler/current_thread/mod.rs

@@ -15,7 +15,7 @@ use crate::util::{waker_ref, RngSeedGenerator, Wake, WakerRef};
 use std::cell::RefCell;
 use std::collections::VecDeque;
 use std::future::{poll_fn, Future};
-use std::sync::atomic::Ordering::{AcqRel, Release};
+use std::sync::atomic::Ordering::{AcqRel, Acquire, Release};
 use std::task::Poll::{Pending, Ready};
 use std::task::Waker;
 use std::thread::ThreadId;
@@ -380,9 +380,9 @@ impl Context {
             core = c;
         }
 
-        // This check will fail if `before_park` spawns a task for us to run
-        // instead of parking the thread
-        if core.tasks.is_empty() {
+        // If `before_park` spawns a task (or otherwise schedules work for us), then we should not
+        // park the thread.
+        if !self.has_pending_work(&core) {
             // Park until the thread is signaled
             core.metrics.about_to_park();
             core.submit_metrics(handle);
@@ -414,6 +414,10 @@ impl Context {
         core
     }
 
+    fn has_pending_work(&self, core: &Core) -> bool {
+        !core.tasks.is_empty() || !self.defer.is_empty() || self.handle.shared.woken.load(Acquire)
+    }
+
     fn park_internal(
         &self,
         core: Box<Core>,
@@ -499,7 +503,7 @@ impl Handle {
         F: crate::future::Future + 'static,
         F::Output: 'static,
     {
-        // Safety: the caller guarantees that the this is only called on a `LocalRuntime`.
+        // Safety: the caller guarantees that this is only called on a `LocalRuntime`.
         let (handle, notified) = unsafe {
             me.shared
                 .owned
@@ -720,8 +724,20 @@ impl Wake for Handle {
 
     /// Wake by reference
     fn wake_by_ref(arc_self: &Arc<Self>) {
-        arc_self.shared.woken.store(true, Release);
-        arc_self.driver.unpark();
+        let already_woken = arc_self.shared.woken.swap(true, Release);
+
+        if !already_woken {
+            use scheduler::Context::CurrentThread;
+
+            // If we are already running on the runtime, then it's not required to wake up the
+            // runtime.
+            context::with_scheduler(|maybe_cx| match maybe_cx {
+                Some(CurrentThread(cx)) if Arc::ptr_eq(arc_self, &cx.handle) => {}
+                _ => {
+                    arc_self.driver.unpark();
+                }
+            });
+        }
     }
 }
 
@@ -775,7 +791,7 @@ impl CoreGuard<'_> {
                         None => {
                             core.metrics.end_processing_scheduled_tasks();
 
-                            core = if !context.defer.is_empty() {
+                            core = if context.has_pending_work(&core) {
                                 context.park_yield(core, handle)
                             } else {
                                 context.park(core, handle)

data/rust-vendor/tokio/src/runtime/scheduler/multi_thread/worker.rs

@@ -424,6 +424,10 @@ where
 
         let cx = maybe_cx.expect("no .is_some() == false cases above should lead here");
 
+        // Since deferred tasks don't stay on `core`, make sure to wake them
+        // before blocking.
+        cx.defer.wake();
+
         // Get the worker core. If none is set, then blocking is fine!
         let mut core = match cx.core.borrow_mut().take() {
             Some(core) => core,
@@ -1280,6 +1284,7 @@ impl Handle {
         });
     }
 
+    // Separated case to reduce LLVM codegen in `Handle::bind_new_task`.
     pub(super) fn schedule_option_task_without_yield(&self, task: Option<Notified>) {
         if let Some(task) = task {
             self.schedule_task(task, false);

data/rust-vendor/tokio/src/runtime/task/core.rs

@@ -204,6 +204,7 @@ pub(super) struct Trailer {
     /// Consumer task waiting on completion of this task.
     pub(super) waker: UnsafeCell<Option<Waker>>,
     /// Optional hooks needed in the harness.
+    #[cfg_attr(not(tokio_unstable), allow(dead_code))] //TODO: remove when hooks are stabilized
     pub(super) hooks: TaskHarnessScheduleHooks,
 }
 

data/rust-vendor/tokio/src/runtime/task/join.rs

@@ -1,4 +1,4 @@
-use crate::runtime::task::{Header, RawTask};
+use crate::runtime::task::{AbortHandle, Header, RawTask};
 
 use std::fmt;
 use std::future::Future;
@@ -22,6 +22,10 @@ cfg_rt! {
     /// This `struct` is created by the [`task::spawn`] and [`task::spawn_blocking`]
     /// functions.
     ///
+    /// It is guaranteed that the destructor of the spawned task has finished
+    /// before task completion is observed via `JoinHandle` `await`,
+    /// [`JoinHandle::is_finished`] or [`AbortHandle::is_finished`].
+    ///
     /// # Cancel safety
     ///
     /// The `&mut JoinHandle<T>` type is cancel safe. If it is used as the event
@@ -300,9 +304,9 @@ impl<T> JoinHandle<T> {
     /// ```
     /// [cancelled]: method@super::error::JoinError::is_cancelled
     #[must_use = "abort handles do nothing unless `.abort` is called"]
-    pub fn abort_handle(&self) -> super::AbortHandle {
+    pub fn abort_handle(&self) -> AbortHandle {
         self.raw.ref_inc();
-        super::AbortHandle::new(self.raw)
+        AbortHandle::new(self.raw)
     }
 
     /// Returns a [task ID] that uniquely identifies this task relative to other

data/rust-vendor/tokio/src/runtime/task/list.rs

@@ -193,9 +193,11 @@ impl<S: 'static> OwnedTasks<S> {
         self.list.len()
     }
 
-    cfg_64bit_metrics! {
-        pub(crate) fn spawned_tasks_count(&self) -> u64 {
-            self.list.added()
+    cfg_unstable_metrics! {
+        cfg_64bit_metrics! {
+            pub(crate) fn spawned_tasks_count(&self) -> u64 {
+                self.list.added()
+            }
         }
     }
 

data/rust-vendor/tokio/src/runtime/task/mod.rs

@@ -178,10 +178,6 @@
 //! poll call will notice it when the poll finishes, and the task is cancelled
 //! at that point.
 
-// Some task infrastructure is here to support `JoinSet`, which is currently
-// unstable. This should be removed once `JoinSet` is stabilized.
-#![cfg_attr(not(tokio_unstable), allow(dead_code))]
-
 mod core;
 use self::core::Cell;
 use self::core::Header;
@@ -193,7 +189,6 @@ mod harness;
 use self::harness::Harness;
 
 mod id;
-#[cfg_attr(not(tokio_unstable), allow(unreachable_pub, unused_imports))]
 pub use id::{id, try_id, Id};
 
 #[cfg(feature = "rt")]

data/rust-vendor/tokio/src/runtime/tests/loom_blocking.rs

@@ -1,6 +1,7 @@
 use crate::runtime::{self, Runtime};
 
 use std::sync::Arc;
+use std::time::Duration;
 
 #[test]
 fn blocking_shutdown() {
@@ -75,7 +76,6 @@ fn spawn_mandatory_blocking_should_run_even_when_shutting_down_from_other_thread
 
 #[test]
 fn spawn_blocking_when_paused() {
-    use std::time::Duration;
     loom::model(|| {
         let rt = crate::runtime::Builder::new_current_thread()
             .enable_time()
@@ -94,6 +94,44 @@ fn spawn_blocking_when_paused() {
     });
 }
 
+#[test]
+/// See <https://github.com/tokio-rs/tokio/pull/7922>
+fn spawn_blocking_then_shutdown() {
+    loom::model(|| {
+        let rt = crate::runtime::Builder::new_current_thread()
+            .max_blocking_threads(1)
+            .thread_keep_alive(Duration::from_secs(7200)) // don't let the thread exit on its own
+            .build()
+            .unwrap();
+        let rt_hdl = rt.handle().clone();
+
+        // Currently, there is no live blocking thread,
+        // so `spawn_blocking` will spawn a new blocking thread.
+        let jh0 = rt_hdl.spawn_blocking(|| {});
+        loom::future::block_on(jh0).unwrap();
+
+        // Now, there is a idle blocking threads park on the condvar,
+        // so the following `spawn_blocking` will decrease the `num_idle_threads`
+        // and then notify one of the idle threads to run the task.
+
+        // this will decrease the `num_idle_threads`
+        // and then notify one of the idle threads to run the task.
+        let jh3 = rt_hdl.spawn_blocking(|| {});
+
+        // shutdown the runtime, which also shutdown the blocking pool
+        drop(rt);
+
+        // loom will emulate two parrel operations:
+        //
+        // 1. the blocking thread is woken up on the condvar
+        // 2. the main thread is waiting for the blocking thread to finish the task
+        //
+        // So, if the `num_idle_threads` is not counted correctly,
+        // it will trigger the assertions inside the `Inner::run` function.
+        let _ = loom::future::block_on(jh3);
+    });
+}
+
 fn mk_runtime(num_threads: usize) -> Runtime {
     runtime::Builder::new_multi_thread()
         .worker_threads(num_threads)

data/rust-vendor/tokio/src/signal/mod.rs

@@ -50,16 +50,9 @@ mod ctrl_c;
 #[cfg(feature = "signal")]
 pub use ctrl_c::ctrl_c;
 
+#[cfg(unix)]
 pub(crate) mod registry;
 
-mod os {
-    #[cfg(unix)]
-    pub(crate) use super::unix::{OsExtraData, OsStorage};
-
-    #[cfg(windows)]
-    pub(crate) use super::windows::{OsExtraData, OsStorage};
-}
-
 pub mod unix;
 pub mod windows;
 
@@ -83,18 +76,14 @@ impl RxFuture {
         }
     }
 
-    async fn recv(&mut self) -> Option<()> {
+    async fn recv(&mut self) {
         use std::future::poll_fn;
         poll_fn(|cx| self.poll_recv(cx)).await
     }
 
-    fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        match self.inner.poll(cx) {
-            Poll::Pending => Poll::Pending,
-            Poll::Ready(rx) => {
-                self.inner.set(make_future(rx));
-                Poll::Ready(Some(()))
-            }
-        }
+    fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<()> {
+        self.inner
+            .poll(cx)
+            .map(|rx| self.inner.set(make_future(rx)))
     }
 }

data/rust-vendor/tokio/src/signal/registry.rs

@@ -1,4 +1,4 @@
-use crate::signal::os::{OsExtraData, OsStorage};
+use crate::signal::unix::{OsExtraData, OsStorage};
 use crate::sync::watch;
 
 use std::ops;

data/rust-vendor/tokio/src/signal/unix.rs

@@ -14,8 +14,7 @@ use crate::sync::watch;
 
 use mio::net::UnixStream;
 use std::io::{self, Error, ErrorKind, Write};
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Once;
+use std::sync::OnceLock;
 use std::task::{Context, Poll};
 
 #[cfg(not(any(target_os = "linux", target_os = "illumos")))]
@@ -239,20 +238,10 @@ impl From<SignalKind> for std::os::raw::c_int {
     }
 }
 
+#[derive(Default)]
 pub(crate) struct SignalInfo {
     event_info: EventInfo,
-    init: Once,
-    initialized: AtomicBool,
-}
-
-impl Default for SignalInfo {
-    fn default() -> SignalInfo {
-        SignalInfo {
-            event_info: EventInfo::default(),
-            init: Once::new(),
-            initialized: AtomicBool::new(false),
-        }
-    }
+    init: OnceLock<Result<(), Option<i32>>>,
 }
 
 /// Our global signal handler for all signals registered by this module.
@@ -294,26 +283,20 @@ fn signal_enable(signal: SignalKind, handle: &Handle) -> io::Result<()> {
         Some(slot) => slot,
         None => return Err(io::Error::new(io::ErrorKind::Other, "signal too large")),
     };
-    let mut registered = Ok(());
-    siginfo.init.call_once(|| {
-        registered = unsafe {
-            signal_hook_registry::register(signal, move || action(globals, signal)).map(|_| ())
-        };
-        if registered.is_ok() {
-            siginfo.initialized.store(true, Ordering::Relaxed);
-        }
-    });
-    registered?;
-    // If the call_once failed, it won't be retried on the next attempt to register the signal. In
-    // such case it is not run, registered is still `Ok(())`, initialized is still `false`.
-    if siginfo.initialized.load(Ordering::Relaxed) {
-        Ok(())
-    } else {
-        Err(Error::new(
-            ErrorKind::Other,
-            "Failed to register signal handler",
-        ))
-    }
+
+    siginfo
+        .init
+        .get_or_init(|| {
+            unsafe { signal_hook_registry::register(signal, move || action(globals, signal)) }
+                .map(|_| ())
+                .map_err(|e| e.raw_os_error())
+        })
+        .map_err(|e| {
+            e.map_or_else(
+                || Error::new(ErrorKind::Other, "registering signal handler failed"),
+                Error::from_raw_os_error,
+            )
+        })
 }
 
 /// An listener for receiving a particular type of OS signal.
@@ -438,7 +421,8 @@ pub(crate) fn signal_with_handle(
 impl Signal {
     /// Receives the next signal notification event.
     ///
-    /// `None` is returned if no more events can be received by this stream.
+    /// Although this returns `Option<()>`, it will never actually return `None`.
+    /// This was accidentally exposed and would be a breaking change to be removed.
     ///
     /// # Cancel safety
     ///
@@ -466,19 +450,15 @@ impl Signal {
     /// }
     /// ```
     pub async fn recv(&mut self) -> Option<()> {
-        self.inner.recv().await
+        self.inner.recv().await;
+        Some(())
     }
 
     /// Polls to receive the next signal notification event, outside of an
     /// `async` context.
     ///
-    /// This method returns:
-    ///
-    ///  * `Poll::Pending` if no signals are available but the channel is not
-    ///    closed.
-    ///  * `Poll::Ready(Some(()))` if a signal is available.
-    ///  * `Poll::Ready(None)` if the channel has been closed and all signals
-    ///    sent before it was closed have been received.
+    /// Although this returns `Option<()>`, it will never actually return `None`.
+    /// This was accidentally exposed and would be a breaking change to be removed.
     ///
     /// # Examples
     ///
@@ -504,7 +484,7 @@ impl Signal {
     /// }
     /// ```
     pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        self.inner.poll_recv(cx)
+        self.inner.poll_recv(cx).map(Some)
     }
 }
 

data/rust-vendor/tokio/src/signal/windows/sys.rs

@@ -1,35 +1,37 @@
 use std::io;
-use std::sync::Once;
+use std::sync::OnceLock;
 
-use crate::signal::registry::{globals, EventId, EventInfo, Storage};
 use crate::signal::RxFuture;
+use crate::sync::watch;
 
 use windows_sys::core::BOOL;
 use windows_sys::Win32::System::Console as console;
 
+type EventInfo = watch::Sender<()>;
+
 pub(super) fn ctrl_break() -> io::Result<RxFuture> {
-    new(console::CTRL_BREAK_EVENT)
+    new(&registry().ctrl_break)
 }
 
 pub(super) fn ctrl_close() -> io::Result<RxFuture> {
-    new(console::CTRL_CLOSE_EVENT)
+    new(&registry().ctrl_close)
 }
 
 pub(super) fn ctrl_c() -> io::Result<RxFuture> {
-    new(console::CTRL_C_EVENT)
+    new(&registry().ctrl_c)
 }
 
 pub(super) fn ctrl_logoff() -> io::Result<RxFuture> {
-    new(console::CTRL_LOGOFF_EVENT)
+    new(&registry().ctrl_logoff)
 }
 
 pub(super) fn ctrl_shutdown() -> io::Result<RxFuture> {
-    new(console::CTRL_SHUTDOWN_EVENT)
+    new(&registry().ctrl_shutdown)
 }
 
-fn new(signum: u32) -> io::Result<RxFuture> {
+fn new(event_info: &EventInfo) -> io::Result<RxFuture> {
     global_init()?;
-    let rx = globals().register_listener(signum as EventId);
+    let rx = event_info.subscribe();
     Ok(RxFuture::new(rx))
 }
 
@@ -40,16 +42,14 @@ fn event_requires_infinite_sleep_in_handler(signum: u32) -> bool {
     //
     // For more information, see:
     // https://learn.microsoft.com/en-us/windows/console/handlerroutine#remarks
-    match signum {
-        console::CTRL_CLOSE_EVENT => true,
-        console::CTRL_LOGOFF_EVENT => true,
-        console::CTRL_SHUTDOWN_EVENT => true,
-        _ => false,
-    }
+    matches!(
+        signum,
+        console::CTRL_CLOSE_EVENT | console::CTRL_LOGOFF_EVENT | console::CTRL_SHUTDOWN_EVENT
+    )
 }
 
 #[derive(Debug, Default)]
-pub(crate) struct OsStorage {
+struct Registry {
     ctrl_break: EventInfo,
     ctrl_close: EventInfo,
     ctrl_c: EventInfo,
@@ -57,74 +57,62 @@ pub(crate) struct OsStorage {
     ctrl_shutdown: EventInfo,
 }
 
-impl Storage for OsStorage {
-    fn event_info(&self, id: EventId) -> Option<&EventInfo> {
-        match u32::try_from(id) {
-            Ok(console::CTRL_BREAK_EVENT) => Some(&self.ctrl_break),
-            Ok(console::CTRL_CLOSE_EVENT) => Some(&self.ctrl_close),
-            Ok(console::CTRL_C_EVENT) => Some(&self.ctrl_c),
-            Ok(console::CTRL_LOGOFF_EVENT) => Some(&self.ctrl_logoff),
-            Ok(console::CTRL_SHUTDOWN_EVENT) => Some(&self.ctrl_shutdown),
+impl Registry {
+    fn event_info(&self, signum: u32) -> Option<&EventInfo> {
+        match signum {
+            console::CTRL_BREAK_EVENT => Some(&self.ctrl_break),
+            console::CTRL_CLOSE_EVENT => Some(&self.ctrl_close),
+            console::CTRL_C_EVENT => Some(&self.ctrl_c),
+            console::CTRL_LOGOFF_EVENT => Some(&self.ctrl_logoff),
+            console::CTRL_SHUTDOWN_EVENT => Some(&self.ctrl_shutdown),
             _ => None,
         }
     }
-
-    fn for_each<'a, F>(&'a self, mut f: F)
-    where
-        F: FnMut(&'a EventInfo),
-    {
-        f(&self.ctrl_break);
-        f(&self.ctrl_close);
-        f(&self.ctrl_c);
-        f(&self.ctrl_logoff);
-        f(&self.ctrl_shutdown);
-    }
 }
 
-#[derive(Debug, Default)]
-pub(crate) struct OsExtraData {}
+fn registry() -> &'static Registry {
+    static REGISTRY: OnceLock<Registry> = OnceLock::new();
 
-fn global_init() -> io::Result<()> {
-    static INIT: Once = Once::new();
+    REGISTRY.get_or_init(Default::default)
+}
 
-    let mut init = None;
+fn global_init() -> io::Result<()> {
+    static INIT: OnceLock<Result<(), Option<i32>>> = OnceLock::new();
 
-    INIT.call_once(|| unsafe {
-        let rc = console::SetConsoleCtrlHandler(Some(handler), 1);
-        let ret = if rc == 0 {
-            Err(io::Error::last_os_error())
+    INIT.get_or_init(|| {
+        let rc = unsafe { console::SetConsoleCtrlHandler(Some(handler), 1) };
+        if rc == 0 {
+            Err(io::Error::last_os_error().raw_os_error())
         } else {
             Ok(())
-        };
-
-        init = Some(ret);
-    });
-
-    init.unwrap_or_else(|| Ok(()))
+        }
+    })
+    .map_err(|e| {
+        e.map_or_else(
+            || io::Error::new(io::ErrorKind::Other, "registering signal handler failed"),
+            io::Error::from_raw_os_error,
+        )
+    })
 }
 
 unsafe extern "system" fn handler(ty: u32) -> BOOL {
-    let globals = globals();
-    globals.record_event(ty as EventId);
+    // Ignore unknown control signal types.
+    let Some(event_info) = registry().event_info(ty) else {
+        return 0;
+    };
 
-    // According to https://docs.microsoft.com/en-us/windows/console/handlerroutine
+    // According to https://learn.microsoft.com/en-us/windows/console/handlerroutine
     // the handler routine is always invoked in a new thread, thus we don't
     // have the same restrictions as in Unix signal handlers, meaning we can
     // go ahead and perform the broadcast here.
-    let event_was_handled = globals.broadcast();
-
-    if event_was_handled && event_requires_infinite_sleep_in_handler(ty) {
-        loop {
+    match event_info.send(()) {
+        Ok(_) if event_requires_infinite_sleep_in_handler(ty) => loop {
             std::thread::park();
-        }
-    }
-
-    if event_was_handled {
-        1
-    } else {
+        },
+        Ok(_) => 1,
         // No one is listening for this notification any more
         // let the OS fire the next (possibly the default) handler.
-        0
+        Err(_) => 0,
     }
 }