use super::CompletionSample;
use crate::telemetry;
use crate::transfer::{BoxTransfer, PollWork, TransferId, WorkOutcome};
use crate::runtime::sync::{Submission, SubmissionQueue};
use crate::runtime::ScheduledWork;
use crate::scheduler::descriptor::{ClaimGuard, TransferDescriptor};
use crate::scheduler::ready_set::{OrphanedChild, ReadySet};
use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{Arc, RwLock, Weak};
use std::time::Duration;
const SUBMISSION_QUEUE_SIZE: usize = 64;
const MAX_GENERATION_PASSES: usize = 3;
use super::gate::GenerateWorkGate;
#[derive(Clone)]
pub(crate) struct Scheduler(Arc<SchedulerInner>);
struct SchedulerInner {
transfers: RwLock<HashMap<TransferId, TransferDescriptor>>,
ready_set: ReadySet,
handle: Weak<crate::client::Handle>,
dispatched: AtomicUsize,
idle_candidate: AtomicBool,
submission_queue: SubmissionQueue<ScheduledWork>,
generate_work_gate: GenerateWorkGate,
}
impl std::fmt::Debug for Scheduler {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Scheduler").finish_non_exhaustive()
}
}
pub(crate) struct Cancellation {
pub(super) target: Option<TransferDescriptor>,
pub(super) children: Vec<TransferDescriptor>,
}
impl Cancellation {
pub(crate) async fn wait_for_idle(self) {
if let Some(d) = self.target {
d.wait_for_idle().await;
}
for d in self.children {
d.wait_for_idle().await;
}
}
}
impl Scheduler {
pub(crate) fn new(handle: Weak<crate::client::Handle>) -> Self {
Scheduler(Arc::new(SchedulerInner {
transfers: RwLock::new(HashMap::new()),
ready_set: ReadySet::new(),
handle,
dispatched: AtomicUsize::new(0),
idle_candidate: AtomicBool::new(false),
submission_queue: SubmissionQueue::new(SUBMISSION_QUEUE_SIZE),
generate_work_gate: GenerateWorkGate::new(),
}))
}
fn handle(&self) -> Arc<crate::client::Handle> {
self.0
.handle
.upgrade()
.expect("Handle dropped while scheduler active")
}
pub(crate) fn on_dispatch(&self) {
self.handle().controller.on_dispatch();
}
pub(crate) fn enqueue_transfer(&self, transfer: BoxTransfer) {
let tid = transfer.ctx().id;
let (group_vruntime, desc) = {
let mut transfers = self.0.transfers.write().unwrap();
let group_vruntime = match self.0.ready_set.resolve_group_vruntime(&tid) {
Some(gv) => gv,
None => {
drop(transfers);
let ctx = transfer.ctx();
ctx.set_cancelled();
transfer.on_terminal();
ctx.signal_terminal();
return;
}
};
let desc = TransferDescriptor::new_with_vruntime(
transfer,
self.0.ready_set.min_vruntime(),
group_vruntime.clone(),
);
transfers.insert(desc.id(), desc.clone());
self.0.idle_candidate.store(false, Ordering::SeqCst);
self.handle().scheduler_work_registered();
(group_vruntime, desc)
};
let _ = group_vruntime; let id = desc.id();
match self.0.ready_set.insert(desc) {
Ok(()) => {}
Err(OrphanedChild) => {
self.cancel_transfer(id);
return;
}
}
tracing::debug!(target: telemetry::TARGET_SCHEDULING, tid = %id, "transfer enqueued");
self.generate_work();
}
pub(crate) fn wake(&self, id: TransferId) {
let desc = {
let transfers = self.0.transfers.read().unwrap();
transfers.get(&id).cloned()
};
match desc {
Some(desc) => {
desc.record_wake_request();
let _ = self.0.ready_set.insert(desc);
tracing::trace!(
target: telemetry::TARGET_SCHEDULING,
tid = %id,
"wake",
);
self.generate_work();
}
None => {
tracing::trace!(
target: telemetry::TARGET_SCHEDULING,
tid = %id,
"wake.not_found",
);
}
}
}
pub(crate) fn cancel_transfer(&self, id: TransferId) -> Cancellation {
let (target, children) = self.remove_transfer_atomic(id);
if let Some(desc) = &target {
self.cancel_descriptor(desc.clone());
}
for desc in &children {
self.cancel_descriptor(desc.clone());
}
Cancellation { target, children }
}
fn remove_transfer_atomic(
&self,
id: TransferId,
) -> (Option<TransferDescriptor>, Vec<TransferDescriptor>) {
let mut transfers = self.0.transfers.write().unwrap();
let target = transfers.remove(&id);
let child_keys: Vec<TransferId> = transfers
.keys()
.filter(|tid| tid.parent == Some(id.id))
.copied()
.collect();
let children: Vec<TransferDescriptor> = child_keys
.iter()
.filter_map(|k| transfers.remove(k))
.collect();
if target.is_some() && id.parent.is_none() {
self.0.ready_set.remove_group(id.id);
}
let registry_became_empty =
(target.is_some() || !children.is_empty()) && transfers.is_empty();
if registry_became_empty {
self.0.idle_candidate.store(true, Ordering::SeqCst);
}
drop(transfers);
if registry_became_empty {
self.publish_global_idle_if_candidate();
}
(target, children)
}
fn cancel_descriptor(&self, desc: TransferDescriptor) {
let id = desc.id();
let ctx = desc.transfer().ctx();
if ctx.is_active() {
ctx.set_cancelled();
}
let cleanup_completed = run_on_terminal(&desc);
desc.cancellation_token().cancel();
ctx.signal_terminal();
let purged = self.handle().runtime.remove_pending_for_transfer(id);
self.release_dispatched(purged);
desc.work_purged(purged);
desc.notify_idle();
tracing::debug!(target: telemetry::TARGET_SCHEDULING, tid = %id, purged, "transfer cancelled");
if !cleanup_completed {
tracing::error!(
target: telemetry::TARGET_SCHEDULING,
tid = %id,
"on_terminal panicked; transfer cleanup is incomplete",
);
}
}
pub(crate) fn set_priority(&self, id: TransferId, priority: u8) {
let transfers = self.0.transfers.read().unwrap();
if let Some(desc) = transfers.get(&id) {
desc.set_priority(priority);
}
}
pub(crate) fn on_completion(
&self,
work: ScheduledWork,
outcome: WorkOutcome,
elapsed: Duration,
) {
let outcome_tag = match &outcome {
WorkOutcome::Success { .. } => "success",
WorkOutcome::Yielded => "yielded",
WorkOutcome::Failed { .. } => "failed",
WorkOutcome::Cancelled => "cancelled",
};
tracing::trace!(
target: telemetry::TARGET_SCHEDULING,
tid = %work.descriptor.id(),
?elapsed,
outcome = outcome_tag,
"work execution finished",
);
self.release_dispatched(1);
let completion_sample = if matches!(outcome, WorkOutcome::Yielded) {
None
} else {
let classification = match &outcome {
WorkOutcome::Failed { classification } => *classification,
_ => None,
};
Some(CompletionSample {
error: classification,
})
};
self.handle()
.controller
.on_completion(completion_sample.as_ref());
let desc = &work.descriptor;
let is_idle = desc.work_finished();
if is_idle {
desc.notify_idle();
}
if desc.is_terminal() && is_idle {
let desc_id = desc.id();
let (completed, orphans) = self.remove_transfer_atomic(desc_id);
if !orphans.is_empty() {
tracing::warn!(
target: telemetry::TARGET_SCHEDULING,
parent_id = %desc_id,
child_count = orphans.len(),
"transfer reached terminal+idle in on_completion while \
children still alive; cleaning up. This is a Transfer \
trait contract violation."
);
for desc in orphans {
self.cancel_descriptor(desc);
}
}
if let Some(completed) = completed {
completed.transfer().ctx().signal_terminal();
}
}
self.generate_work();
}
pub(crate) fn on_panic(&self, work: ScheduledWork) {
self.release_dispatched(1);
let desc = &work.descriptor;
let ctx = desc.transfer().ctx();
let err = crate::error::from_kind(crate::error::ErrorKind::RuntimeError)(
"worker panic during execute",
);
ctx.set_failed(err);
let cleanup_completed = run_on_terminal(desc);
ctx.signal_terminal();
let is_idle = desc.work_finished();
if is_idle {
let desc_id = desc.id();
let (_completed, orphans) = self.remove_transfer_atomic(desc_id);
if !orphans.is_empty() {
tracing::warn!(
target: telemetry::TARGET_SCHEDULING,
parent_id = %desc_id,
child_count = orphans.len(),
"panicking transfer reached idle while children still \
alive; cleaning up."
);
for desc in orphans {
self.cancel_descriptor(desc);
}
}
}
desc.notify_idle();
if !cleanup_completed {
tracing::error!(
target: telemetry::TARGET_SCHEDULING,
tid = %desc.id(),
"on_terminal panicked; transfer cleanup is incomplete",
);
}
self.generate_work();
}
fn has_capacity(&self) -> bool {
let target = self.handle().controller.target();
debug_assert!(target >= 1, "concurrency target must be >= 1");
self.0.dispatched.load(Ordering::Relaxed) < target
}
fn recheck_capacity(&self) -> bool {
let target = self.handle().controller.target();
debug_assert!(target >= 1, "concurrency target must be >= 1");
self.0.dispatched.fetch_add(0, Ordering::SeqCst) < target
}
fn submit_and_reenter<'a>(
&'a self,
sub: Submission<'a, ScheduledWork>,
) -> Submission<'a, ScheduledWork> {
if let Some(mut guard) = sub.submit() {
self.handle().runtime.dispatch(&mut guard);
}
self.0.submission_queue.enter()
}
fn enqueue<'a>(
&'a self,
mut sub: Submission<'a, ScheduledWork>,
work: ScheduledWork,
) -> Submission<'a, ScheduledWork> {
let mut pending = work;
loop {
match sub.push(pending) {
Ok(()) => return sub,
Err(returned) => {
sub = self.submit_and_reenter(sub);
pending = returned;
}
}
}
}
fn generate_work(&self) {
let Some(_handle) = self.0.handle.upgrade() else {
return;
};
let Some(mut permit) = self.0.generate_work_gate.try_acquire() else {
return;
};
let mut passes = 0usize;
'generate: loop {
passes += 1;
let mut sub = self.0.submission_queue.enter();
let mut generated = 0usize;
let mut polled = 0usize;
let mut pending_count = 0usize;
let mut done_count = 0usize;
let mut terminal_skipped = 0usize;
tracing::trace!(
target: telemetry::TARGET_SCHEDULING,
has_capacity = self.has_capacity(),
dispatched = self.0.dispatched.load(Ordering::Relaxed),
target = self.handle().controller.target(),
"generate_work.enter",
);
let break_reason = loop {
if !self.has_capacity() {
break "no_capacity";
}
let Some(desc) = self.0.ready_set.pop() else {
break "ready_set_empty";
};
if desc.is_terminal() {
terminal_skipped += 1;
let claim = ClaimGuard::new(&desc);
claim.release();
continue;
}
polled += 1;
let id = desc.id();
desc.clear_wake_request();
desc.transfer().ctx().begin_poll();
let claim = ClaimGuard::new(&desc);
let poll_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
desc.transfer().poll_work()
}));
match poll_result {
Ok(PollWork::Ready { io, spawned }) => {
generated += 1;
desc.work_generated();
if spawned {
desc.work_generated_spawn();
}
claim.hold();
self.0.ready_set.reinsert_under_claim(desc.clone());
self.0.dispatched.fetch_add(1, Ordering::Relaxed);
desc.work_queued();
let work = ScheduledWork {
item: io,
descriptor: desc,
};
sub = self.enqueue(sub, work);
}
Ok(PollWork::Spawned) => {
desc.work_generated_spawn();
claim.hold();
self.0.ready_set.reinsert_under_claim(desc.clone());
}
Ok(PollWork::Pending) => {
pending_count += 1;
tracing::trace!(
target: telemetry::TARGET_SCHEDULING,
tid = %id,
"poll_work.pending",
);
claim.release();
if desc.reconcile_pending_wake() {
let _ = self.0.ready_set.insert(desc);
}
}
Ok(PollWork::Done) => {
done_count += 1;
tracing::trace!(
target: telemetry::TARGET_SCHEDULING,
tid = %id,
"poll_work.done",
);
claim.release();
let desc_id = desc.id();
let (_completed, orphans) = self.remove_transfer_atomic(desc_id);
if !orphans.is_empty() {
tracing::warn!(
target: telemetry::TARGET_SCHEDULING,
parent_id = %desc_id,
child_count = orphans.len(),
"transfer returned PollWork::Done while children \
still alive; cleaning up. This is a Transfer \
trait contract violation."
);
for desc in orphans {
self.cancel_descriptor(desc);
}
}
}
Err(_panic_payload) => {
tracing::error!(
target: telemetry::TARGET_SCHEDULING,
tid = %id,
"panic in poll_work, forcing terminal",
);
drop(claim);
drop(desc);
self.cancel_transfer(id);
}
}
};
if let Some(mut guard) = sub.submit() {
self.handle().runtime.dispatch(&mut guard);
}
tracing::trace!(
target: telemetry::TARGET_SCHEDULING,
generated,
polled,
pending_count,
done_count,
terminal_skipped,
break_reason,
dispatched = self.0.dispatched.load(Ordering::Relaxed),
target = self.handle().controller.target(),
"generate_work.exit",
);
loop {
if permit.try_release() {
return;
}
if self.recheck_capacity() {
if passes < MAX_GENERATION_PASSES
|| self.0.dispatched.fetch_add(0, Ordering::SeqCst) == 0
{
continue 'generate;
}
}
}
}
}
#[allow(dead_code)]
pub(crate) fn is_idle(&self) -> bool {
self.0.transfers.read().unwrap().is_empty()
&& self.0.dispatched.load(Ordering::Relaxed) == 0
}
fn release_dispatched(&self, count: usize) {
if count == 0 {
return;
}
let previous = self.0.dispatched.fetch_sub(count, Ordering::SeqCst);
debug_assert!(
previous >= count,
"released more scheduler dispatch tickets than were outstanding"
);
if previous == count {
self.publish_global_idle_if_candidate();
}
}
fn publish_global_idle_if_candidate(&self) {
if !self.0.idle_candidate.load(Ordering::SeqCst) {
return;
}
let transfers = self.0.transfers.read().unwrap();
if transfers.is_empty()
&& self.0.dispatched.fetch_add(0, Ordering::SeqCst) == 0
&& self.0.idle_candidate.swap(false, Ordering::SeqCst)
{
self.handle().scheduler_became_idle();
}
}
#[cfg(test)]
pub(crate) fn register_empty_group_for_test(&self, group_id: u64) {
self.0.ready_set.register_empty_group_for_test(group_id);
}
#[cfg(test)]
pub(crate) fn group_member_count(&self, group_id: u64) -> Option<usize> {
self.0.ready_set.member_count(group_id)
}
#[cfg(test)]
pub(crate) fn transfer_count(&self) -> usize {
self.0.transfers.read().unwrap().len()
}
#[cfg(test)]
pub(crate) fn dispatched_for_test(&self) -> usize {
self.0.dispatched.load(Ordering::Relaxed)
}
}
fn run_on_terminal(desc: &TransferDescriptor) -> bool {
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
desc.transfer().on_terminal()
}))
.is_ok()
}
#[cfg(test)]
mod tests {
use crate::client::Handle;
use crate::runtime::ScheduledWork;
use crate::scheduler::descriptor::TransferDescriptor;
use crate::scheduler::descriptor::{vruntime_delta_for_cost, IO_WORK_COST, SPAWN_WORK_COST};
use crate::scheduler::transfer::mock::{
BuggyDoneMock, FixedWorkCount, FusedReadySpawnedMock, MockStateMachine,
TerminalWithoutSignalMock, WithDelay, WithExecute,
};
use crate::scheduler::MockTransfer;
use crate::transfer::{
IoRequest, PendingCategory, PendingCause, PollWork, Transfer, TransferContext, TransferId,
WorkOutcome,
};
use aws_smithy_runtime::test_util::capture_test_logs::show_test_logs;
use std::future::Future;
use std::pin::Pin;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{Arc, Barrier};
use std::time::Duration;
fn test_handle(concurrency: usize) -> Arc<Handle> {
let s3_client = aws_smithy_mocks::mock_client!(aws_sdk_s3, []);
let config = crate::Config::builder()
.sdk_client(s3_client)
.build()
.expect("valid config");
Handle::new_for_test(config, concurrency)
}
fn test_handle_with_diagnostics(concurrency: usize, detail: u64) -> Arc<Handle> {
let s3_client = aws_smithy_mocks::mock_client!(aws_sdk_s3, []);
let config = crate::Config::builder()
.sdk_client(s3_client)
.diagnostics_for_test(crate::config::MemoryDiagnosticsConfig::default(), detail)
.build()
.expect("valid config");
Handle::new_for_test(config, concurrency)
}
#[derive(Debug)]
struct WakeBeforePendingTransfer {
ctx: TransferContext,
polls: AtomicUsize,
}
impl Transfer for WakeBeforePendingTransfer {
fn ctx(&self) -> &TransferContext {
&self.ctx
}
fn poll_work(&self) -> PollWork {
if self.polls.fetch_add(1, Ordering::SeqCst) == 0 {
self.ctx.waker().wake_by_ref();
self.ctx
.set_pending(PendingCause::new(PendingCategory::Memory, "test"));
PollWork::Pending
} else {
self.ctx.set_completed();
self.ctx.signal_terminal();
PollWork::Done
}
}
fn execute<'a>(
&'a self,
_work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
Box::pin(async { unreachable!("test transfer produces no work") })
}
}
#[derive(Debug)]
struct TerminalOrderingTransfer {
ctx: TransferContext,
terminal_hook_entered: Arc<Barrier>,
release_terminal_hook: Arc<Barrier>,
}
impl Transfer for TerminalOrderingTransfer {
fn ctx(&self) -> &TransferContext {
&self.ctx
}
fn poll_work(&self) -> PollWork {
self.ctx.set_pending(PendingCause::other("test"));
PollWork::Pending
}
fn execute<'a>(
&'a self,
_work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
Box::pin(async { unreachable!("test transfer produces no work") })
}
fn on_terminal(&self) {
self.terminal_hook_entered.wait();
self.release_terminal_hook.wait();
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn wake_before_pending_is_backfilled_and_repolled() {
let handle = test_handle_with_diagnostics(1, 1);
let id = TransferId {
id: 40_001,
parent: None,
};
let (ctx, completion_rx) = TransferContext::with_id(id, handle.clone());
let observer = ctx.clone();
let polls = AtomicUsize::new(0);
let transfer = WakeBeforePendingTransfer { ctx, polls };
handle.scheduler.enqueue_transfer(Box::new(transfer));
completion_rx
.await
.expect("second poll should complete the transfer");
let stats = observer
.pending_stats()
.expect("summary diagnostics enabled");
assert_eq!(stats.category(PendingCategory::Memory).count, 1);
assert_eq!(stats.terminal_cause, None);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn cancellation_runs_terminal_hook_before_notification() {
let handle = test_handle(1);
let id = TransferId {
id: 40_002,
parent: None,
};
let (ctx, mut completion_rx) = TransferContext::with_id(id, handle.clone());
let entered = Arc::new(Barrier::new(2));
let release = Arc::new(Barrier::new(2));
handle
.scheduler
.enqueue_transfer(Box::new(TerminalOrderingTransfer {
ctx,
terminal_hook_entered: Arc::clone(&entered),
release_terminal_hook: Arc::clone(&release),
}));
let scheduler = handle.scheduler.clone();
let cancel = std::thread::spawn(move || drop(scheduler.cancel_transfer(id)));
entered.wait();
assert_eq!(
completion_rx.try_recv(),
Err(tokio::sync::oneshot::error::TryRecvError::Empty),
"terminal notification must wait for on_terminal cleanup"
);
release.wait();
cancel.join().unwrap();
completion_rx
.await
.expect("cancellation should signal terminal");
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn worker_panic_runs_terminal_hook_before_notification() {
let handle = test_handle(1);
let id = TransferId {
id: 40_003,
parent: None,
};
let (ctx, mut completion_rx) = TransferContext::with_id(id, handle.clone());
let entered = Arc::new(Barrier::new(2));
let release = Arc::new(Barrier::new(2));
let descriptor = TransferDescriptor::new(Box::new(TerminalOrderingTransfer {
ctx,
terminal_hook_entered: Arc::clone(&entered),
release_terminal_hook: Arc::clone(&release),
}));
descriptor.work_queued();
descriptor.work_started();
handle.scheduler.0.dispatched.store(1, Ordering::Relaxed);
let work = ScheduledWork {
item: IoRequest { data: None },
descriptor,
};
let scheduler = handle.scheduler.clone();
let tokio_handle = tokio::runtime::Handle::current();
let panic = std::thread::spawn(move || {
let _runtime = tokio_handle.enter();
scheduler.on_panic(work);
});
entered.wait();
assert_eq!(
completion_rx.try_recv(),
Err(tokio::sync::oneshot::error::TryRecvError::Empty),
"terminal notification must wait for on_terminal cleanup"
);
release.wait();
panic.join().unwrap();
completion_rx
.await
.expect("panic handling should signal terminal");
crate::runtime::test_util::shutdown(&handle).await;
}
#[derive(Debug)]
struct PoisonedTerminalTransfer {
ctx: TransferContext,
state: Arc<std::sync::Mutex<u32>>,
}
impl Transfer for PoisonedTerminalTransfer {
fn ctx(&self) -> &TransferContext {
&self.ctx
}
fn poll_work(&self) -> PollWork {
self.ctx.set_pending(PendingCause::other("test"));
PollWork::Pending
}
fn execute<'a>(
&'a self,
_work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
Box::pin(async { unreachable!("test transfer produces no work") })
}
fn on_terminal(&self) {
let _guard = self.state.lock().unwrap();
}
}
fn poisoned_state() -> Arc<std::sync::Mutex<u32>> {
let state = Arc::new(std::sync::Mutex::new(0u32));
let poisoner = Arc::clone(&state);
let _ = std::thread::spawn(move || {
let _guard = poisoner.lock().unwrap();
panic!("invalid discovery state");
})
.join();
assert!(state.lock().is_err(), "mutex should be poisoned");
state
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn panic_poisoning_state_still_signals_terminal() {
let handle = test_handle(1);
let id = TransferId {
id: 40_009,
parent: None,
};
let (ctx, completion_rx) = TransferContext::with_id(id, handle.clone());
let _handle_side_ctx = ctx.clone();
let state = poisoned_state();
let descriptor = TransferDescriptor::new(Box::new(PoisonedTerminalTransfer {
ctx,
state: Arc::clone(&state),
}));
descriptor.work_queued();
descriptor.work_started();
let observer = descriptor.clone();
handle.scheduler.0.dispatched.store(1, Ordering::Relaxed);
let work = ScheduledWork {
item: IoRequest { data: None },
descriptor,
};
let scheduler = handle.scheduler.clone();
let tokio_handle = tokio::runtime::Handle::current();
let panicker = std::thread::spawn(move || {
let _runtime = tokio_handle.enter();
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| scheduler.on_panic(work)))
.is_err()
});
let signalled = tokio::time::timeout(Duration::from_secs(3), completion_rx).await;
let on_panic_panicked = panicker.join().unwrap();
let received = signalled.expect("join() never released");
assert!(
received.is_ok(),
"terminal never signalled (on_panic panicked: {on_panic_panicked})"
);
assert!(!on_panic_panicked, "on_panic must not re-raise");
assert!(observer.is_idle(), "descriptor should reach idle");
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn cancel_poisoning_state_still_signals_terminal() {
let handle = test_handle(1);
let id = TransferId {
id: 40_010,
parent: None,
};
let (ctx, completion_rx) = TransferContext::with_id(id, handle.clone());
let state = poisoned_state();
handle
.scheduler
.enqueue_transfer(Box::new(PoisonedTerminalTransfer {
ctx,
state: Arc::clone(&state),
}));
let scheduler = handle.scheduler.clone();
let canceller = std::thread::spawn(move || {
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
scheduler.cancel_transfer(id)
}))
});
let signalled = tokio::time::timeout(Duration::from_secs(3), completion_rx).await;
let cancellation = canceller
.join()
.unwrap()
.expect("cancel_transfer must not re-raise");
let received = signalled.expect("join() never released");
assert!(received.is_ok(), "terminal never signalled");
let target = cancellation
.target
.clone()
.expect("cancelled transfer should be registered");
assert!(
target.cancellation_token().is_cancelled(),
"cancellation token should fire"
);
tokio::time::timeout(Duration::from_secs(3), cancellation.wait_for_idle())
.await
.expect("cancelled transfer should reach idle");
crate::runtime::test_util::shutdown(&handle).await;
}
#[derive(Debug)]
struct CountingCompletionController {
completions: AtomicUsize,
samples: AtomicUsize,
}
impl crate::scheduler::ConcurrencyController for CountingCompletionController {
fn target(&self) -> usize {
1
}
fn on_completion(&self, sample: Option<&crate::scheduler::CompletionSample>) {
self.completions.fetch_add(1, Ordering::Relaxed);
if sample.is_some() {
self.samples.fetch_add(1, Ordering::Relaxed);
}
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn yielded_work_releases_capacity_without_reporting_completion() {
let controller = Arc::new(CountingCompletionController {
completions: AtomicUsize::new(0),
samples: AtomicUsize::new(0),
});
let s3_client = aws_smithy_mocks::mock_client!(aws_sdk_s3, []);
let config = crate::Config::builder()
.sdk_client(s3_client)
.build()
.expect("valid config");
let handle = Handle::new_for_test_with_runtime(config, controller.clone(), |weak| {
Arc::new(crate::runtime::TokioMultiThreadRuntime::new(weak))
});
let id = TransferId {
id: 1,
parent: None,
};
let state = Arc::new(WithExecute::new(FixedWorkCount::new(1), |_| {
WorkOutcome::Yielded
}));
handle
.scheduler
.enqueue_transfer(Box::new(MockTransfer::new(id, state)));
tokio::time::timeout(Duration::from_secs(5), async {
while !handle.scheduler.is_idle() {
tokio::task::yield_now().await;
}
})
.await
.expect("scheduler did not drain yielded work");
assert_eq!(controller.completions.load(Ordering::Relaxed), 1);
assert_eq!(controller.samples.load(Ordering::Relaxed), 0);
}
fn test_handle_managed(concurrency: usize) -> Arc<Handle> {
let s3_client = aws_smithy_mocks::mock_client!(aws_sdk_s3, []);
let config = crate::Config::builder()
.sdk_client(s3_client)
.build()
.expect("valid config");
Handle::new_for_test_with_runtime(
config,
Arc::new(crate::scheduler::FixedConcurrency::new(concurrency)),
|weak| Arc::new(crate::runtime::ManagedExecution::for_test(weak, 4)),
)
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn completed_transfer_is_dropped_while_the_client_is_alive() {
let handle = test_handle(1);
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
let sm = Arc::new(FixedWorkCount::new(2));
let released = Arc::downgrade(&sm);
scheduler.enqueue_transfer(Box::new(MockTransfer::new_with_handle(
id,
sm,
Arc::clone(&handle),
)));
let dropped = tokio::time::timeout(Duration::from_secs(2), async {
while released.strong_count() > 0 {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await;
let completed = released.upgrade().map(|sm| sm.completed_count());
assert_eq!(scheduler.transfer_count(), 0, "transfer was not removed");
assert!(
dropped.is_ok(),
"completed transfer is still retained; completed work items: {completed:?}"
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[derive(Debug, Default)]
struct PendingThenDone {
polls: AtomicUsize,
}
impl MockStateMachine for PendingThenDone {
fn poll_work(&self, _id: TransferId) -> PollWork {
if self.polls.fetch_add(1, Ordering::SeqCst) == 0 {
PollWork::Pending
} else {
PollWork::Done
}
}
fn execute<'a>(
&'a self,
_work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
Box::pin(async { WorkOutcome::Success { data: None } })
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn generation_pass_survives_retiring_the_last_handle_owner() {
let handle = test_handle(1);
let scheduler = handle.scheduler.clone();
let released = Arc::downgrade(&handle);
let id = TransferId {
id: 1,
parent: None,
};
scheduler.enqueue_transfer(Box::new(MockTransfer::new_with_handle(
id,
Arc::new(PendingThenDone::default()),
Arc::clone(&handle),
)));
drop(handle);
assert!(
released.upgrade().is_some(),
"the pending transfer holds the handle"
);
scheduler.wake(id);
assert_eq!(scheduler.transfer_count(), 0, "transfer was not removed");
assert!(released.upgrade().is_none(), "the handle is still alive");
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_transfer_completes() {
let _logs = show_test_logs();
let handle = test_handle(4);
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
let sm = Arc::new(FixedWorkCount::new(5));
let transfer = Box::new(MockTransfer::new(id, sm.clone()));
scheduler.enqueue_transfer(transfer);
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
assert!(sm.is_complete());
assert_eq!(sm.completed_count(), 5);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_idle_candidate_waits_for_the_final_dispatch() {
let handle = test_handle(1);
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
scheduler.enqueue_transfer(Box::new(MockTransfer::new_with_handle(
id,
Arc::new(PendingForever),
Arc::clone(&handle),
)));
scheduler.0.dispatched.store(1, Ordering::SeqCst);
let cancellation = scheduler.cancel_transfer(id);
assert_eq!(scheduler.transfer_count(), 0);
assert!(scheduler.0.idle_candidate.load(Ordering::SeqCst));
assert_eq!(handle.buffer_pool.diagnostics().idle_deadlines, 0);
scheduler.release_dispatched(1);
assert!(!scheduler.0.idle_candidate.load(Ordering::SeqCst));
assert_eq!(handle.buffer_pool.diagnostics().idle_deadlines, 1);
drop(cancellation);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_registry_removal_observes_an_already_completed_dispatch() {
let handle = test_handle(1);
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
scheduler.enqueue_transfer(Box::new(MockTransfer::new_with_handle(
id,
Arc::new(PendingForever),
Arc::clone(&handle),
)));
scheduler.0.dispatched.store(1, Ordering::SeqCst);
scheduler.release_dispatched(1);
assert_eq!(handle.buffer_pool.diagnostics().idle_deadlines, 0);
let cancellation = scheduler.cancel_transfer(id);
assert!(!scheduler.0.idle_candidate.load(Ordering::SeqCst));
assert_eq!(handle.buffer_pool.diagnostics().idle_deadlines, 1);
drop(cancellation);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_new_work_cancels_a_pending_idle_candidate() {
let handle = test_handle(1);
let scheduler = &handle.scheduler;
let first_id = TransferId {
id: 1,
parent: None,
};
scheduler.enqueue_transfer(Box::new(MockTransfer::new_with_handle(
first_id,
Arc::new(PendingForever),
Arc::clone(&handle),
)));
scheduler.0.dispatched.store(1, Ordering::SeqCst);
let first_cancellation = scheduler.cancel_transfer(first_id);
assert!(scheduler.0.idle_candidate.load(Ordering::SeqCst));
let second_id = TransferId {
id: 2,
parent: None,
};
scheduler.enqueue_transfer(Box::new(MockTransfer::new_with_handle(
second_id,
Arc::new(PendingForever),
Arc::clone(&handle),
)));
scheduler.release_dispatched(1);
assert!(!scheduler.0.idle_candidate.load(Ordering::SeqCst));
assert_eq!(handle.buffer_pool.diagnostics().idle_deadlines, 0);
drop(first_cancellation);
drop(scheduler.cancel_transfer(second_id));
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_each_managed_work_interval_arms_one_idle_deadline() {
let handle = test_handle(2);
let scheduler = &handle.scheduler;
for expected_deadlines in 1..=2 {
let id = TransferId {
id: expected_deadlines,
parent: None,
};
scheduler.enqueue_transfer(Box::new(MockTransfer::new(
id,
Arc::new(FixedWorkCount::new(1)),
)));
let reached_idle = tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle()
|| handle.buffer_pool.diagnostics().idle_deadlines < expected_deadlines
{
tokio::task::yield_now().await;
}
})
.await;
assert!(
reached_idle.is_ok(),
"completed managed work should arm idle reclamation: \
registered={}, dispatched={}, diagnostics={:?}",
scheduler.transfer_count(),
scheduler.dispatched_for_test(),
handle.buffer_pool.diagnostics(),
);
assert_eq!(
handle.buffer_pool.diagnostics().idle_deadlines,
expected_deadlines,
"one deadline should be armed for each activity-to-idle interval"
);
}
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_transfer_completes_managed_runtime() {
let _logs = show_test_logs();
let handle = test_handle_managed(4);
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
let sm = Arc::new(FixedWorkCount::new(5));
let transfer = Box::new(MockTransfer::new(id, sm.clone()));
scheduler.enqueue_transfer(transfer);
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
assert!(sm.is_complete());
assert_eq!(sm.completed_count(), 5);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_multiple_transfers_complete() {
let handle = test_handle(4);
let scheduler = &handle.scheduler;
let mut state_machines = Vec::new();
for i in 0..3u64 {
let id = TransferId {
id: i,
parent: None,
};
let sm = Arc::new(FixedWorkCount::new(4));
state_machines.push(sm.clone());
scheduler.enqueue_transfer(Box::new(MockTransfer::new(id, sm)));
}
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
for (i, sm) in state_machines.iter().enumerate() {
assert!(sm.is_complete(), "transfer {} should be complete", i);
assert_eq!(sm.completed_count(), 4);
}
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_work_transfers_exceed_concurrency() {
let handle = test_handle(2);
let scheduler = &handle.scheduler;
let mut state_machines = Vec::new();
for i in 0..10u64 {
let id = TransferId {
id: i,
parent: None,
};
let sm = Arc::new(FixedWorkCount::new(1));
state_machines.push(sm.clone());
scheduler.enqueue_transfer(Box::new(MockTransfer::new(id, sm)));
}
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("all 10 transfers should complete - scheduler must generate work after terminal completions");
for (i, sm) in state_machines.iter().enumerate() {
assert!(sm.is_complete(), "transfer {} should be complete", i);
assert_eq!(sm.completed_count(), 1);
}
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[test]
fn test_new_does_not_require_runtime() {
let _handle = test_handle(4);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_set_priority() {
let handle = test_handle(2);
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
let sm = Arc::new(PendingForever);
let transfer = Box::new(MockTransfer::new(id, sm));
scheduler.enqueue_transfer(transfer);
{
let transfers = scheduler.0.transfers.read().unwrap();
let desc = transfers.get(&id).expect("transfer should exist");
assert_eq!(desc.priority(), 128);
}
scheduler.set_priority(id, 255);
{
let transfers = scheduler.0.transfers.read().unwrap();
let desc = transfers.get(&id).expect("transfer should still exist");
assert_eq!(desc.priority(), 255);
}
let fake_id = TransferId {
id: 999,
parent: None,
};
scheduler.set_priority(fake_id, 100);
crate::runtime::test_util::shutdown(&handle).await;
}
#[derive(Debug)]
struct PendingForever;
impl MockStateMachine for PendingForever {
fn poll_work(&self, _id: TransferId) -> PollWork {
PollWork::Pending
}
fn execute<'a>(
&'a self,
_work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
Box::pin(async { unreachable!("PendingForever never generates work") })
}
}
#[derive(Debug)]
struct BlockingExecute {
generated: AtomicBool,
started: tokio::sync::Notify,
release: tokio::sync::Notify,
}
impl BlockingExecute {
fn new() -> Self {
Self {
generated: AtomicBool::new(false),
started: tokio::sync::Notify::new(),
release: tokio::sync::Notify::new(),
}
}
}
impl MockStateMachine for BlockingExecute {
fn poll_work(&self, _id: TransferId) -> PollWork {
if self.generated.swap(true, Ordering::SeqCst) {
PollWork::Pending
} else {
PollWork::ready(IoRequest { data: None })
}
}
fn execute<'a>(
&'a self,
_work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
Box::pin(async move {
self.started.notify_one();
self.release.notified().await;
WorkOutcome::Success { data: None }
})
}
}
async fn cancellation_interrupts_executing_work(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
let state = Arc::new(BlockingExecute::new());
scheduler.enqueue_transfer(Box::new(MockTransfer::new_with_handle(
id,
state.clone(),
handle.clone(),
)));
tokio::time::timeout(Duration::from_secs(5), state.started.notified())
.await
.expect("work did not enter execute");
let result = tokio::time::timeout(
Duration::from_secs(1),
scheduler.cancel_transfer(id).wait_for_idle(),
)
.await;
if result.is_err() {
state.release.notify_waiters();
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::task::yield_now().await;
}
})
.await
.expect("scheduler did not drain released work");
}
crate::runtime::test_util::shutdown(&handle).await;
result.expect("cancellation did not interrupt executing transfer work");
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn cancellation_interrupts_executing_work_on_tokio_runtime() {
cancellation_interrupts_executing_work(test_handle(1)).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn cancellation_interrupts_executing_work_on_managed_runtime() {
cancellation_interrupts_executing_work(test_handle_managed(1)).await;
}
#[derive(Debug)]
struct CompletionCounter {
target: usize,
completions: AtomicUsize,
}
impl CompletionCounter {
fn completions(&self) -> usize {
self.completions.load(Ordering::SeqCst)
}
}
impl crate::scheduler::ConcurrencyController for CompletionCounter {
fn target(&self) -> usize {
self.target
}
fn on_completion(&self, _sample: Option<&crate::scheduler::CompletionSample>) {
self.completions.fetch_add(1, Ordering::SeqCst);
}
}
#[derive(Clone, Copy, Debug)]
enum TestRuntime {
Tokio,
Managed { threads: usize },
}
fn counted_handle(
runtime: TestRuntime,
target: usize,
) -> (Arc<Handle>, Arc<CompletionCounter>) {
let controller = Arc::new(CompletionCounter {
target,
completions: AtomicUsize::new(0),
});
let s3_client = aws_smithy_mocks::mock_client!(aws_sdk_s3, []);
let config = crate::Config::builder()
.sdk_client(s3_client)
.build()
.expect("valid config");
let handle =
Handle::new_for_test_with_runtime(
config,
controller.clone(),
move |weak| match runtime {
TestRuntime::Tokio => {
Arc::new(crate::runtime::TokioMultiThreadRuntime::new(weak))
as Arc<dyn crate::runtime::ExecutionRuntime>
}
TestRuntime::Managed { threads } => {
Arc::new(crate::runtime::ManagedExecution::for_test(weak, threads))
}
},
);
(handle, controller)
}
fn registered_descriptor(
handle: &Handle,
id: TransferId,
) -> crate::scheduler::descriptor::TransferDescriptor {
handle
.scheduler
.0
.transfers
.read()
.unwrap()
.get(&id)
.cloned()
.expect("transfer is not registered with the scheduler")
}
async fn wait_for_scheduler_idle(handle: &Handle) {
tokio::time::timeout(Duration::from_secs(5), async {
while !handle.scheduler.is_idle() {
tokio::task::yield_now().await;
}
})
.await
.expect("scheduler did not drain");
}
async fn expect_descriptor_idle(desc: &crate::scheduler::descriptor::TransferDescriptor) {
tokio::time::timeout(Duration::from_secs(5), desc.wait_for_idle())
.await
.expect("a dispatched work item never reported completion");
assert!(
desc.is_idle(),
"queued/executing counter must return to (0, 0)"
);
}
#[derive(Debug)]
struct GatedSingleWork {
generated: AtomicBool,
finished: AtomicBool,
panics: bool,
started: tokio::sync::Notify,
release: tokio::sync::Notify,
}
impl GatedSingleWork {
fn succeeding() -> Self {
Self::new(false)
}
fn panicking() -> Self {
Self::new(true)
}
fn new(panics: bool) -> Self {
Self {
generated: AtomicBool::new(false),
finished: AtomicBool::new(false),
panics,
started: tokio::sync::Notify::new(),
release: tokio::sync::Notify::new(),
}
}
}
impl MockStateMachine for GatedSingleWork {
fn poll_work(&self, _id: TransferId) -> PollWork {
if !self.generated.swap(true, Ordering::SeqCst) {
PollWork::ready(IoRequest { data: None })
} else if self.finished.load(Ordering::SeqCst) {
PollWork::Done
} else {
PollWork::Pending
}
}
fn execute<'a>(
&'a self,
_work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
Box::pin(async move {
self.started.notify_one();
self.release.notified().await;
if self.panics {
panic!("intentional execute panic");
}
self.finished.store(true, Ordering::SeqCst);
WorkOutcome::Success { data: None }
})
}
}
#[derive(Debug)]
struct ThreadBlockingExecute {
generated: AtomicBool,
started: tokio::sync::Notify,
released: std::sync::Mutex<bool>,
release_cv: std::sync::Condvar,
}
impl ThreadBlockingExecute {
fn new() -> Self {
Self {
generated: AtomicBool::new(false),
started: tokio::sync::Notify::new(),
released: std::sync::Mutex::new(false),
release_cv: std::sync::Condvar::new(),
}
}
fn release(&self) {
*self.released.lock().unwrap() = true;
self.release_cv.notify_all();
}
}
impl MockStateMachine for ThreadBlockingExecute {
fn poll_work(&self, _id: TransferId) -> PollWork {
if self.generated.swap(true, Ordering::SeqCst) {
PollWork::Pending
} else {
PollWork::ready(IoRequest { data: None })
}
}
fn execute<'a>(
&'a self,
_work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
Box::pin(async move {
self.started.notify_one();
let released = self.released.lock().unwrap();
let (_released, _timeout) = self
.release_cv
.wait_timeout_while(released, Duration::from_secs(10), |released| !*released)
.unwrap();
WorkOutcome::Success { data: None }
})
}
}
const BLOCKER_ID: TransferId = TransferId {
id: 100,
parent: None,
};
async fn occupy_managed_thread(
handle: &Arc<Handle>,
) -> (
Arc<ThreadBlockingExecute>,
crate::scheduler::descriptor::TransferDescriptor,
) {
let blocker = Arc::new(ThreadBlockingExecute::new());
handle
.scheduler
.enqueue_transfer(Box::new(MockTransfer::new(BLOCKER_ID, blocker.clone())));
tokio::time::timeout(Duration::from_secs(5), blocker.started.notified())
.await
.expect("blocking work did not enter execute");
(blocker, registered_descriptor(handle, BLOCKER_ID))
}
async fn normal_completion_finishes_work_once(runtime: TestRuntime) {
let (handle, counter) = counted_handle(runtime, 1);
let id = TransferId {
id: 1,
parent: None,
};
let state = Arc::new(GatedSingleWork::succeeding());
handle
.scheduler
.enqueue_transfer(Box::new(MockTransfer::new(id, state.clone())));
tokio::time::timeout(Duration::from_secs(5), state.started.notified())
.await
.expect("work did not enter execute");
let desc = registered_descriptor(&handle, id);
state.release.notify_one();
expect_descriptor_idle(&desc).await;
wait_for_scheduler_idle(&handle).await;
assert!(desc.is_idle());
assert_eq!(counter.completions(), 1);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn normal_completion_finishes_work_once_on_tokio_runtime() {
normal_completion_finishes_work_once(TestRuntime::Tokio).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn normal_completion_finishes_work_once_on_managed_runtime() {
normal_completion_finishes_work_once(TestRuntime::Managed { threads: 4 }).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn terminal_skip_finishes_work_once_on_tokio_runtime() {
let (handle, counter) = counted_handle(TestRuntime::Tokio, 1);
let id = TransferId {
id: 1,
parent: None,
};
let state = Arc::new(FixedWorkCount::new(1));
let transfer = MockTransfer::new(id, state.clone());
let ctx = transfer.ctx().clone();
handle.scheduler.enqueue_transfer(Box::new(transfer));
let desc = registered_descriptor(&handle, id);
assert!(!desc.is_idle(), "work item should be queued");
ctx.set_cancelled();
expect_descriptor_idle(&desc).await;
wait_for_scheduler_idle(&handle).await;
assert!(desc.is_idle());
assert_eq!(counter.completions(), 1);
assert_eq!(state.completed_count(), 0, "terminal work must not execute");
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn terminal_skip_finishes_work_once_on_managed_runtime() {
let (handle, counter) = counted_handle(TestRuntime::Managed { threads: 1 }, 2);
let (blocker, blocker_desc) = occupy_managed_thread(&handle).await;
let id = TransferId {
id: 1,
parent: None,
};
let state = Arc::new(FixedWorkCount::new(1));
let transfer = MockTransfer::new(id, state.clone());
let ctx = transfer.ctx().clone();
handle.scheduler.enqueue_transfer(Box::new(transfer));
let desc = registered_descriptor(&handle, id);
assert!(!desc.is_idle(), "work item should be queued");
ctx.set_cancelled();
blocker.release();
expect_descriptor_idle(&desc).await;
expect_descriptor_idle(&blocker_desc).await;
handle.scheduler.cancel_transfer(BLOCKER_ID);
wait_for_scheduler_idle(&handle).await;
assert!(desc.is_idle());
assert_eq!(counter.completions(), 2);
assert_eq!(state.completed_count(), 0, "terminal work must not execute");
crate::runtime::test_util::shutdown(&handle).await;
}
async fn execute_panic_finishes_work_once(runtime: TestRuntime) {
let (handle, counter) = counted_handle(runtime, 1);
let id = TransferId {
id: 1,
parent: None,
};
let state = Arc::new(GatedSingleWork::panicking());
let transfer = MockTransfer::new(id, state.clone());
let ctx = transfer.ctx().clone();
handle.scheduler.enqueue_transfer(Box::new(transfer));
tokio::time::timeout(Duration::from_secs(5), state.started.notified())
.await
.expect("work did not enter execute");
let desc = registered_descriptor(&handle, id);
state.release.notify_one();
expect_descriptor_idle(&desc).await;
wait_for_scheduler_idle(&handle).await;
assert!(desc.is_idle());
assert!(ctx.is_failed());
assert_eq!(
counter.completions(),
0,
"a panicked work item is reported by on_panic, not on_completion"
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn execute_panic_finishes_work_once_on_tokio_runtime() {
let _logs = show_test_logs();
execute_panic_finishes_work_once(TestRuntime::Tokio).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn execute_panic_finishes_work_once_on_managed_runtime() {
let _logs = show_test_logs();
execute_panic_finishes_work_once(TestRuntime::Managed { threads: 4 }).await;
}
async fn cancel_while_executing_finishes_work_once(runtime: TestRuntime) {
let (handle, counter) = counted_handle(runtime, 1);
let id = TransferId {
id: 1,
parent: None,
};
let state = Arc::new(GatedSingleWork::succeeding());
handle
.scheduler
.enqueue_transfer(Box::new(MockTransfer::new(id, state.clone())));
tokio::time::timeout(Duration::from_secs(5), state.started.notified())
.await
.expect("work did not enter execute");
let desc = registered_descriptor(&handle, id);
let result = tokio::time::timeout(
Duration::from_secs(1),
handle.scheduler.cancel_transfer(id).wait_for_idle(),
)
.await;
if result.is_err() {
state.release.notify_one();
wait_for_scheduler_idle(&handle).await;
crate::runtime::test_util::shutdown(&handle).await;
}
result.expect("cancellation did not interrupt executing transfer work");
wait_for_scheduler_idle(&handle).await;
assert!(desc.is_idle());
assert_eq!(counter.completions(), 1);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn cancel_while_executing_finishes_work_once_on_tokio_runtime() {
cancel_while_executing_finishes_work_once(TestRuntime::Tokio).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn cancel_while_executing_finishes_work_once_on_managed_runtime() {
cancel_while_executing_finishes_work_once(TestRuntime::Managed { threads: 4 }).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn cancel_while_queued_finishes_work_once_on_tokio_runtime() {
let (handle, counter) = counted_handle(TestRuntime::Tokio, 1);
let id = TransferId {
id: 1,
parent: None,
};
let state = Arc::new(FixedWorkCount::new(1));
handle
.scheduler
.enqueue_transfer(Box::new(MockTransfer::new(id, state.clone())));
let desc = registered_descriptor(&handle, id);
assert!(!desc.is_idle(), "work item should be queued");
let cancellation = handle.scheduler.cancel_transfer(id);
tokio::time::timeout(Duration::from_secs(5), cancellation.wait_for_idle())
.await
.expect("purging queued work did not reach idle");
assert!(desc.is_idle());
let follower_id = TransferId {
id: 2,
parent: None,
};
let follower = Arc::new(FixedWorkCount::new(1));
handle
.scheduler
.enqueue_transfer(Box::new(MockTransfer::new(follower_id, follower.clone())));
wait_for_scheduler_idle(&handle).await;
assert!(follower.is_complete());
assert!(desc.is_idle());
assert_eq!(state.completed_count(), 0, "purged work must not execute");
assert_eq!(
counter.completions(),
1,
"only the follower's work item should report completion"
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn cancel_while_queued_finishes_work_once_on_managed_runtime() {
let (handle, counter) = counted_handle(TestRuntime::Managed { threads: 1 }, 2);
let (blocker, blocker_desc) = occupy_managed_thread(&handle).await;
let id = TransferId {
id: 1,
parent: None,
};
let state = Arc::new(FixedWorkCount::new(1));
handle
.scheduler
.enqueue_transfer(Box::new(MockTransfer::new(id, state.clone())));
let desc = registered_descriptor(&handle, id);
assert!(!desc.is_idle(), "work item should be queued");
let cancellation = handle.scheduler.cancel_transfer(id);
blocker.release();
tokio::time::timeout(Duration::from_secs(5), cancellation.wait_for_idle())
.await
.expect("cancelled queued work never reported completion");
expect_descriptor_idle(&blocker_desc).await;
handle.scheduler.cancel_transfer(BLOCKER_ID);
wait_for_scheduler_idle(&handle).await;
assert!(desc.is_idle());
assert_eq!(
state.completed_count(),
0,
"cancelled work must not execute"
);
assert_eq!(counter.completions(), 2);
crate::runtime::test_util::shutdown(&handle).await;
}
#[derive(Debug)]
struct CountingInfinite {
executions: AtomicUsize,
done: std::sync::atomic::AtomicBool,
}
impl CountingInfinite {
fn new() -> Self {
Self {
executions: AtomicUsize::new(0),
done: std::sync::atomic::AtomicBool::new(false),
}
}
fn count(&self) -> usize {
self.executions.load(Ordering::Relaxed)
}
fn set_done(&self) {
self.done.store(true, Ordering::Release);
}
}
impl MockStateMachine for CountingInfinite {
fn poll_work(&self, _id: TransferId) -> PollWork {
if self.done.load(Ordering::Acquire) {
return PollWork::Done;
}
PollWork::ready(IoRequest { data: None })
}
fn execute<'a>(
&'a self,
_work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
Box::pin(async move {
self.executions.fetch_add(1, Ordering::Relaxed);
tokio::task::yield_now().await;
WorkOutcome::Success { data: None }
})
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_priority_affects_work_distribution() {
let handle = test_handle(2);
let scheduler = &handle.scheduler;
let high_id = TransferId {
id: 1,
parent: None,
};
let low_id = TransferId {
id: 2,
parent: None,
};
let high_mock = Arc::new(CountingInfinite::new());
let low_mock = Arc::new(CountingInfinite::new());
let high_transfer = Box::new(MockTransfer::new(high_id, high_mock.clone()));
let low_transfer = Box::new(MockTransfer::new(low_id, low_mock.clone()));
scheduler.enqueue_transfer(high_transfer);
scheduler.enqueue_transfer(low_transfer);
scheduler.set_priority(high_id, 255);
scheduler.set_priority(low_id, 64);
let target_total = 200;
while high_mock.count() + low_mock.count() < target_total {
tokio::time::sleep(Duration::from_millis(1)).await;
}
high_mock.set_done();
low_mock.set_done();
crate::runtime::test_util::shutdown(&handle).await;
let high_count = high_mock.count();
let low_count = low_mock.count();
assert!(
high_count > low_count,
"high priority should execute more: high={}, low={}",
high_count,
low_count
);
let ratio = high_count as f64 / low_count.max(1) as f64;
assert!(
ratio > 3.0,
"expected ratio > 3.0, got {:.2} (high={}, low={})",
ratio,
high_count,
low_count
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_priority_change_mid_flight() {
let handle = test_handle(2);
let scheduler = &handle.scheduler;
let a_id = TransferId {
id: 1,
parent: None,
};
let b_id = TransferId {
id: 2,
parent: None,
};
let a_mock = Arc::new(CountingInfinite::new());
let b_mock = Arc::new(CountingInfinite::new());
scheduler.enqueue_transfer(Box::new(MockTransfer::new(a_id, a_mock.clone())));
scheduler.enqueue_transfer(Box::new(MockTransfer::new(b_id, b_mock.clone())));
while a_mock.count() + b_mock.count() < 100 {
tokio::time::sleep(Duration::from_millis(1)).await;
}
let a_before = a_mock.count();
let b_before = b_mock.count();
scheduler.set_priority(a_id, 255);
scheduler.set_priority(b_id, 1);
while (a_mock.count() - a_before) + (b_mock.count() - b_before) < 200 {
tokio::time::sleep(Duration::from_millis(1)).await;
}
a_mock.set_done();
b_mock.set_done();
crate::runtime::test_util::shutdown(&handle).await;
let a_after = a_mock.count() - a_before;
let b_after = b_mock.count() - b_before;
let ratio = a_after as f64 / b_after.max(1) as f64;
assert!(
ratio > 3.0,
"after priority change (255 vs 1), expected ratio > 3.0, got {:.2} (a={}, b={})",
ratio,
a_after,
b_after
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_failed_transfer_cleaned_up() {
let _logs = show_test_logs();
let handle = test_handle(2);
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
let sm = Arc::new(WithExecute::new(FixedWorkCount::new(1), |_| {
WorkOutcome::Failed {
classification: None,
}
}));
scheduler.enqueue_transfer(Box::new(MockTransfer::new(id, sm)));
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle after failed transfer");
assert!(!scheduler.0.transfers.read().unwrap().contains_key(&id));
crate::runtime::test_util::shutdown(&handle).await;
}
#[derive(Debug)]
struct PanicAfterSignal {
generated: AtomicBool,
started: tokio::sync::Notify,
release: tokio::sync::Notify,
}
impl PanicAfterSignal {
fn new() -> Self {
Self {
generated: AtomicBool::new(false),
started: tokio::sync::Notify::new(),
release: tokio::sync::Notify::new(),
}
}
}
impl MockStateMachine for PanicAfterSignal {
fn poll_work(&self, _id: TransferId) -> PollWork {
if self.generated.swap(true, Ordering::SeqCst) {
PollWork::Done
} else {
PollWork::ready(IoRequest { data: None })
}
}
fn execute<'a>(
&'a self,
_work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
Box::pin(async move {
self.started.notify_one();
self.release.notified().await;
panic!("intentional execute panic")
})
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_panic_transfer_cleaned_up_and_error_propagated() {
let _logs = show_test_logs();
let handle = test_handle(1);
let scheduler = &handle.scheduler;
let panic_id = TransferId {
id: 1,
parent: None,
};
let panic_sm = Arc::new(PanicAfterSignal::new());
let panic_mock = MockTransfer::new(panic_id, Arc::clone(&panic_sm));
let panic_ctx = panic_mock.ctx().clone();
scheduler.enqueue_transfer(Box::new(panic_mock));
tokio::time::timeout(Duration::from_secs(5), panic_sm.started.notified())
.await
.expect("panicking work did not occupy the scheduler slot");
let ok_id = TransferId {
id: 2,
parent: None,
};
let ok_sm = Arc::new(FixedWorkCount::new(3));
scheduler.enqueue_transfer(Box::new(MockTransfer::new(ok_id, ok_sm.clone())));
assert_eq!(scheduler.dispatched_for_test(), 1);
assert_eq!(ok_sm.completed_count(), 0);
panic_sm.release.notify_one();
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
assert!(panic_ctx.is_failed());
assert_eq!(
panic_ctx.error_kind(),
Some(crate::error::ErrorKind::RuntimeError),
);
assert!(!scheduler
.0
.transfers
.read()
.unwrap()
.contains_key(&panic_id));
assert!(ok_sm.is_complete());
assert_eq!(ok_sm.completed_count(), 3);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_cancel_transfer_stops_work() {
let handle = test_handle(2);
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
let inner = FixedWorkCount::new(20);
let sm = Arc::new(WithDelay::new(inner, Duration::from_millis(50)));
let transfer = Box::new(MockTransfer::new(id, sm.clone()));
scheduler.enqueue_transfer(transfer);
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(scheduler.cancel_transfer(id).target.is_some());
assert!(scheduler.cancel_transfer(id).target.is_none());
tokio::time::timeout(Duration::from_secs(2), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle after cancel");
let completed = sm.inner().completed_count();
assert!(
completed < 20,
"expected fewer than 20 completions, got {}",
completed
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_cancel_parent_cascades_to_children() {
let handle = test_handle(4);
let scheduler = &handle.scheduler;
let parent_id = TransferId {
id: 1,
parent: None,
};
let child_ids: Vec<TransferId> = (2..=4)
.map(|i| TransferId {
id: i,
parent: Some(1),
})
.collect();
let parent_sm = Arc::new(WithDelay::new(
FixedWorkCount::new(20),
Duration::from_millis(50),
));
let parent_transfer = MockTransfer::new(parent_id, parent_sm);
let parent_ctx = parent_transfer.ctx().clone();
scheduler.enqueue_transfer(Box::new(parent_transfer));
let mut child_ctxs = Vec::new();
for &cid in &child_ids {
let sm = Arc::new(WithDelay::new(
FixedWorkCount::new(20),
Duration::from_millis(50),
));
let transfer = MockTransfer::new(cid, sm);
child_ctxs.push(transfer.ctx().clone());
scheduler.enqueue_transfer(Box::new(transfer));
}
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(scheduler.cancel_transfer(parent_id).target.is_some());
tokio::time::timeout(Duration::from_secs(2), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle after cascade cancel");
assert!(!parent_ctx.is_active(), "parent should not be active");
for (i, ctx) in child_ctxs.iter().enumerate() {
assert!(!ctx.is_active(), "child {} should not be active", i + 2);
}
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_cancel_parent_with_no_children_still_works() {
let handle = test_handle(2);
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
let sm = Arc::new(WithDelay::new(
FixedWorkCount::new(20),
Duration::from_millis(50),
));
let transfer = MockTransfer::new(id, sm);
let ctx = transfer.ctx().clone();
scheduler.enqueue_transfer(Box::new(transfer));
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(scheduler.cancel_transfer(id).target.is_some());
assert!(scheduler.cancel_transfer(id).target.is_none());
tokio::time::timeout(Duration::from_secs(2), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle after cancel");
assert!(!ctx.is_active(), "parent should not be active");
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_cancel_child_does_not_affect_siblings_or_parent() {
let handle = test_handle(4);
let scheduler = &handle.scheduler;
let parent_id = TransferId {
id: 1,
parent: None,
};
let child_a = TransferId {
id: 2,
parent: Some(1),
};
let child_b = TransferId {
id: 3,
parent: Some(1),
};
let parent_sm = Arc::new(WithDelay::new(
FixedWorkCount::new(20),
Duration::from_millis(50),
));
let parent_transfer = MockTransfer::new(parent_id, parent_sm);
let parent_ctx = parent_transfer.ctx().clone();
scheduler.enqueue_transfer(Box::new(parent_transfer));
let sm_a = Arc::new(WithDelay::new(
FixedWorkCount::new(20),
Duration::from_millis(50),
));
let transfer_a = MockTransfer::new(child_a, sm_a);
let ctx_a = transfer_a.ctx().clone();
scheduler.enqueue_transfer(Box::new(transfer_a));
let sm_b = Arc::new(WithDelay::new(
FixedWorkCount::new(20),
Duration::from_millis(50),
));
let transfer_b = MockTransfer::new(child_b, sm_b);
let ctx_b = transfer_b.ctx().clone();
scheduler.enqueue_transfer(Box::new(transfer_b));
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(scheduler.cancel_transfer(child_a).target.is_some());
assert!(ctx_a.is_cancelled(), "child A should be cancelled");
assert!(parent_ctx.is_active(), "parent should still be active");
assert!(ctx_b.is_active(), "sibling B should still be active");
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_cancel_nonexistent_transfer_returns_false() {
let handle = test_handle(2);
let scheduler = &handle.scheduler;
let fake_id = TransferId {
id: 999,
parent: None,
};
assert!(scheduler.cancel_transfer(fake_id).target.is_none());
crate::runtime::test_util::shutdown(&handle).await;
}
use crate::scheduler::transfer::mock::{
ChildMockTransfer, CompositeMock, CountedWork, DispatchCounter, DispatchTrace,
PanickingCompositeMock, SingleTicketCompositeMock,
};
async fn impl_single_composite_uses_target_fully(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let counter = DispatchCounter::new();
let id = TransferId {
id: 1,
parent: None,
};
let composite = CompositeMock::new(
id,
handle.clone(),
200, 1, 10000, counter.clone(),
);
scheduler.enqueue_transfer(Box::new(composite));
let start = tokio::time::Instant::now();
tokio::time::timeout(Duration::from_secs(30), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
let elapsed = start.elapsed();
let total_dispatches = counter.count();
assert_eq!(total_dispatches, 200, "all 200 children should complete");
assert!(
elapsed < Duration::from_secs(15),
"took too long: {:?}",
elapsed
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_composite_uses_target_fully() {
let handle = test_handle(200);
impl_single_composite_uses_target_fully(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_composite_uses_target_fully_managed_runtime() {
let handle = test_handle_managed(20);
impl_single_composite_uses_target_fully(handle).await;
}
async fn impl_composite_vs_single_fair_share_at_root(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let c_counter = DispatchCounter::new();
let c_id = TransferId {
id: 1,
parent: None,
};
let composite = CompositeMock::new(c_id, handle.clone(), 50, 1, 10000, c_counter.clone());
scheduler.enqueue_transfer(Box::new(composite));
let s_counter = DispatchCounter::new();
let s_id = TransferId {
id: 2,
parent: None,
};
let sm = Arc::new(CountedWork::new(50, s_counter.clone()));
let transfer = MockTransfer::new_with_handle(s_id, sm, handle.clone());
scheduler.enqueue_transfer(Box::new(transfer));
tokio::time::timeout(Duration::from_secs(30), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
let c_count = c_counter.count();
let s_count = s_counter.count();
let total = c_count + s_count;
let fair_share = total as f64 / 2.0;
let tolerance = fair_share * 0.10;
assert!(
(c_count as f64 - fair_share).abs() < tolerance,
"composite got {} dispatches, expected ~{} (tolerance {})",
c_count,
fair_share,
tolerance
);
assert!(
(s_count as f64 - fair_share).abs() < tolerance,
"single got {} dispatches, expected ~{} (tolerance {})",
s_count,
fair_share,
tolerance
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_composite_vs_single_fair_share_at_root() {
let handle = test_handle(100);
impl_composite_vs_single_fair_share_at_root(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_composite_vs_single_fair_share_at_root_managed_runtime() {
let handle = test_handle_managed(20);
impl_composite_vs_single_fair_share_at_root(handle).await;
}
async fn impl_two_composites_fair_share_regardless_of_fan_out(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let c1_counter = DispatchCounter::new();
let c1_id = TransferId {
id: 1,
parent: None,
};
let c1 = CompositeMock::new(c1_id, handle.clone(), 50, 20, 10000, c1_counter.clone());
scheduler.enqueue_transfer(Box::new(c1));
let c2_counter = DispatchCounter::new();
let c2_id = TransferId {
id: 2,
parent: None,
};
let c2 = CompositeMock::new(c2_id, handle.clone(), 50, 20, 10000, c2_counter.clone());
scheduler.enqueue_transfer(Box::new(c2));
let total_work = 2 * 50 * 20;
tokio::time::timeout(Duration::from_secs(15), async {
loop {
let total = c1_counter.count() + c2_counter.count();
if total >= 1200 || total >= total_work {
break;
}
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.expect("should reach the fairness sampling window");
let c1_count = c1_counter.count();
let c2_count = c2_counter.count();
let total = c1_count + c2_count;
let fair_share = total as f64 / 2.0;
let tolerance = fair_share * 0.10;
assert!(
(c1_count as f64 - fair_share).abs() < tolerance,
"C1 got {} dispatches, expected ~{} (tolerance {}), C2 got {}",
c1_count,
fair_share,
tolerance,
c2_count
);
assert!(
(c2_count as f64 - fair_share).abs() < tolerance,
"C2 got {} dispatches, expected ~{} (tolerance {}), C1 got {}",
c2_count,
fair_share,
tolerance,
c1_count
);
tokio::time::timeout(Duration::from_secs(30), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("sampled composites should drain before shutdown");
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_two_composites_fair_share_regardless_of_fan_out() {
let handle = test_handle(100);
impl_two_composites_fair_share_regardless_of_fan_out(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_two_composites_fair_share_regardless_of_fan_out_managed_runtime() {
let handle = test_handle_managed(20);
impl_two_composites_fair_share_regardless_of_fan_out(handle).await;
}
async fn impl_heterogeneous_within_group_proportional_share(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let small_counter = DispatchCounter::new();
let large_counter = DispatchCounter::new();
let parent_id = TransferId {
id: 1,
parent: None,
};
scheduler.register_empty_group_for_test(parent_id.id);
let small_id = TransferId {
id: 2,
parent: Some(1),
};
let large_id = TransferId {
id: 3,
parent: Some(1),
};
let sm_small = Arc::new(CountedWork::new(1, small_counter.clone()));
let sm_large = Arc::new(CountedWork::new(100, large_counter.clone()));
let t_small = MockTransfer::new_with_handle(small_id, sm_small.clone(), handle.clone());
let t_large = MockTransfer::new_with_handle(large_id, sm_large.clone(), handle.clone());
scheduler.enqueue_transfer(Box::new(t_small));
scheduler.enqueue_transfer(Box::new(t_large));
tokio::time::timeout(Duration::from_secs(10), async {
while !sm_small.is_complete() || !sm_large.is_complete() {
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.expect("both children should complete");
assert_eq!(small_counter.count(), 1);
assert_eq!(large_counter.count(), 100);
assert!(
sm_small.is_complete(),
"c_small should complete before c_large finishes all 100 items"
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_heterogeneous_within_group_proportional_share() {
let handle = test_handle(4);
impl_heterogeneous_within_group_proportional_share(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_heterogeneous_within_group_proportional_share_managed_runtime() {
let handle = test_handle_managed(4);
impl_heterogeneous_within_group_proportional_share(handle).await;
}
async fn impl_memory_cap_returns_pending_at_limit(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let counter = DispatchCounter::new();
let notify = Arc::new(tokio::sync::Notify::new());
let id = TransferId {
id: 1,
parent: None,
};
let composite = CompositeMock::new_blocking(
id,
handle.clone(),
100, 5, counter.clone(),
notify.clone(),
);
scheduler.enqueue_transfer(Box::new(composite));
tokio::time::sleep(Duration::from_millis(200)).await;
assert_eq!(
counter.count(),
0,
"no children should have completed (they're blocking)"
);
let transfer_count = scheduler.transfer_count();
assert!(
transfer_count >= 1,
"at least the composite should be tracked, got {}",
transfer_count
);
tokio::time::sleep(Duration::from_millis(100)).await;
assert_eq!(
counter.count(),
0,
"still no completions without releasing barrier"
);
scheduler.cancel_transfer(id);
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle after cancellation");
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_memory_cap_returns_pending_at_limit() {
let handle = test_handle(10);
impl_memory_cap_returns_pending_at_limit(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_memory_cap_returns_pending_at_limit_managed_runtime() {
let handle = test_handle_managed(10);
impl_memory_cap_returns_pending_at_limit(handle).await;
}
async fn impl_memory_cap_release_resumes_spawning(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let counter = DispatchCounter::new();
let notify = Arc::new(tokio::sync::Notify::new());
let id = TransferId {
id: 1,
parent: None,
};
let composite = CompositeMock::new_blocking(
id,
handle.clone(),
20, 5, counter.clone(),
notify.clone(),
);
scheduler.enqueue_transfer(Box::new(composite));
tokio::time::sleep(Duration::from_millis(200)).await;
assert_eq!(counter.count(), 0, "children should be blocking");
for iteration in 0..3u64 {
notify.notify_waiters();
tokio::time::timeout(Duration::from_secs(3), async {
loop {
if counter.count() > iteration {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap_or_else(|_| {
panic!(
"iteration {}: expected >{} completions, got {}",
iteration,
iteration,
counter.count()
)
});
}
assert!(
counter.count() >= 3,
"expected at least 3 completions after 3 releases, got {}",
counter.count()
);
scheduler.cancel_transfer(id);
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_memory_cap_release_resumes_spawning() {
let handle = test_handle(10);
impl_memory_cap_release_resumes_spawning(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_memory_cap_release_resumes_spawning_managed_runtime() {
let handle = test_handle_managed(10);
impl_memory_cap_release_resumes_spawning(handle).await;
}
async fn impl_priority_change_shifts_root_share(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let hi_counter = DispatchCounter::new();
let lo_counter = DispatchCounter::new();
let hi_id = TransferId {
id: 1,
parent: None,
};
let lo_id = TransferId {
id: 2,
parent: None,
};
let sm_hi = Arc::new(WithDelay::new(
CountedWork::new(1000, hi_counter.clone()),
Duration::from_millis(1),
));
let sm_lo = Arc::new(WithDelay::new(
CountedWork::new(1000, lo_counter.clone()),
Duration::from_millis(1),
));
let t_hi = MockTransfer::new_with_handle(hi_id, sm_hi, handle.clone());
let t_lo = MockTransfer::new_with_handle(lo_id, sm_lo, handle.clone());
scheduler.enqueue_transfer(Box::new(t_hi));
scheduler.enqueue_transfer(Box::new(t_lo));
scheduler.set_priority(hi_id, 255); scheduler.set_priority(lo_id, 64);
tokio::time::timeout(Duration::from_secs(10), async {
loop {
let total = hi_counter.count() + lo_counter.count();
if total >= 800 {
break;
}
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.expect("should reach 800 dispatches");
let hi_count = hi_counter.count();
let lo_count = lo_counter.count();
let ratio = hi_count as f64 / lo_count.max(1) as f64;
assert!(
ratio > 3.5,
"expected ratio > 3.5, got {:.2} (hi={}, lo={})",
ratio,
hi_count,
lo_count
);
scheduler.cancel_transfer(hi_id);
scheduler.cancel_transfer(lo_id);
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle after cancellation");
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_priority_change_shifts_root_share() {
let handle = test_handle(4);
impl_priority_change_shifts_root_share(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_priority_change_shifts_root_share_managed_runtime() {
let handle = test_handle_managed(4);
impl_priority_change_shifts_root_share(handle).await;
}
async fn impl_cancellation_cascades_in_hierarchical_structure(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let counter = DispatchCounter::new();
let notify = Arc::new(tokio::sync::Notify::new());
let c_id = TransferId {
id: 1,
parent: None,
};
let composite = CompositeMock::new_blocking(
c_id,
handle.clone(),
20, 20, counter.clone(),
notify.clone(),
);
scheduler.enqueue_transfer(Box::new(composite));
tokio::time::sleep(Duration::from_millis(300)).await;
assert!(scheduler.cancel_transfer(c_id).target.is_some());
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle after cancellation");
assert_eq!(
scheduler.group_member_count(c_id.id),
None,
"group should be removed after cancellation"
);
assert_eq!(
scheduler.transfer_count(),
0,
"all transfers should be purged"
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_cancellation_cascades_in_hierarchical_structure() {
let handle = test_handle(10);
impl_cancellation_cascades_in_hierarchical_structure(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_cancellation_cascades_in_hierarchical_structure_managed_runtime() {
let handle = test_handle_managed(10);
impl_cancellation_cascades_in_hierarchical_structure(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_panic_in_composite_poll_work() {
let handle = test_handle(4);
let scheduler = &handle.scheduler;
let panic_id = TransferId {
id: 1,
parent: None,
};
let panicker = PanickingCompositeMock::new(panic_id, handle.clone());
scheduler.enqueue_transfer(Box::new(panicker));
let s_counter = DispatchCounter::new();
let s_id = TransferId {
id: 2,
parent: None,
};
let sm = Arc::new(CountedWork::new(10, s_counter.clone()));
let peer = MockTransfer::new_with_handle(s_id, sm.clone(), handle.clone());
scheduler.enqueue_transfer(Box::new(peer));
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle despite panic");
assert_eq!(
s_counter.count(),
10,
"peer transfer should complete all work"
);
assert_eq!(
scheduler.group_member_count(panic_id.id),
None,
"panicking composite's group should be removed"
);
assert!(scheduler.is_idle());
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_done_with_live_children_does_not_hang() {
let _logs = show_test_logs();
let handle = test_handle(2);
let scheduler = &handle.scheduler;
let parent_id = TransferId {
id: 1,
parent: None,
};
let (mock, _terminals) = BuggyDoneMock::new(parent_id, handle.clone(), 3);
scheduler.enqueue_transfer(Box::new(mock));
tokio::time::timeout(Duration::from_secs(2), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should reach idle; orphaned children would hang it");
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_done_orphans_have_terminal_signaled() {
let _logs = show_test_logs();
let handle = test_handle(2);
let scheduler = &handle.scheduler;
let parent_id = TransferId {
id: 1,
parent: None,
};
let (mock, terminals) = BuggyDoneMock::new(parent_id, handle.clone(), 3);
scheduler.enqueue_transfer(Box::new(mock));
tokio::time::timeout(Duration::from_secs(2), async {
loop {
if terminals.lock().unwrap().is_some()
&& !terminals.lock().unwrap().as_ref().unwrap().is_empty()
{
break;
}
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.expect("BuggyDoneMock should populate child terminals during poll_work");
let child_terminals = terminals
.lock()
.unwrap()
.take()
.expect("child terminals should be available");
assert_eq!(child_terminals.len(), 3, "expected 3 child terminals");
for term in child_terminals {
tokio::time::timeout(Duration::from_secs(2), term)
.await
.expect("child terminal should fire (cancelled by Done branch)")
.expect("terminal sender should not have been dropped");
}
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_terminal_without_signal_does_not_strand_handle() {
let _logs = show_test_logs();
let handle = test_handle(2);
let scheduler = &handle.scheduler;
let parent_id = TransferId {
id: 1,
parent: None,
};
let (mock, completion_rx) = TerminalWithoutSignalMock::new(parent_id, handle.clone());
scheduler.enqueue_transfer(Box::new(mock));
tokio::time::timeout(Duration::from_secs(2), completion_rx)
.await
.expect("parent completion must be signaled on scheduler removal, not strand")
.expect("terminal sender should not have been dropped");
tokio::time::timeout(Duration::from_secs(2), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should reach idle");
crate::runtime::test_util::shutdown(&handle).await;
}
#[derive(Debug)]
struct SpawnedThenDone {
spawned_remaining: AtomicUsize,
poll_count: AtomicUsize,
}
impl SpawnedThenDone {
fn new(spawned_count: usize) -> Self {
Self {
spawned_remaining: AtomicUsize::new(spawned_count),
poll_count: AtomicUsize::new(0),
}
}
fn poll_count(&self) -> usize {
self.poll_count.load(Ordering::SeqCst)
}
}
impl MockStateMachine for SpawnedThenDone {
fn poll_work(&self, _id: TransferId) -> PollWork {
self.poll_count.fetch_add(1, Ordering::SeqCst);
let prev = self.spawned_remaining.fetch_sub(1, Ordering::SeqCst);
if prev == 0 {
PollWork::Done
} else {
PollWork::Spawned
}
}
fn execute<'a>(
&'a self,
_work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
unreachable!("SpawnedThenDone never returns PollWork::Ready")
}
}
async fn impl_spawned_does_not_increment_dispatched(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
let sm = Arc::new(SpawnedThenDone::new(1));
let transfer = Box::new(MockTransfer::new_with_handle(id, sm, handle.clone()));
scheduler.enqueue_transfer(transfer);
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
assert_eq!(
scheduler.dispatched_for_test(),
0,
"dispatched should be 0 after Spawned+Done (no work items dispatched)"
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawned_does_not_increment_dispatched() {
let handle = test_handle(4);
impl_spawned_does_not_increment_dispatched(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawned_does_not_increment_dispatched_managed_runtime() {
let handle = test_handle_managed(4);
impl_spawned_does_not_increment_dispatched(handle).await;
}
async fn impl_spawned_reinserts_and_repolls(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
let n = 5;
let sm = Arc::new(SpawnedThenDone::new(n));
let transfer = Box::new(MockTransfer::new_with_handle(
id,
sm.clone(),
handle.clone(),
));
scheduler.enqueue_transfer(transfer);
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
assert_eq!(
sm.poll_count(),
n + 1,
"expected {} polls (N Spawned + 1 Done), got {}",
n + 1,
sm.poll_count()
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawned_reinserts_and_repolls() {
let handle = test_handle(4);
impl_spawned_reinserts_and_repolls(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawned_reinserts_and_repolls_managed_runtime() {
let handle = test_handle_managed(4);
impl_spawned_reinserts_and_repolls(handle).await;
}
async fn impl_single_ticket_caps_materialization_near_target(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let counter = DispatchCounter::new();
let notify = Arc::new(tokio::sync::Notify::new());
let id = TransferId {
id: 1,
parent: None,
};
let target = 200;
let total_children = 2000;
let composite = SingleTicketCompositeMock::new_blocking(
id,
handle.clone(),
total_children,
100_000, counter.clone(),
notify.clone(),
);
scheduler.enqueue_transfer(Box::new(composite));
let mut max_observed: usize = 0;
let deadline = tokio::time::Instant::now() + Duration::from_millis(500);
while tokio::time::Instant::now() < deadline {
let dispatched = scheduler.dispatched_for_test();
if dispatched > max_observed {
max_observed = dispatched;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
assert!(
max_observed <= target,
"max dispatched ({}) must not exceed target ({})",
max_observed,
target
);
assert!(
max_observed > 0,
"at least some children should have been dispatched"
);
notify.notify_waiters();
let notify_clone = notify.clone();
let notifier = tokio::spawn(async move {
loop {
notify_clone.notify_waiters();
tokio::time::sleep(Duration::from_millis(5)).await;
}
});
tokio::time::timeout(Duration::from_secs(30), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle after releasing children");
notifier.abort();
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_ticket_caps_materialization_near_target() {
let handle = test_handle(200);
impl_single_ticket_caps_materialization_near_target(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_ticket_caps_materialization_near_target_managed_runtime() {
let handle = test_handle_managed(200);
impl_single_ticket_caps_materialization_near_target(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_fused_ready_spawned_charges_both_io_and_spawn_vruntime() {
let handle = test_handle(4);
let scheduler = &handle.scheduler;
let id = TransferId {
id: 1,
parent: None,
};
let sm = Arc::new(FusedReadySpawnedMock::new());
let transfer = Box::new(MockTransfer::new_with_handle(id, sm, handle.clone()));
scheduler.enqueue_transfer(transfer);
let expected = vruntime_delta_for_cost(IO_WORK_COST, 128)
+ vruntime_delta_for_cost(SPAWN_WORK_COST, 128);
let observed = {
let transfers = scheduler.0.transfers.read().unwrap();
transfers
.get(&id)
.expect("transfer should still be present")
.vruntime()
};
assert_eq!(
observed,
expected,
"fused Ready{{spawned:true}} must charge IO ({}) + spawn ({}) = {}, got {}",
vruntime_delta_for_cost(IO_WORK_COST, 128),
vruntime_delta_for_cost(SPAWN_WORK_COST, 128),
expected,
observed
);
scheduler.cancel_transfer(id).wait_for_idle().await;
crate::runtime::test_util::shutdown(&handle).await;
}
async fn impl_single_ticket_completes_all(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let counter = DispatchCounter::new();
let id = TransferId {
id: 1,
parent: None,
};
let total_children = 500;
let composite = SingleTicketCompositeMock::new(
id,
handle.clone(),
total_children,
1, 100_000, counter.clone(),
);
scheduler.enqueue_transfer(Box::new(composite));
tokio::time::timeout(Duration::from_secs(30), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
assert_eq!(
counter.count(),
total_children,
"all {} children should have been dispatched",
total_children
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_ticket_completes_all() {
let handle = test_handle(50);
impl_single_ticket_completes_all(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_ticket_completes_all_managed_runtime() {
let handle = test_handle_managed(50);
impl_single_ticket_completes_all(handle).await;
}
async fn impl_single_ticket_two_composites_fair_share(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
const C1: u8 = 1;
const C2: u8 = 2;
const TOTAL_CHILDREN: u64 = 400;
const WORK_PER_CHILD: u64 = 5;
const WARMUP_PER_COMPOSITE: usize = 100;
const SAMPLE_DISPATCHES: usize = 1200;
let work_per_composite = TOTAL_CHILDREN * WORK_PER_CHILD;
let total_work = 2 * work_per_composite;
let trace = DispatchTrace::new(total_work as usize);
let c1_counter = trace.counter(C1);
let c2_counter = trace.counter(C2);
let c1_id = TransferId {
id: 1,
parent: None,
};
let c2_id = TransferId {
id: 2,
parent: None,
};
let c1 = SingleTicketCompositeMock::new(
c1_id,
handle.clone(),
TOTAL_CHILDREN,
WORK_PER_CHILD,
100_000, c1_counter.clone(),
);
let c2 = SingleTicketCompositeMock::new(
c2_id,
handle.clone(),
TOTAL_CHILDREN,
WORK_PER_CHILD,
100_000, c2_counter.clone(),
);
scheduler.enqueue_transfer(Box::new(c1));
scheduler.enqueue_transfer(Box::new(c2));
tokio::time::timeout(Duration::from_secs(30), async {
loop {
let completed = c1_counter.count() + c2_counter.count();
if completed >= total_work && scheduler.is_idle() {
break;
}
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.expect("both composites should complete");
assert_eq!(c1_counter.count(), work_per_composite);
assert_eq!(c2_counter.count(), work_per_composite);
let dispatches = trace.snapshot();
assert_eq!(dispatches.len(), total_work as usize);
let mut c1_seen = 0;
let mut c2_seen = 0;
let mut sample_start = None;
let mut overlap_end = None;
for (index, label) in dispatches.iter().copied().enumerate() {
match label {
C1 => c1_seen += 1,
C2 => c2_seen += 1,
other => panic!("unknown dispatch trace label {other}"),
}
if sample_start.is_none()
&& c1_seen >= WARMUP_PER_COMPOSITE
&& c2_seen >= WARMUP_PER_COMPOSITE
{
sample_start = Some(index + 1);
}
if overlap_end.is_none()
&& (c1_seen == work_per_composite as usize
|| c2_seen == work_per_composite as usize)
{
overlap_end = Some(index + 1);
}
}
let sample_start = sample_start.expect("both composites should reach the warmup");
let overlap_end = overlap_end.expect("one composite should finish");
let sample_end = sample_start + SAMPLE_DISPATCHES;
assert!(
sample_end <= overlap_end,
"only {} jointly runnable dispatches remain after the warmup; expected \
{SAMPLE_DISPATCHES}",
overlap_end.saturating_sub(sample_start)
);
let sample = &dispatches[sample_start..sample_end];
let c1_count = sample.iter().filter(|&&label| label == C1).count() as u64;
let c2_count = sample.iter().filter(|&&label| label == C2).count() as u64;
let total = SAMPLE_DISPATCHES as u64;
let fair_share = total as f64 / 2.0;
let tolerance = fair_share * 0.10;
assert!(
(c1_count as f64 - fair_share).abs() < tolerance,
"C1 got {} dispatches, expected ~{} (tolerance {}), C2 got {}",
c1_count,
fair_share,
tolerance,
c2_count
);
assert!(
(c2_count as f64 - fair_share).abs() < tolerance,
"C2 got {} dispatches, expected ~{} (tolerance {}), C1 got {}",
c2_count,
fair_share,
tolerance,
c1_count
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_ticket_two_composites_fair_share() {
let handle = test_handle(100);
impl_single_ticket_two_composites_fair_share(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_ticket_two_composites_fair_share_managed_runtime() {
let handle = test_handle_managed(20);
impl_single_ticket_two_composites_fair_share(handle).await;
}
async fn impl_single_ticket_memory_cap_backstops(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let counter = DispatchCounter::new();
let notify = Arc::new(tokio::sync::Notify::new());
let id = TransferId {
id: 1,
parent: None,
};
let memory_cap = 10; let total_children = 100;
let composite = SingleTicketCompositeMock::new_blocking(
id,
handle.clone(),
total_children,
memory_cap,
counter.clone(),
notify.clone(),
);
scheduler.enqueue_transfer(Box::new(composite));
tokio::time::sleep(Duration::from_millis(500)).await;
let dispatched = scheduler.dispatched_for_test();
assert!(
dispatched <= memory_cap as usize + 2, "dispatched ({}) should not exceed memory_cap ({})",
dispatched,
memory_cap
);
scheduler.cancel_transfer(id);
tokio::time::timeout(Duration::from_secs(5), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle after cancellation");
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_ticket_memory_cap_backstops() {
let handle = test_handle(200);
impl_single_ticket_memory_cap_backstops(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_ticket_memory_cap_backstops_managed_runtime() {
let handle = test_handle_managed(200);
impl_single_ticket_memory_cap_backstops(handle).await;
}
async fn impl_spawned_spin_guard_does_not_starve_peer(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let poll_log = Arc::new(std::sync::Mutex::new(Vec::new()));
let mut setup = scheduler
.0
.generate_work_gate
.try_acquire()
.expect("scheduler must be idle before setup");
let c_counter = DispatchCounter::new();
let c_id = TransferId {
id: 1,
parent: None,
};
let composite = SingleTicketCompositeMock::new(
c_id,
handle.clone(),
200,
1, 100_000, c_counter.clone(),
)
.with_poll_log(poll_log.clone());
scheduler.enqueue_transfer(Box::new(composite));
let s_counter = DispatchCounter::new();
let s_id = TransferId {
id: 2,
parent: None,
};
let peer = ChildMockTransfer::new(s_id, handle.clone(), 200, s_counter.clone())
.with_poll_log(poll_log.clone());
scheduler.enqueue_transfer(Box::new(peer));
while !setup.try_release() {}
scheduler.generate_work();
tokio::time::timeout(Duration::from_secs(30), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
crate::runtime::test_util::shutdown(&handle).await;
let log = poll_log.lock().unwrap();
assert_eq!(
log.first(),
Some(&c_id.id),
"composite must be polled first"
);
let first_peer = log
.iter()
.position(|&id| id == s_id.id)
.expect("peer must be polled");
let composite_polls = log[..first_peer]
.iter()
.filter(|&&id| id == c_id.id)
.count();
assert!(
composite_polls < 100,
"peer must be polled before 100 composite polls (got {composite_polls}); spin guard may be broken"
);
assert_eq!(c_counter.count(), 200);
assert_eq!(s_counter.count(), 200);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawned_spin_guard_does_not_starve_peer() {
let handle = test_handle(50);
impl_spawned_spin_guard_does_not_starve_peer(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawned_spin_guard_does_not_starve_peer_managed_runtime() {
let handle = test_handle_managed(20);
impl_spawned_spin_guard_does_not_starve_peer(handle).await;
}
async fn impl_spawn_model_non_blocking(
handle: Arc<Handle>,
_target: usize,
work_per_child: u64,
total_children: u64,
) -> (usize, u64) {
let scheduler = &handle.scheduler;
let counter = DispatchCounter::new();
let id = TransferId {
id: 1,
parent: None,
};
let composite = SingleTicketCompositeMock::new(
id,
handle.clone(),
total_children,
work_per_child,
100_000, counter.clone(),
);
let (spawned_handle, terminated_handle) = composite.observer_handles();
scheduler.enqueue_transfer(Box::new(composite));
let mut max_dispatched: usize = 0;
let mut max_alive: u64 = 0;
let deadline = tokio::time::Instant::now() + Duration::from_millis(800);
while tokio::time::Instant::now() < deadline {
let dispatched = scheduler.dispatched_for_test();
let spawned = spawned_handle.load(Ordering::SeqCst);
let terminated = terminated_handle.load(Ordering::SeqCst);
let alive = spawned.saturating_sub(terminated);
if dispatched > max_dispatched {
max_dispatched = dispatched;
}
if alive > max_alive {
max_alive = alive;
}
tokio::time::sleep(Duration::from_millis(5)).await;
}
tokio::time::timeout(Duration::from_secs(30), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle after all children complete");
crate::runtime::test_util::shutdown(&handle).await;
(max_dispatched, max_alive)
}
async fn impl_test_spawn_model_small_objects(handle: Arc<Handle>) {
let target: usize = 8;
let (max_dispatched, max_alive) =
impl_spawn_model_non_blocking(handle, target, 1, 160).await;
assert!(
max_dispatched <= target + 4,
"DIAGNOSTIC small_objects: max_dispatched ({}) should be near target ({}); \
max_alive={}",
max_dispatched,
target,
max_alive,
);
println!(
"DIAGNOSTIC small_objects: target={}, max_dispatched={}, max_alive={}",
target, max_dispatched, max_alive
);
assert!(
max_alive <= 100,
"DIAGNOSTIC small_objects: max_alive ({}) ran well beyond expected bounds; \
target={}, max_dispatched={}",
max_alive,
target,
max_dispatched,
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawn_model_small_objects() {
let _logs = show_test_logs();
let handle = test_handle(8);
impl_test_spawn_model_small_objects(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawn_model_small_objects_managed_runtime() {
let _logs = show_test_logs();
let handle = test_handle_managed(8);
impl_test_spawn_model_small_objects(handle).await;
}
async fn impl_test_spawn_model_large_objects(handle: Arc<Handle>) {
let target: usize = 8;
let (max_dispatched, max_alive) =
impl_spawn_model_non_blocking(handle, target, 10, 160).await;
assert!(
max_dispatched <= target + 4,
"DIAGNOSTIC large_objects: max_dispatched ({}) should be near target ({}); \
max_alive={}",
max_dispatched,
target,
max_alive,
);
println!(
"DIAGNOSTIC large_objects: target={}, max_dispatched={}, max_alive={}",
target, max_dispatched, max_alive
);
assert!(
max_alive <= 160,
"DIAGNOSTIC large_objects: max_alive ({}) exceeded total_children; \
target={}, max_dispatched={}",
max_alive,
target,
max_dispatched,
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawn_model_large_objects() {
let _logs = show_test_logs();
let handle = test_handle(8);
impl_test_spawn_model_large_objects(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawn_model_large_objects_managed_runtime() {
let _logs = show_test_logs();
let handle = test_handle_managed(8);
impl_test_spawn_model_large_objects(handle).await;
}
async fn impl_test_spawn_model_blocking_children(handle: Arc<Handle>) {
let target: usize = 8;
let scheduler = &handle.scheduler;
let counter = DispatchCounter::new();
let notify = Arc::new(tokio::sync::Notify::new());
let id = TransferId {
id: 1,
parent: None,
};
let composite = SingleTicketCompositeMock::new_blocking(
id,
handle.clone(),
160, 100_000, counter.clone(),
notify.clone(),
);
let (spawned_handle, terminated_handle) = composite.observer_handles();
scheduler.enqueue_transfer(Box::new(composite));
let mut max_dispatched: usize = 0;
let mut max_alive: u64 = 0;
let deadline = tokio::time::Instant::now() + Duration::from_millis(500);
while tokio::time::Instant::now() < deadline {
let dispatched = scheduler.dispatched_for_test();
let spawned = spawned_handle.load(Ordering::SeqCst);
let terminated = terminated_handle.load(Ordering::SeqCst);
let alive = spawned.saturating_sub(terminated);
if dispatched > max_dispatched {
max_dispatched = dispatched;
}
if alive > max_alive {
max_alive = alive;
}
tokio::time::sleep(Duration::from_millis(5)).await;
}
println!(
"DIAGNOSTIC blocking: target={}, max_dispatched={}, max_alive={}",
target, max_dispatched, max_alive
);
assert!(
max_dispatched <= target + 4,
"DIAGNOSTIC blocking: max_dispatched ({}) should be near target ({}); \
max_alive={}",
max_dispatched,
target,
max_alive,
);
assert!(
max_alive <= (target as u64) + 8,
"DIAGNOSTIC blocking: max_alive ({}) should be near target ({}); \
max_dispatched={}",
max_alive,
target,
max_dispatched,
);
assert!(
max_dispatched > 0,
"DIAGNOSTIC blocking: at least some children should be dispatched"
);
notify.notify_waiters();
let notify_clone = notify.clone();
let notifier = tokio::spawn(async move {
loop {
notify_clone.notify_waiters();
tokio::time::sleep(Duration::from_millis(5)).await;
}
});
tokio::time::timeout(Duration::from_secs(30), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle after releasing children");
notifier.abort();
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawn_model_blocking_children() {
let _logs = show_test_logs();
let handle = test_handle(8);
impl_test_spawn_model_blocking_children(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawn_model_blocking_children_managed_runtime() {
let _logs = show_test_logs();
let handle = test_handle_managed(8);
impl_test_spawn_model_blocking_children(handle).await;
}
async fn impl_test_spawn_child_polled_before_composite_respawns(handle: Arc<Handle>) {
let target: usize = 1;
let scheduler = &handle.scheduler;
let counter = DispatchCounter::new();
let id = TransferId {
id: 1,
parent: None,
};
let composite = SingleTicketCompositeMock::new(
id,
handle.clone(),
50, 1, 100_000,
counter.clone(),
);
let (spawned_handle, terminated_handle) = composite.observer_handles();
scheduler.enqueue_transfer(Box::new(composite));
let mut max_dispatched: usize = 0;
let mut max_alive: u64 = 0;
let deadline = tokio::time::Instant::now() + Duration::from_millis(500);
while tokio::time::Instant::now() < deadline {
let dispatched = scheduler.dispatched_for_test();
let spawned = spawned_handle.load(Ordering::SeqCst);
let terminated = terminated_handle.load(Ordering::SeqCst);
let alive = spawned.saturating_sub(terminated);
if dispatched > max_dispatched {
max_dispatched = dispatched;
}
if alive > max_alive {
max_alive = alive;
}
tokio::time::sleep(Duration::from_millis(2)).await;
}
tokio::time::timeout(Duration::from_secs(15), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
println!(
"DIAGNOSTIC target=1: target={}, max_dispatched={}, max_alive={}",
target, max_dispatched, max_alive
);
assert!(
max_dispatched <= 2,
"DIAGNOSTIC target=1: max_dispatched ({}) should be <=2; max_alive={}",
max_dispatched,
max_alive,
);
crate::runtime::test_util::shutdown(&handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawn_child_polled_before_composite_respawns() {
let _logs = show_test_logs();
let handle = test_handle(1);
impl_test_spawn_child_polled_before_composite_respawns(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_spawn_child_polled_before_composite_respawns_managed_runtime() {
let _logs = show_test_logs();
let handle = test_handle_managed(1);
impl_test_spawn_child_polled_before_composite_respawns(handle).await;
}
async fn impl_test_composite_child_poll_interleaving(handle: Arc<Handle>) {
let scheduler = &handle.scheduler;
let counter = DispatchCounter::new();
let poll_log = Arc::new(std::sync::Mutex::new(Vec::<u64>::new()));
let composite_id = 1u64;
let id = TransferId {
id: composite_id,
parent: None,
};
let composite = SingleTicketCompositeMock::new(id, handle.clone(), 50, 1, 100_000, counter)
.with_poll_log(poll_log.clone());
scheduler.enqueue_transfer(Box::new(composite));
tokio::time::timeout(Duration::from_secs(30), async {
while !scheduler.is_idle() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("scheduler should become idle");
let log = poll_log.lock().unwrap().clone();
assert!(!log.is_empty(), "poll log should record polls");
let mut longest_composite_run = 0usize;
let mut current_run = 0usize;
for &tid in &log {
if tid == composite_id {
current_run += 1;
longest_composite_run = longest_composite_run.max(current_run);
} else {
current_run = 0;
}
}
let composite_polls = log.iter().filter(|&&t| t == composite_id).count();
let child_polls = log.len() - composite_polls;
println!(
"DIAGNOSTIC poll-interleaving: total_polls={}, composite_polls={}, \
child_polls={}, longest_composite_run={}",
log.len(),
composite_polls,
child_polls,
longest_composite_run,
);
assert!(child_polls > 0, "children must be polled");
assert!(
longest_composite_run <= log.len(),
"run cannot exceed total polls"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_composite_child_poll_interleaving() {
let _logs = show_test_logs();
let handle = test_handle(2);
impl_test_composite_child_poll_interleaving(handle).await;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_composite_child_poll_interleaving_managed_runtime() {
let _logs = show_test_logs();
let handle = test_handle_managed(2);
impl_test_composite_child_poll_interleaving(handle).await;
}
}
#[cfg(all(test, s3_tm_loom))]
mod loom_tests {
use loom::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use loom::sync::{Arc, Mutex, RwLock};
use loom::thread;
use std::collections::HashMap;
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
struct TidShim {
id: u64,
parent: Option<u64>,
}
#[derive(Default)]
struct IdleEpoch {
activity: u64,
deadline: Option<u64>,
publications: usize,
}
struct LoomIdleScheduler {
transfers: RwLock<usize>,
dispatched: AtomicUsize,
idle_candidate: AtomicBool,
idle: Mutex<IdleEpoch>,
}
impl LoomIdleScheduler {
fn new(transfers: usize, dispatched: usize, idle_candidate: bool) -> Self {
Self {
transfers: RwLock::new(transfers),
dispatched: AtomicUsize::new(dispatched),
idle_candidate: AtomicBool::new(idle_candidate),
idle: Mutex::new(IdleEpoch::default()),
}
}
fn enqueue_transfer(&self) {
let mut transfers = self.transfers.write().unwrap();
*transfers += 1;
self.idle_candidate.store(false, Ordering::SeqCst);
let mut idle = self.idle.lock().unwrap();
idle.activity = idle.activity.wrapping_add(1);
idle.deadline = None;
}
fn remove_transfer(&self) {
let mut transfers = self.transfers.write().unwrap();
assert!(*transfers > 0);
*transfers -= 1;
let registry_became_empty = *transfers == 0;
if registry_became_empty {
self.idle_candidate.store(true, Ordering::SeqCst);
}
drop(transfers);
if registry_became_empty {
self.publish_global_idle_if_candidate();
}
}
fn release_dispatch(&self) {
let previous = self.dispatched.fetch_sub(1, Ordering::SeqCst);
assert!(previous > 0);
if previous == 1 {
self.publish_global_idle_if_candidate();
}
}
fn publish_global_idle_if_candidate(&self) {
if !self.idle_candidate.load(Ordering::SeqCst) {
return;
}
let transfers = self.transfers.read().unwrap();
if *transfers == 0
&& self.dispatched.fetch_add(0, Ordering::SeqCst) == 0
&& self.idle_candidate.swap(false, Ordering::SeqCst)
{
let mut idle = self.idle.lock().unwrap();
if idle.deadline.is_none() {
idle.deadline = Some(idle.activity);
}
idle.publications += 1;
}
}
fn active_work_has_no_idle_deadline(&self) -> bool {
let transfers = self.transfers.read().unwrap();
let idle = self.idle.lock().unwrap();
*transfers == 0 || idle.deadline.is_none()
}
fn idle_was_published_once(&self) -> bool {
let transfers = self.transfers.read().unwrap();
let dispatched = self.dispatched.load(Ordering::SeqCst);
let idle = self.idle.lock().unwrap();
*transfers == 0 && dispatched == 0 && idle.deadline.is_some() && idle.publications == 1
}
}
struct LoomScheduler {
transfers: RwLock<HashMap<TidShim, ()>>,
by_group: RwLock<HashMap<u64, ()>>,
groups: RwLock<HashMap<u64, ()>>,
}
impl LoomScheduler {
fn new() -> Self {
Self {
transfers: RwLock::new(HashMap::new()),
by_group: RwLock::new(HashMap::new()),
groups: RwLock::new(HashMap::new()),
}
}
fn register_group(&self, group_id: u64) {
self.by_group.write().unwrap().insert(group_id, ());
self.groups.write().unwrap().insert(group_id, ());
self.transfers.write().unwrap().insert(
TidShim {
id: group_id,
parent: None,
},
(),
);
}
fn enqueue_transfer(&self, tid: TidShim) {
let inserted = {
let mut transfers = self.transfers.write().unwrap();
let parent_exists = match tid.parent {
Some(p) => self.by_group.read().unwrap().contains_key(&p),
None => true,
};
if !parent_exists {
drop(transfers);
return;
}
transfers.insert(tid, ());
true
};
let _ = inserted;
let group_id = tid.parent.unwrap_or(tid.id);
let by_group = self.by_group.read().unwrap();
if !by_group.contains_key(&group_id) {
drop(by_group);
self.transfers.write().unwrap().remove(&tid);
return;
}
self.groups.write().unwrap().insert(group_id, ());
drop(by_group);
}
fn cancel_transfer(&self, id: TidShim) {
let mut transfers = self.transfers.write().unwrap();
let removed = transfers.remove(&id).is_some();
let child_keys: Vec<TidShim> = transfers
.keys()
.filter(|t| t.parent == Some(id.id))
.copied()
.collect();
for k in &child_keys {
transfers.remove(k);
}
if removed && id.parent.is_none() {
self.by_group.write().unwrap().remove(&id.id);
self.groups.write().unwrap().remove(&id.id);
}
}
fn no_orphans(&self) -> bool {
let t = self.transfers.read().unwrap();
let bg = self.by_group.read().unwrap();
t.keys().all(|tid| match tid.parent {
Some(p) => bg.contains_key(&p),
None => true,
})
}
fn no_phantom_groups(&self) -> bool {
let groups = self.groups.read().unwrap();
let by_group = self.by_group.read().unwrap();
groups.keys().all(|gid| by_group.contains_key(gid))
}
}
#[test]
fn enqueue_cannot_leave_a_stale_pool_idle_epoch() {
loom::model(|| {
let scheduler = Arc::new(LoomIdleScheduler::new(1, 0, false));
let enqueueing = Arc::clone(&scheduler);
let enqueue = thread::spawn(move || enqueueing.enqueue_transfer());
let removing = Arc::clone(&scheduler);
let remove = thread::spawn(move || removing.remove_transfer());
enqueue.join().unwrap();
remove.join().unwrap();
assert!(
scheduler.active_work_has_no_idle_deadline(),
"active scheduler work retained a stale pool idle deadline"
);
});
}
#[test]
fn registry_and_dispatch_zero_edges_cannot_lose_idle() {
loom::model(|| {
let scheduler = Arc::new(LoomIdleScheduler::new(1, 1, false));
let removing = Arc::clone(&scheduler);
let remove = thread::spawn(move || removing.remove_transfer());
let completing = Arc::clone(&scheduler);
let complete = thread::spawn(move || completing.release_dispatch());
remove.join().unwrap();
complete.join().unwrap();
assert!(
scheduler.idle_was_published_once(),
"zero-edge race lost or duplicated scheduler-global idle"
);
});
}
#[test]
fn enqueue_cancels_a_pending_idle_candidate() {
loom::model(|| {
let scheduler = Arc::new(LoomIdleScheduler::new(0, 1, true));
let enqueueing = Arc::clone(&scheduler);
let enqueue = thread::spawn(move || enqueueing.enqueue_transfer());
let completing = Arc::clone(&scheduler);
let complete = thread::spawn(move || completing.release_dispatch());
enqueue.join().unwrap();
complete.join().unwrap();
assert!(
scheduler.active_work_has_no_idle_deadline(),
"new scheduler work retained an idle event from the prior interval"
);
});
}
#[test]
fn fixed_dance_no_orphan() {
loom::model(|| {
let sched = Arc::new(LoomScheduler::new());
sched.register_group(1);
let s1 = sched.clone();
let h1 = thread::spawn(move || {
s1.enqueue_transfer(TidShim {
id: 100,
parent: Some(1),
});
});
let s2 = sched.clone();
let h2 = thread::spawn(move || {
s2.cancel_transfer(TidShim {
id: 1,
parent: None,
});
});
h1.join().unwrap();
h2.join().unwrap();
assert!(
sched.no_orphans(),
"fixed dance produced an orphan; lock-ordering bug regressed"
);
});
}
#[test]
fn two_enqueues_one_cancel_no_orphan() {
loom::model(|| {
let sched = Arc::new(LoomScheduler::new());
sched.register_group(1);
let s1 = sched.clone();
let h1 = thread::spawn(move || {
s1.enqueue_transfer(TidShim {
id: 100,
parent: Some(1),
});
});
let s2 = sched.clone();
let h2 = thread::spawn(move || {
s2.enqueue_transfer(TidShim {
id: 200,
parent: Some(1),
});
});
let s3 = sched.clone();
let h3 = thread::spawn(move || {
s3.cancel_transfer(TidShim {
id: 1,
parent: None,
});
});
h1.join().unwrap();
h2.join().unwrap();
h3.join().unwrap();
assert!(
sched.no_orphans(),
"fixed dance produced an orphan with 2 enqueues + 1 cancel"
);
});
}
#[test]
fn child_insert_phantom_group() {
loom::model(|| {
let sched = Arc::new(LoomScheduler::new());
sched.register_group(1);
let s1 = sched.clone();
let h1 = thread::spawn(move || {
s1.enqueue_transfer(TidShim {
id: 100,
parent: Some(1),
});
});
let s2 = sched.clone();
let h2 = thread::spawn(move || {
s2.cancel_transfer(TidShim {
id: 1,
parent: None,
});
});
h1.join().unwrap();
h2.join().unwrap();
assert!(
sched.no_phantom_groups(),
"phantom group entry: groups contains a group_id not in by_group"
);
});
}
}