lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

native_tasks.rs (27050B)


      1 //! One explicitly started native executor for library-owned command futures.
      2 use futures::{
      3     FutureExt, StreamExt,
      4     future::{Either, Shared, select},
      5     stream::FuturesUnordered,
      6 };
      7 use radroots_execution::{
      8     Code, Error, OperationContext, RetryClass,
      9     session::{HostFuture, tasks::TaskHost},
     10 };
     11 use std::{
     12     sync::{
     13         Arc, Mutex,
     14         atomic::{AtomicUsize, Ordering},
     15     },
     16     thread::JoinHandle,
     17 };
     18 use tokio::sync::{mpsc, oneshot};
     19 
     20 const CAPACITY: usize = 32;
     21 const UNAVAILABLE: Error = match Error::new(
     22     Code::CapabilityUnavailable,
     23     OperationContext::proposed(None),
     24     RetryClass::Never,
     25     None,
     26 ) {
     27     Ok(error) => error,
     28     Err(_) => panic!("invalid constant task-host error"),
     29 };
     30 type Completion = Shared<HostFuture<'static, crate::Result<()>>>;
     31 enum Job {
     32     Work(HostFuture<'static, ()>),
     33     Control(
     34         HostFuture<'static, crate::Result<()>>,
     35         oneshot::Sender<crate::Result<()>>,
     36     ),
     37     Stop,
     38 }
     39 #[derive(Clone, Copy, Eq, PartialEq)]
     40 pub(crate) enum ControlKind {
     41     Drain,
     42     Disconnect,
     43 }
     44 struct Control {
     45     id: u64,
     46     kind: ControlKind,
     47     completed: Completion,
     48 }
     49 struct Running {
     50     sender: mpsc::Sender<Job>,
     51     ready: Completion,
     52     done: Completion,
     53     thread: Option<JoinHandle<()>>,
     54     stop_sent: bool,
     55 }
     56 #[derive(Default)]
     57 struct State {
     58     running: Option<Running>,
     59     accepting: bool,
     60     quiesced: bool,
     61     closed: bool,
     62     control: Option<Control>,
     63     next_control: u64,
     64 }
     65 #[derive(Default)]
     66 pub(crate) struct NativeTasks {
     67     state: Mutex<State>,
     68     closing: futures::lock::Mutex<()>,
     69     admitted: Arc<AtomicUsize>,
     70 }
     71 struct WorkLease(Arc<AtomicUsize>);
     72 impl Drop for WorkLease {
     73     fn drop(&mut self) {
     74         self.0.fetch_sub(1, Ordering::AcqRel);
     75     }
     76 }
     77 fn completion(receiver: oneshot::Receiver<crate::Result<()>>) -> Completion {
     78     let future: HostFuture<'static, crate::Result<()>> =
     79         Box::pin(async move { receiver.await.unwrap_or(Err(UNAVAILABLE)) });
     80     future.shared()
     81 }
     82 fn run_worker(
     83     mut receiver: mpsc::Receiver<Job>,
     84     ready: oneshot::Sender<crate::Result<()>>,
     85     done: oneshot::Sender<crate::Result<()>>,
     86     build: impl FnOnce() -> std::io::Result<tokio::runtime::Runtime>,
     87 ) {
     88     let runtime = match build() {
     89         Ok(runtime) => runtime,
     90         Err(_) => {
     91             let _ = ready.send(Err(UNAVAILABLE));
     92             let _ = done.send(Err(UNAVAILABLE));
     93             return;
     94         }
     95     };
     96     let _ = ready.send(Ok(()));
     97     runtime.block_on(async move {
     98         let mut active = FuturesUnordered::new();
     99         loop {
    100             let next = if active.is_empty() {
    101                 receiver.recv().await
    102             } else {
    103                 match select(Box::pin(receiver.recv()), active.next()).await {
    104                     Either::Left((job, _)) => job,
    105                     Either::Right((_, _)) => continue,
    106                 }
    107             };
    108             let Some(job) = next else {
    109                 while active.next().await.is_some() {}
    110                 break;
    111             };
    112             match job {
    113                 Job::Work(task) => active.push(task),
    114                 Job::Control(task, reply) => {
    115                     // Later submissions cannot cross a control barrier.
    116                     while active.next().await.is_some() {}
    117                     let result = task.await;
    118                     let _ = reply.send(result);
    119                 }
    120                 Job::Stop => {
    121                     while active.next().await.is_some() {}
    122                     break;
    123                 }
    124             }
    125         }
    126     });
    127     drop(runtime);
    128     let _ = done.send(Ok(()));
    129 }
    130 impl NativeTasks {
    131     pub(crate) fn new() -> Self {
    132         Self::default()
    133     }
    134 
    135     pub(crate) async fn start(&self) -> crate::Result<()> {
    136         let ready = {
    137             let mut state = self
    138                 .state
    139                 .lock()
    140                 .unwrap_or_else(std::sync::PoisonError::into_inner);
    141             if state.quiesced || state.closed {
    142                 return Err(UNAVAILABLE);
    143             }
    144             if state.running.is_none() {
    145                 let (sender, receiver) = mpsc::channel::<Job>(CAPACITY);
    146                 let (ready, ready_receiver) = oneshot::channel();
    147                 let (done, done_receiver) = oneshot::channel();
    148                 let thread = std::thread::Builder::new()
    149                     .name("radroots_commands".into())
    150                     .spawn(move || {
    151                         run_worker(receiver, ready, done, || {
    152                             tokio::runtime::Builder::new_current_thread()
    153                                 .enable_all()
    154                                 .build()
    155                         })
    156                     })
    157                     .map_err(|_| UNAVAILABLE)?;
    158                 state.running = Some(Running {
    159                     sender,
    160                     ready: completion(ready_receiver),
    161                     done: completion(done_receiver),
    162                     thread: Some(thread),
    163                     stop_sent: false,
    164                 });
    165             }
    166             state.running.as_ref().ok_or(UNAVAILABLE)?.ready.clone()
    167         };
    168         ready.await?;
    169         let mut state = self
    170             .state
    171             .lock()
    172             .unwrap_or_else(std::sync::PoisonError::into_inner);
    173         if state.quiesced || state.closed {
    174             return Err(UNAVAILABLE);
    175         }
    176         state.accepting = true;
    177         Ok(())
    178     }
    179 
    180     pub(crate) fn quiesce(&self) {
    181         let mut state = self
    182             .state
    183             .lock()
    184             .unwrap_or_else(std::sync::PoisonError::into_inner);
    185         state.accepting = false;
    186         state.quiesced = true;
    187     }
    188 
    189     pub(crate) async fn control(
    190         &self,
    191         kind: ControlKind,
    192         task: HostFuture<'static, crate::Result<()>>,
    193     ) -> crate::Result<()> {
    194         let ready = {
    195             let state = self
    196                 .state
    197                 .lock()
    198                 .unwrap_or_else(std::sync::PoisonError::into_inner);
    199             if state.closed {
    200                 return Err(UNAVAILABLE);
    201             }
    202             state.running.as_ref().map(|running| running.ready.clone())
    203         };
    204         let Some(ready) = ready else {
    205             return Ok(());
    206         };
    207         if ready.await.is_err() {
    208             return Ok(());
    209         }
    210         let (id, completed) = {
    211             let mut state = self
    212                 .state
    213                 .lock()
    214                 .unwrap_or_else(std::sync::PoisonError::into_inner);
    215             if state.closed {
    216                 return Err(UNAVAILABLE);
    217             }
    218             if let Some(control) = &state.control {
    219                 if control.kind != kind {
    220                     return Err(UNAVAILABLE);
    221                 }
    222                 (control.id, control.completed.clone())
    223             } else {
    224                 let id = state.next_control.checked_add(1).ok_or(UNAVAILABLE)?;
    225                 let Some(running) = state.running.as_ref() else {
    226                     return Ok(());
    227                 };
    228                 if running.stop_sent {
    229                     return Err(UNAVAILABLE);
    230                 }
    231                 let (reply, wait) = oneshot::channel();
    232                 if let Err(error) = running.sender.try_send(Job::Control(task, reply)) {
    233                     drop(state);
    234                     drop(error);
    235                     return Err(UNAVAILABLE);
    236                 }
    237                 let completed = completion(wait);
    238                 state.next_control = id;
    239                 state.control = Some(Control {
    240                     id,
    241                     kind,
    242                     completed: completed.clone(),
    243                 });
    244                 (id, completed)
    245             }
    246         };
    247         let result = completed.await;
    248         let retired = {
    249             let mut state = self
    250                 .state
    251                 .lock()
    252                 .unwrap_or_else(std::sync::PoisonError::into_inner);
    253             if state
    254                 .control
    255                 .as_ref()
    256                 .is_some_and(|control| control.id == id)
    257             {
    258                 state.control.take()
    259             } else {
    260                 None
    261             }
    262         };
    263         drop(retired);
    264         result
    265     }
    266 
    267     pub(crate) async fn close(&self) -> crate::Result<()> {
    268         self.quiesce();
    269         let _closing = self.closing.lock().await;
    270         let ready = {
    271             let state = self
    272                 .state
    273                 .lock()
    274                 .unwrap_or_else(std::sync::PoisonError::into_inner);
    275             state.running.as_ref().map(|running| running.ready.clone())
    276         };
    277         let failed_start = match ready {
    278             Some(ready) => ready.await.is_err(),
    279             None => false,
    280         };
    281         let done = {
    282             let mut state = self
    283                 .state
    284                 .lock()
    285                 .unwrap_or_else(std::sync::PoisonError::into_inner);
    286             if state.closed {
    287                 return Ok(());
    288             }
    289             let Some(running) = state.running.as_mut() else {
    290                 state.closed = true;
    291                 return Ok(());
    292             };
    293             if !failed_start && !running.stop_sent {
    294                 running
    295                     .sender
    296                     .try_send(Job::Stop)
    297                     .map_err(|_| UNAVAILABLE)?;
    298                 running.stop_sent = true;
    299             }
    300             running.done.clone()
    301         };
    302         let result = done.await;
    303         if !failed_start {
    304             result?;
    305         }
    306         let thread = {
    307             let mut state = self
    308                 .state
    309                 .lock()
    310                 .unwrap_or_else(std::sync::PoisonError::into_inner);
    311             state
    312                 .running
    313                 .as_mut()
    314                 .and_then(|running| running.thread.take())
    315         };
    316         if let Some(thread) = thread {
    317             let result = thread.join().map_err(|_| UNAVAILABLE);
    318             if !failed_start {
    319                 result?;
    320             }
    321         }
    322         self.state
    323             .lock()
    324             .unwrap_or_else(std::sync::PoisonError::into_inner)
    325             .closed = true;
    326         Ok(())
    327     }
    328 }
    329 impl TaskHost for NativeTasks {
    330     fn submit(&self, task: HostFuture<'static, ()>) -> crate::Result<()> {
    331         let state = self
    332             .state
    333             .lock()
    334             .unwrap_or_else(std::sync::PoisonError::into_inner);
    335         if !state.accepting || state.quiesced || state.closed {
    336             return Err(UNAVAILABLE);
    337         }
    338         let running = state.running.as_ref().ok_or(UNAVAILABLE)?;
    339         if self
    340             .admitted
    341             .try_update(Ordering::AcqRel, Ordering::Acquire, |used| {
    342                 used.checked_add(1).filter(|next| *next <= CAPACITY)
    343             })
    344             .is_err()
    345         {
    346             drop(state);
    347             return Err(UNAVAILABLE);
    348         }
    349         let lease = WorkLease(self.admitted.clone());
    350         let task = Box::pin(async move {
    351             task.await;
    352             drop(lease);
    353         });
    354         let result = running.sender.try_send(Job::Work(task));
    355         drop(state);
    356         result.map_err(|_| UNAVAILABLE)
    357     }
    358 }
    359 
    360 #[cfg(test)]
    361 mod tests {
    362     use super::{CAPACITY, ControlKind, NativeTasks, Running, UNAVAILABLE, completion, run_worker};
    363     use futures::{FutureExt, executor::block_on, task::noop_waker_ref};
    364     use radroots_execution::session::{HostFuture, tasks::TaskHost};
    365     use std::{
    366         future::Future,
    367         pin::Pin,
    368         sync::{
    369             Arc,
    370             atomic::{AtomicUsize, Ordering},
    371         },
    372         task::{Context, Poll},
    373         time::Duration,
    374     };
    375     use tokio::sync::{mpsc, oneshot};
    376 
    377     fn pending<F: Future>(future: Pin<&mut F>) {
    378         assert!(
    379             future
    380                 .poll(&mut Context::from_waker(noop_waker_ref()))
    381                 .is_pending()
    382         );
    383     }
    384     fn gate_ready(tasks: &NativeTasks) -> oneshot::Sender<()> {
    385         let mut state = tasks.state.lock().unwrap();
    386         let running = state.running.as_mut().unwrap();
    387         let original = running.ready.clone();
    388         let (release, wait) = oneshot::channel();
    389         let gated: HostFuture<'static, crate::Result<()>> = Box::pin(async move {
    390             original.await?;
    391             wait.await.map_err(|_| UNAVAILABLE)
    392         });
    393         running.ready = gated.shared();
    394         release
    395     }
    396 
    397     #[test]
    398     fn never_started_driver_quiesces_and_closes_without_dispatch() {
    399         let tasks = NativeTasks::new();
    400         block_on(tasks.control(
    401             ControlKind::Drain,
    402             Box::pin(async { panic!("unstarted control dispatched") }),
    403         ))
    404         .unwrap();
    405         tasks.quiesce();
    406         assert!(block_on(tasks.start()).is_err());
    407         block_on(tasks.close()).unwrap();
    408         assert!(block_on(tasks.control(ControlKind::Drain, Box::pin(async { Ok(()) }))).is_err());
    409         block_on(tasks.close()).unwrap();
    410     }
    411 
    412     #[test]
    413     fn cancelled_close_retains_stop_progress_and_refuses_late_control() {
    414         let tasks = NativeTasks::new();
    415         block_on(tasks.start()).unwrap();
    416         let (release, wait) = oneshot::channel();
    417         tasks
    418             .submit(Box::pin(async move {
    419                 wait.await.unwrap();
    420             }))
    421             .unwrap();
    422         let mut closing = Box::pin(tasks.close());
    423         pending(closing.as_mut());
    424         drop(closing);
    425         assert!(block_on(tasks.control(ControlKind::Drain, Box::pin(async { Ok(()) }))).is_err());
    426         release.send(()).unwrap();
    427         block_on(tasks.close()).unwrap();
    428         assert!(
    429             tasks
    430                 .state
    431                 .lock()
    432                 .unwrap()
    433                 .running
    434                 .as_ref()
    435                 .unwrap()
    436                 .thread
    437                 .is_none()
    438         );
    439     }
    440 
    441     #[test]
    442     fn coalesced_control_failure_retry_and_stale_observer_keep_the_current_generation() {
    443         let tasks = NativeTasks::new();
    444         block_on(tasks.start()).unwrap();
    445         block_on(tasks.start()).unwrap();
    446         let (release, wait) = oneshot::channel();
    447         let mut first = Box::pin(tasks.control(
    448             ControlKind::Drain,
    449             Box::pin(async move {
    450                 wait.await.unwrap();
    451                 Err(UNAVAILABLE)
    452             }),
    453         ));
    454         pending(first.as_mut());
    455         let mut stale = Box::pin(tasks.control(
    456             ControlKind::Drain,
    457             Box::pin(async { panic!("coalesced work dispatched twice") }),
    458         ));
    459         pending(stale.as_mut());
    460         assert!(
    461             block_on(tasks.control(ControlKind::Disconnect, Box::pin(async { Ok(()) }))).is_err()
    462         );
    463         release.send(()).unwrap();
    464         assert!(block_on(first).is_err());
    465         let (release, wait) = oneshot::channel();
    466         let mut current = Box::pin(tasks.control(
    467             ControlKind::Drain,
    468             Box::pin(async move {
    469                 wait.await.unwrap();
    470                 Ok(())
    471             }),
    472         ));
    473         pending(current.as_mut());
    474         let generation = tasks.state.lock().unwrap().control.as_ref().unwrap().id;
    475         assert!(block_on(stale).is_err());
    476         assert_eq!(
    477             tasks.state.lock().unwrap().control.as_ref().unwrap().id,
    478             generation
    479         );
    480         release.send(()).unwrap();
    481         block_on(current).unwrap();
    482         block_on(tasks.close()).unwrap();
    483     }
    484 
    485     #[test]
    486     fn delayed_ready_observation_cannot_reopen_a_closed_driver_or_dispatch_control() {
    487         let tasks = NativeTasks::new();
    488         block_on(tasks.start()).unwrap();
    489         let release = gate_ready(&tasks);
    490         let mut start = Box::pin(tasks.start());
    491         pending(start.as_mut());
    492         let mut control = Box::pin(tasks.control(
    493             ControlKind::Drain,
    494             Box::pin(async { panic!("closed control dispatched") }),
    495         ));
    496         pending(control.as_mut());
    497         release.send(()).unwrap();
    498         block_on(tasks.close()).unwrap();
    499         assert!(block_on(start).is_err());
    500         assert!(block_on(control).is_err());
    501     }
    502 
    503     fn injected_driver(bootstrap_failure: bool, panic_after_drain: bool) -> NativeTasks {
    504         let tasks = NativeTasks::new();
    505         let (sender, receiver) = mpsc::channel(CAPACITY);
    506         let (ready, ready_receiver) = oneshot::channel();
    507         let (done, done_receiver) = oneshot::channel();
    508         let thread = std::thread::spawn(move || {
    509             run_worker(receiver, ready, done, || {
    510                 if bootstrap_failure {
    511                     Err(std::io::Error::other("injected bootstrap failure"))
    512                 } else {
    513                     tokio::runtime::Builder::new_current_thread()
    514                         .enable_all()
    515                         .build()
    516                 }
    517             });
    518             assert!(!panic_after_drain, "injected post-drain worker failure");
    519         });
    520         tasks.state.lock().unwrap().running = Some(Running {
    521             sender,
    522             ready: completion(ready_receiver),
    523             done: completion(done_receiver),
    524             thread: Some(thread),
    525             stop_sent: false,
    526         });
    527         tasks
    528     }
    529 
    530     #[test]
    531     fn injected_bootstrap_failure_and_post_drain_join_failure_preserve_actual_close_progress() {
    532         let failed = injected_driver(true, false);
    533         assert!(block_on(failed.start()).is_err());
    534         block_on(failed.control(
    535             ControlKind::Drain,
    536             Box::pin(async { panic!("failed bootstrap dispatched") }),
    537         ))
    538         .unwrap();
    539         block_on(failed.close()).unwrap();
    540         let failed = injected_driver(false, true);
    541         block_on(failed.start()).unwrap();
    542         assert!(block_on(failed.close()).is_err());
    543         assert!(!failed.state.lock().unwrap().closed);
    544         block_on(failed.close()).unwrap();
    545     }
    546 
    547     #[test]
    548     fn dropping_an_empty_driver_ends_its_actual_channel_without_claiming_close() {
    549         let tasks = NativeTasks::new();
    550         block_on(tasks.start()).unwrap();
    551         let (done, thread) = {
    552             let mut state = tasks.state.lock().unwrap();
    553             let running = state.running.as_mut().unwrap();
    554             (running.done.clone(), running.thread.take().unwrap())
    555         };
    556         drop(tasks);
    557         block_on(done).unwrap();
    558         thread.join().unwrap();
    559     }
    560 
    561     #[test]
    562     fn dropping_the_driver_does_not_cancel_accepted_pending_work() {
    563         let tasks = NativeTasks::new();
    564         block_on(tasks.start()).unwrap();
    565         let (started, observed) = std::sync::mpsc::sync_channel(1);
    566         let (release, wait) = oneshot::channel();
    567         let calls = Arc::new(AtomicUsize::new(0));
    568         let completed = calls.clone();
    569         tasks
    570             .submit(Box::pin(async move {
    571                 started.send(()).unwrap();
    572                 wait.await.unwrap();
    573                 completed.fetch_add(1, Ordering::SeqCst);
    574             }))
    575             .unwrap();
    576         observed.recv_timeout(Duration::from_secs(10)).unwrap();
    577         let (done, thread) = {
    578             let mut state = tasks.state.lock().unwrap();
    579             let running = state.running.as_mut().unwrap();
    580             (running.done.clone(), running.thread.take().unwrap())
    581         };
    582         drop(tasks);
    583         release.send(()).unwrap();
    584         block_on(done).unwrap();
    585         thread.join().unwrap();
    586         assert_eq!(calls.load(Ordering::SeqCst), 1);
    587     }
    588 
    589     #[test]
    590     fn accepted_tasks_and_control_survive_lost_observation_on_the_actual_native_executor() {
    591         let tasks = NativeTasks::new();
    592         let count = Arc::new(AtomicUsize::new(0));
    593         assert!(tasks.submit(Box::pin(async {})).is_err());
    594         drop(tasks.start());
    595         assert!(tasks.state.lock().unwrap().running.is_none());
    596         block_on(tasks.start()).unwrap();
    597         let (ready, observed) = std::sync::mpsc::sync_channel(1);
    598         let (release, wait) = oneshot::channel();
    599         let calls = count.clone();
    600         tasks
    601             .submit(Box::pin(async move {
    602                 ready.send(std::thread::current().id()).unwrap();
    603                 wait.await.unwrap();
    604                 calls.fetch_add(1, Ordering::SeqCst);
    605             }))
    606             .unwrap();
    607         assert_ne!(
    608             observed.recv_timeout(Duration::from_secs(10)).unwrap(),
    609             std::thread::current().id()
    610         );
    611         let calls = count.clone();
    612         tasks
    613             .submit(Box::pin(async move {
    614                 calls.fetch_add(10, Ordering::SeqCst);
    615             }))
    616             .unwrap();
    617         tasks.quiesce();
    618         assert!(tasks.submit(Box::pin(async {})).is_err());
    619         let calls = count.clone();
    620         let mut drain = Box::pin(tasks.control(
    621             ControlKind::Drain,
    622             Box::pin(async move {
    623                 calls.fetch_add(100, Ordering::SeqCst);
    624                 Ok(())
    625             }),
    626         ));
    627         assert!(matches!(
    628             drain
    629                 .as_mut()
    630                 .poll(&mut Context::from_waker(noop_waker_ref())),
    631             Poll::Pending
    632         ));
    633         drop(drain);
    634         release.send(()).unwrap();
    635         let calls = count.clone();
    636         block_on(tasks.control(
    637             ControlKind::Drain,
    638             Box::pin(async move {
    639                 calls.fetch_add(1000, Ordering::SeqCst);
    640                 Ok(())
    641             }),
    642         ))
    643         .unwrap();
    644         assert_eq!(count.load(Ordering::SeqCst), 111);
    645         block_on(tasks.control(ControlKind::Disconnect, Box::pin(async { Ok(()) }))).unwrap();
    646         block_on(tasks.close()).unwrap();
    647         block_on(tasks.close()).unwrap();
    648         assert!(block_on(tasks.start()).is_err());
    649         assert!(
    650             tasks
    651                 .state
    652                 .lock()
    653                 .unwrap()
    654                 .running
    655                 .as_ref()
    656                 .unwrap()
    657                 .thread
    658                 .is_none()
    659         );
    660     }
    661 
    662     struct ReentrantDrop(Arc<NativeTasks>, Arc<AtomicUsize>);
    663     impl Drop for ReentrantDrop {
    664         fn drop(&mut self) {
    665             assert!(self.0.state.try_lock().is_ok());
    666             self.1.fetch_add(1, Ordering::SeqCst);
    667         }
    668     }
    669     #[test]
    670     fn pending_work_allows_reads_but_controls_and_later_work_keep_their_barrier() {
    671         let tasks = NativeTasks::new();
    672         block_on(tasks.start()).unwrap();
    673         let (release, wait) = oneshot::channel();
    674         tasks
    675             .submit(Box::pin(async move {
    676                 wait.await.unwrap();
    677             }))
    678             .unwrap();
    679         let (read, observed) = std::sync::mpsc::sync_channel(1);
    680         tasks
    681             .submit(Box::pin(async move {
    682                 read.send(()).unwrap();
    683             }))
    684             .unwrap();
    685         observed.recv_timeout(Duration::from_secs(10)).unwrap();
    686         let (controlled, control_seen) = std::sync::mpsc::sync_channel(1);
    687         let (release_control, wait_control) = oneshot::channel();
    688         let mut control = Box::pin(tasks.control(
    689             ControlKind::Drain,
    690             Box::pin(async move {
    691                 controlled.send(()).unwrap();
    692                 wait_control.await.unwrap();
    693                 Ok(())
    694             }),
    695         ));
    696         pending(control.as_mut());
    697         let (later, later_seen) = std::sync::mpsc::sync_channel(1);
    698         tasks
    699             .submit(Box::pin(async move {
    700                 later.send(()).unwrap();
    701             }))
    702             .unwrap();
    703         assert!(matches!(
    704             control_seen.try_recv(),
    705             Err(std::sync::mpsc::TryRecvError::Empty)
    706         ));
    707         release.send(()).unwrap();
    708         control_seen.recv_timeout(Duration::from_secs(10)).unwrap();
    709         assert!(matches!(
    710             later_seen.try_recv(),
    711             Err(std::sync::mpsc::TryRecvError::Empty)
    712         ));
    713         release_control.send(()).unwrap();
    714         block_on(control).unwrap();
    715         later_seen.recv_timeout(Duration::from_secs(10)).unwrap();
    716         block_on(tasks.close()).unwrap();
    717         assert_eq!(tasks.admitted.load(Ordering::Acquire), 0);
    718     }
    719     #[test]
    720     fn native_queue_refusal_drops_captured_roots_outside_the_gate_and_close_drains_accepted_tasks()
    721     {
    722         let tasks = Arc::new(NativeTasks::new());
    723         block_on(tasks.start()).unwrap();
    724         let (ready, observed) = std::sync::mpsc::sync_channel(1);
    725         let (release, wait) = oneshot::channel();
    726         let wait = wait.shared();
    727         let first_wait = wait.clone();
    728         tasks
    729             .submit(Box::pin(async move {
    730                 ready.send(()).unwrap();
    731                 first_wait.await.unwrap();
    732             }))
    733             .unwrap();
    734         observed.recv_timeout(Duration::from_secs(10)).unwrap();
    735         let count = Arc::new(AtomicUsize::new(0));
    736         let (finished, completed) = oneshot::channel();
    737         let mut finished = Some(finished);
    738         let (started, observed) = std::sync::mpsc::sync_channel(CAPACITY);
    739         for index in 0..CAPACITY - 1 {
    740             let count = count.clone();
    741             let wait = wait.clone();
    742             let started = started.clone();
    743             let finished = if index + 2 == CAPACITY {
    744                 finished.take()
    745             } else {
    746                 None
    747             };
    748             tasks
    749                 .submit(Box::pin(async move {
    750                     started.send(()).unwrap();
    751                     wait.await.unwrap();
    752                     count.fetch_add(1, Ordering::SeqCst);
    753                     if let Some(finished) = finished {
    754                         let _ = finished.send(());
    755                     }
    756                 }))
    757                 .unwrap();
    758         }
    759         // All32 work slots are active; control/stop admission must not depend
    760         // on whether the worker happened to empty its channel before polling.
    761         for _ in 0..CAPACITY - 1 {
    762             observed.recv_timeout(Duration::from_secs(10)).unwrap();
    763         }
    764         let drops = Arc::new(AtomicUsize::new(0));
    765         let probe = ReentrantDrop(tasks.clone(), drops.clone());
    766         assert!(
    767             tasks
    768                 .submit(Box::pin(async move {
    769                     let _probe = probe;
    770                 }))
    771                 .is_err()
    772         );
    773         assert_eq!(drops.load(Ordering::SeqCst), 1);
    774         assert_eq!(tasks.admitted.load(Ordering::Acquire), CAPACITY);
    775         let mut drain = Box::pin(tasks.control(ControlKind::Drain, Box::pin(async { Ok(()) })));
    776         pending(drain.as_mut());
    777         let mut closing = Box::pin(tasks.close());
    778         pending(closing.as_mut());
    779         drop(closing);
    780         let probe = ReentrantDrop(tasks.clone(), drops.clone());
    781         assert!(
    782             tasks
    783                 .submit(Box::pin(async move {
    784                     let _probe = probe;
    785                 }))
    786                 .is_err()
    787         );
    788         assert_eq!(drops.load(Ordering::SeqCst), 2);
    789         release.send(()).unwrap();
    790         block_on(completed).unwrap();
    791         block_on(drain).unwrap();
    792         block_on(tasks.close()).unwrap();
    793         assert_eq!(count.load(Ordering::SeqCst), CAPACITY - 1);
    794         assert_eq!(tasks.admitted.load(Ordering::Acquire), 0);
    795     }
    796 }