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 }