From 729d4ee94706985b47c774d8a63c49e18c119a57 Mon Sep 17 00:00:00 2001 From: Stjepan Glavina Date: Thu, 26 Dec 2019 21:07:42 +0100 Subject: [PATCH 1/3] Schedule function holds a reference --- src/raw.rs | 52 ++++++++++++++++++++++++++++++++------------------ tests/basic.rs | 16 ++++++++++++++++ 2 files changed, 49 insertions(+), 19 deletions(-) diff --git a/src/raw.rs b/src/raw.rs index 2c47f0c..c250c02 100644 --- a/src/raw.rs +++ b/src/raw.rs @@ -16,7 +16,7 @@ use crate::Task; /// The vtable for a task. pub(crate) struct TaskVTable { /// The raw waker vtable. - pub(crate) raw_waker: RawWakerVTable, + pub(crate) raw_waker_vtable: RawWakerVTable, /// Schedules the task. pub(crate) schedule: unsafe fn(*const ()), @@ -119,7 +119,7 @@ where state: AtomicUsize::new(SCHEDULED | HANDLE | REFERENCE), awaiter: Cell::new(None), vtable: &TaskVTable { - raw_waker: RawWakerVTable::new( + raw_waker_vtable: RawWakerVTable::new( Self::clone_waker, Self::wake, Self::wake_by_ref, @@ -198,6 +198,14 @@ where /// Wakes a waker. unsafe fn wake(ptr: *const ()) { + // This is just an optimization. If the schedule function has captured variables, then + // we'll do less reference counting if we wake the waker by reference and then drop it. + if mem::size_of::() > 0 { + Self::wake_by_ref(ptr); + Self::drop_waker(ptr); + return; + } + let raw = Self::from_ptr(ptr); let mut state = (*raw.header).state.load(Ordering::Acquire); @@ -238,13 +246,9 @@ where Ok(_) => { // If the task is not yet scheduled and isn't currently running, now is the // time to schedule it. - if state & (SCHEDULED | RUNNING) == 0 { + if state & RUNNING == 0 { // Schedule the task. - let task = Task { - raw_task: NonNull::new_unchecked(ptr as *mut ()), - _marker: PhantomData, - }; - (*raw.schedule)(task); + Self::schedule(ptr); } else { // Drop the waker. Self::drop_waker(ptr); @@ -284,8 +288,8 @@ where Err(s) => state = s, } } else { - // If the task is not scheduled nor running, we'll need to schedule after waking. - let new = if state & (SCHEDULED | RUNNING) == 0 { + // If the task is not running, we can schedule right away. + let new = if state & RUNNING == 0 { (state | SCHEDULED) + REFERENCE } else { state | SCHEDULED @@ -299,14 +303,16 @@ where Ordering::Acquire, ) { Ok(_) => { - // If the task is not scheduled nor running, now is the time to schedule. - if state & (SCHEDULED | RUNNING) == 0 { + // If the task is not running, now is the time to schedule. + if state & RUNNING == 0 { // If the reference count overflowed, abort. if state > isize::max_value() as usize { std::process::abort(); } - // Schedule the task. + // Schedule the task. There is no need to call `Self::schedule(ptr)` + // because the schedule function cannot be destroyed while the waker is + // still alive. let task = Task { raw_task: NonNull::new_unchecked(ptr as *mut ()), _marker: PhantomData, @@ -325,7 +331,7 @@ where /// Clones a waker. unsafe fn clone_waker(ptr: *const ()) -> RawWaker { let raw = Self::from_ptr(ptr); - let raw_waker = &(*raw.header).vtable.raw_waker; + let raw_waker_vtable = &(*raw.header).vtable.raw_waker_vtable; // Increment the reference count. With any kind of reference-counted data structure, // relaxed ordering is appropriate when incrementing the counter. @@ -336,7 +342,7 @@ where std::process::abort(); } - RawWaker::new(ptr, raw_waker) + RawWaker::new(ptr, raw_waker_vtable) } /// Drops a waker. @@ -360,7 +366,7 @@ where (*raw.header) .state .store(SCHEDULED | CLOSED | REFERENCE, Ordering::Release); - ((*raw.header).vtable.schedule)(ptr); + Self::schedule(ptr); } else { // Otherwise, destroy the task right away. Self::destroy(ptr); @@ -393,10 +399,18 @@ where unsafe fn schedule(ptr: *const ()) { let raw = Self::from_ptr(ptr); - (*raw.schedule)(Task { + // If the schedule function has captured variables, create a temporary waker that prevents + // the task from getting deallocated while the function is being invoked. + let _waker; + if mem::size_of::() > 0 { + _waker = Waker::from_raw(Self::clone_waker(ptr)); + } + + let task = Task { raw_task: NonNull::new_unchecked(ptr as *mut ()), _marker: PhantomData, - }); + }; + (*raw.schedule)(task); } /// Drops the future inside a task. @@ -448,7 +462,7 @@ where // Create a context from the raw task pointer and the vtable inside the its header. let waker = ManuallyDrop::new(Waker::from_raw(RawWaker::new( ptr, - &(*raw.header).vtable.raw_waker, + &(*raw.header).vtable.raw_waker_vtable, ))); let cx = &mut Context::from_waker(&waker); diff --git a/tests/basic.rs b/tests/basic.rs index 8c8734c..a45da73 100644 --- a/tests/basic.rs +++ b/tests/basic.rs @@ -310,3 +310,19 @@ fn schedule_counter() { assert_eq!(handle.tag().load(Ordering::SeqCst), 3); r.recv().unwrap(); } + +#[test] +fn drop_inside_schedule() { + let s = "1234".to_owned(); + + let (task, _) = async_task::spawn( + async {}, + move |task| { + println!("{:?}", s); + drop(task); + println!("{:?}", s); + }, + (), + ); + task.schedule(); +} From ef39c968689a0045dcfcf7abfa9ece36d61e3c3b Mon Sep 17 00:00:00 2001 From: Stjepan Glavina Date: Thu, 26 Dec 2019 21:07:52 +0100 Subject: [PATCH 2/3] Rename DROP_D to DROP_T --- tests/basic.rs | 38 +++++++++++------------ tests/join.rs | 60 ++++++++++++++++++------------------- tests/panic.rs | 40 ++++++++++++------------- tests/ready.rs | 28 ++++++++--------- tests/waker_panic.rs | 42 +++++++++++++------------- tests/waker_pending.rs | 68 +++++++++++++++++++++--------------------- tests/waker_ready.rs | 46 ++++++++++++++-------------- 7 files changed, 161 insertions(+), 161 deletions(-) diff --git a/tests/basic.rs b/tests/basic.rs index a45da73..c11fec9 100644 --- a/tests/basic.rs +++ b/tests/basic.rs @@ -109,132 +109,132 @@ macro_rules! task { fn cancel_and_drop_handle() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); assert_eq!(POLL.load(), 0); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); task.cancel(); assert_eq!(POLL.load(), 0); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); drop(handle); assert_eq!(POLL.load(), 0); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); drop(task); assert_eq!(POLL.load(), 0); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); } #[test] fn run_and_drop_handle() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); drop(handle); assert_eq!(POLL.load(), 0); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); task.run(); assert_eq!(POLL.load(), 1); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); } #[test] fn drop_handle_and_run() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); drop(handle); assert_eq!(POLL.load(), 0); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); task.run(); assert_eq!(POLL.load(), 1); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); } #[test] fn cancel_and_run() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); handle.cancel(); assert_eq!(POLL.load(), 0); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); drop(handle); assert_eq!(POLL.load(), 0); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); task.run(); assert_eq!(POLL.load(), 0); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); } #[test] fn run_and_cancel() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); task.run(); assert_eq!(POLL.load(), 1); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); handle.cancel(); assert_eq!(POLL.load(), 1); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); drop(handle); assert_eq!(POLL.load(), 1); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); } #[test] diff --git a/tests/join.rs b/tests/join.rs index 4bfa7fd..e572062 100644 --- a/tests/join.rs +++ b/tests/join.rs @@ -126,7 +126,7 @@ fn ms(ms: u64) -> Duration { fn cancel_and_join() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); assert_eq!(DROP_O.load(), 0); @@ -139,7 +139,7 @@ fn cancel_and_join() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(DROP_O.load(), 0); } @@ -147,7 +147,7 @@ fn cancel_and_join() { fn run_and_join() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); assert_eq!(DROP_O.load(), 0); @@ -159,7 +159,7 @@ fn run_and_join() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(DROP_O.load(), 1); } @@ -167,7 +167,7 @@ fn run_and_join() { fn drop_handle_and_run() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); assert_eq!(DROP_O.load(), 0); @@ -179,7 +179,7 @@ fn drop_handle_and_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(DROP_O.load(), 1); } @@ -187,7 +187,7 @@ fn drop_handle_and_run() { fn join_twice() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, mut handle, f, s, DROP_D); + task!(task, mut handle, f, s, DROP_T); assert_eq!(DROP_O.load(), 0); @@ -199,7 +199,7 @@ fn join_twice() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 1); assert!(block_on(&mut handle).is_none()); @@ -207,19 +207,19 @@ fn join_twice() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 1); drop(handle); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); } #[test] fn join_and_cancel() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -234,7 +234,7 @@ fn join_and_cancel() { assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_O.load(), 0); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }); assert!(block_on(handle).is_none()); @@ -245,7 +245,7 @@ fn join_and_cancel() { assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_O.load(), 0); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }) .unwrap(); } @@ -254,7 +254,7 @@ fn join_and_cancel() { fn join_and_run() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -267,7 +267,7 @@ fn join_and_run() { thread::sleep(ms(100)); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }); assert!(block_on(handle).is_some()); @@ -278,7 +278,7 @@ fn join_and_run() { thread::sleep(ms(100)); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }) .unwrap(); } @@ -287,7 +287,7 @@ fn join_and_run() { fn try_join_and_run_and_join() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, mut handle, f, s, DROP_D); + task!(task, mut handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -300,7 +300,7 @@ fn try_join_and_run_and_join() { thread::sleep(ms(100)); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }); block_on(future::select(&mut handle, future::ready(()))); @@ -308,7 +308,7 @@ fn try_join_and_run_and_join() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 0); assert!(block_on(handle).is_some()); @@ -319,7 +319,7 @@ fn try_join_and_run_and_join() { thread::sleep(ms(100)); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }) .unwrap(); } @@ -328,7 +328,7 @@ fn try_join_and_run_and_join() { fn try_join_and_cancel_and_run() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, mut handle, f, s, DROP_D); + task!(task, mut handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -339,7 +339,7 @@ fn try_join_and_cancel_and_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }); block_on(future::select(&mut handle, future::ready(()))); @@ -347,7 +347,7 @@ fn try_join_and_cancel_and_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 0); handle.cancel(); @@ -355,7 +355,7 @@ fn try_join_and_cancel_and_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 0); drop(handle); @@ -363,7 +363,7 @@ fn try_join_and_cancel_and_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 0); }) .unwrap(); @@ -373,7 +373,7 @@ fn try_join_and_cancel_and_run() { fn try_join_and_run_and_cancel() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, mut handle, f, s, DROP_D); + task!(task, mut handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -384,7 +384,7 @@ fn try_join_and_run_and_cancel() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); }); block_on(future::select(&mut handle, future::ready(()))); @@ -392,7 +392,7 @@ fn try_join_and_run_and_cancel() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 0); thread::sleep(ms(400)); @@ -402,7 +402,7 @@ fn try_join_and_run_and_cancel() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 0); drop(handle); @@ -410,7 +410,7 @@ fn try_join_and_run_and_cancel() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(DROP_O.load(), 1); }) .unwrap(); diff --git a/tests/panic.rs b/tests/panic.rs index ef917dc..7b7d1b5 100644 --- a/tests/panic.rs +++ b/tests/panic.rs @@ -116,7 +116,7 @@ fn ms(ms: u64) -> Duration { fn cancel_during_run() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -125,7 +125,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }); thread::sleep(ms(100)); @@ -135,14 +135,14 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); drop(handle); assert_eq!(POLL.load(), 1); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); }) .unwrap(); } @@ -151,56 +151,56 @@ fn cancel_during_run() { fn run_and_join() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); assert!(catch_unwind(|| task.run()).is_err()); assert_eq!(POLL.load(), 1); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert!(block_on(handle).is_none()); assert_eq!(POLL.load(), 1); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); } #[test] fn try_join_and_run_and_join() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - task!(task, mut handle, f, s, DROP_D); + task!(task, mut handle, f, s, DROP_T); block_on(future::select(&mut handle, future::ready(()))); assert_eq!(POLL.load(), 0); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert!(catch_unwind(|| task.run()).is_err()); assert_eq!(POLL.load(), 1); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert!(block_on(handle).is_none()); assert_eq!(POLL.load(), 1); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); } #[test] fn join_during_run() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -211,7 +211,7 @@ fn join_during_run() { thread::sleep(ms(100)); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }); thread::sleep(ms(100)); @@ -223,7 +223,7 @@ fn join_during_run() { thread::sleep(ms(100)); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }) .unwrap(); } @@ -232,7 +232,7 @@ fn join_during_run() { fn try_join_during_run() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - task!(task, mut handle, f, s, DROP_D); + task!(task, mut handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -241,7 +241,7 @@ fn try_join_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }); thread::sleep(ms(100)); @@ -251,7 +251,7 @@ fn try_join_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); drop(handle); }) .unwrap(); @@ -261,7 +261,7 @@ fn try_join_during_run() { fn drop_handle_during_run() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -270,7 +270,7 @@ fn drop_handle_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }); thread::sleep(ms(100)); @@ -280,7 +280,7 @@ fn drop_handle_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); }) .unwrap(); } diff --git a/tests/ready.rs b/tests/ready.rs index abdeb90..05b266b 100644 --- a/tests/ready.rs +++ b/tests/ready.rs @@ -125,7 +125,7 @@ fn ms(ms: u64) -> Duration { fn cancel_during_run() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -134,7 +134,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 1); }); @@ -145,7 +145,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 0); thread::sleep(ms(200)); @@ -154,7 +154,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 1); drop(handle); @@ -162,7 +162,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(DROP_O.load(), 1); }) .unwrap(); @@ -172,7 +172,7 @@ fn cancel_during_run() { fn join_during_run() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -183,7 +183,7 @@ fn join_during_run() { thread::sleep(ms(100)); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }); thread::sleep(ms(100)); @@ -196,7 +196,7 @@ fn join_during_run() { thread::sleep(ms(100)); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); }) .unwrap(); } @@ -205,7 +205,7 @@ fn join_during_run() { fn try_join_during_run() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, mut handle, f, s, DROP_D); + task!(task, mut handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -214,7 +214,7 @@ fn try_join_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(DROP_O.load(), 1); }); @@ -225,7 +225,7 @@ fn try_join_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 0); drop(handle); }) @@ -236,7 +236,7 @@ fn try_join_during_run() { fn drop_handle_during_run() { future!(f, POLL, DROP_F, DROP_O); schedule!(s, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); crossbeam::scope(|scope| { scope.spawn(|_| { @@ -245,7 +245,7 @@ fn drop_handle_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(DROP_O.load(), 1); }); @@ -256,7 +256,7 @@ fn drop_handle_during_run() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(DROP_O.load(), 0); }) .unwrap(); diff --git a/tests/waker_panic.rs b/tests/waker_panic.rs index 3a8dfe8..bacdef6 100644 --- a/tests/waker_panic.rs +++ b/tests/waker_panic.rs @@ -137,7 +137,7 @@ fn ms(ms: u64) -> Duration { fn wake_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); task.run(); let w = waker(); @@ -152,7 +152,7 @@ fn wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }); @@ -164,7 +164,7 @@ fn wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); thread::sleep(ms(200)); @@ -173,7 +173,7 @@ fn wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }) .unwrap(); @@ -183,7 +183,7 @@ fn wake_during_run() { fn cancel_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); task.run(); let w = waker(); @@ -198,7 +198,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }); @@ -209,7 +209,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); drop(handle); @@ -217,7 +217,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); thread::sleep(ms(200)); @@ -226,7 +226,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }) .unwrap(); @@ -236,7 +236,7 @@ fn cancel_during_run() { fn wake_and_cancel_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); task.run(); let w = waker(); @@ -251,7 +251,7 @@ fn wake_and_cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }); @@ -262,7 +262,7 @@ fn wake_and_cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); handle.cancel(); @@ -270,7 +270,7 @@ fn wake_and_cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); drop(handle); @@ -278,7 +278,7 @@ fn wake_and_cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); thread::sleep(ms(200)); @@ -287,7 +287,7 @@ fn wake_and_cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }) .unwrap(); @@ -297,7 +297,7 @@ fn wake_and_cancel_during_run() { fn cancel_and_wake_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); task.run(); let w = waker(); @@ -312,7 +312,7 @@ fn cancel_and_wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }); @@ -323,7 +323,7 @@ fn cancel_and_wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); drop(handle); @@ -331,7 +331,7 @@ fn cancel_and_wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); w.wake(); @@ -339,7 +339,7 @@ fn cancel_and_wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); thread::sleep(ms(200)); @@ -348,7 +348,7 @@ fn cancel_and_wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }) .unwrap(); diff --git a/tests/waker_pending.rs b/tests/waker_pending.rs index 11c6bfa..d2c939b 100644 --- a/tests/waker_pending.rs +++ b/tests/waker_pending.rs @@ -127,7 +127,7 @@ fn ms(ms: u64) -> Duration { fn wake_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, _handle, f, s, DROP_D); + task!(task, _handle, f, s, DROP_T); task.run(); let w = waker(); @@ -141,7 +141,7 @@ fn wake_during_run() { assert_eq!(SCHEDULE.load(), 2); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 1); }); @@ -152,7 +152,7 @@ fn wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); thread::sleep(ms(200)); @@ -161,7 +161,7 @@ fn wake_during_run() { assert_eq!(SCHEDULE.load(), 2); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 1); }) .unwrap(); @@ -174,7 +174,7 @@ fn wake_during_run() { fn cancel_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); task.run(); let w = waker(); @@ -189,7 +189,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }); @@ -200,7 +200,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); drop(handle); @@ -208,7 +208,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); thread::sleep(ms(200)); @@ -217,7 +217,7 @@ fn cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }) .unwrap(); @@ -227,7 +227,7 @@ fn cancel_during_run() { fn wake_and_cancel_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); task.run(); let w = waker(); @@ -242,7 +242,7 @@ fn wake_and_cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }); @@ -253,7 +253,7 @@ fn wake_and_cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); handle.cancel(); @@ -261,7 +261,7 @@ fn wake_and_cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); drop(handle); @@ -269,7 +269,7 @@ fn wake_and_cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); thread::sleep(ms(200)); @@ -278,7 +278,7 @@ fn wake_and_cancel_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }) .unwrap(); @@ -288,7 +288,7 @@ fn wake_and_cancel_during_run() { fn cancel_and_wake_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); task.run(); let w = waker(); @@ -303,7 +303,7 @@ fn cancel_and_wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }); @@ -314,7 +314,7 @@ fn cancel_and_wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); drop(handle); @@ -322,7 +322,7 @@ fn cancel_and_wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); w.wake(); @@ -330,7 +330,7 @@ fn cancel_and_wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); thread::sleep(ms(200)); @@ -339,7 +339,7 @@ fn cancel_and_wake_during_run() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); }) .unwrap(); @@ -349,7 +349,7 @@ fn cancel_and_wake_during_run() { fn drop_last_waker() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); task.run(); let w = waker(); @@ -359,7 +359,7 @@ fn drop_last_waker() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); drop(w); @@ -367,7 +367,7 @@ fn drop_last_waker() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 1); chan.recv().unwrap().run(); @@ -375,7 +375,7 @@ fn drop_last_waker() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); } @@ -383,7 +383,7 @@ fn drop_last_waker() { fn cancel_last_handle() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); task.run(); drop(waker()); @@ -391,7 +391,7 @@ fn cancel_last_handle() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); handle.cancel(); @@ -399,7 +399,7 @@ fn cancel_last_handle() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 1); chan.recv().unwrap().run(); @@ -407,7 +407,7 @@ fn cancel_last_handle() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); drop(handle); @@ -415,7 +415,7 @@ fn cancel_last_handle() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); } @@ -423,7 +423,7 @@ fn cancel_last_handle() { fn drop_last_handle() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, handle, f, s, DROP_D); + task!(task, handle, f, s, DROP_T); task.run(); drop(waker()); @@ -431,7 +431,7 @@ fn drop_last_handle() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); drop(handle); @@ -439,7 +439,7 @@ fn drop_last_handle() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 1); chan.recv().unwrap().run(); @@ -447,6 +447,6 @@ fn drop_last_handle() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); } diff --git a/tests/waker_ready.rs b/tests/waker_ready.rs index 800d6ae..a2223c6 100644 --- a/tests/waker_ready.rs +++ b/tests/waker_ready.rs @@ -136,7 +136,7 @@ fn ms(ms: u64) -> Duration { fn wake() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(mut task, _, f, s, DROP_D); + task!(mut task, _, f, s, DROP_T); assert!(chan.is_empty()); @@ -145,7 +145,7 @@ fn wake() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); waker().wake(); @@ -154,7 +154,7 @@ fn wake() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); task.run(); @@ -162,7 +162,7 @@ fn wake() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); waker().wake(); @@ -170,7 +170,7 @@ fn wake() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); } @@ -178,7 +178,7 @@ fn wake() { fn wake_by_ref() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(mut task, _, f, s, DROP_D); + task!(mut task, _, f, s, DROP_T); assert!(chan.is_empty()); @@ -187,7 +187,7 @@ fn wake_by_ref() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); waker().wake_by_ref(); @@ -196,7 +196,7 @@ fn wake_by_ref() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); task.run(); @@ -204,7 +204,7 @@ fn wake_by_ref() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); waker().wake_by_ref(); @@ -212,7 +212,7 @@ fn wake_by_ref() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); } @@ -220,14 +220,14 @@ fn wake_by_ref() { fn clone() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(mut task, _, f, s, DROP_D); + task!(mut task, _, f, s, DROP_T); task.run(); assert_eq!(POLL.load(), 1); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); let w2 = waker().clone(); @@ -241,7 +241,7 @@ fn clone() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); w3.wake(); @@ -249,27 +249,27 @@ fn clone() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); drop(w2); drop(waker()); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); } #[test] fn wake_cancelled() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, _, f, s, DROP_D); + task!(task, _, f, s, DROP_T); task.run(); assert_eq!(POLL.load(), 1); assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); let w = waker(); @@ -280,7 +280,7 @@ fn wake_cancelled() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); w.wake(); @@ -288,7 +288,7 @@ fn wake_cancelled() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); } @@ -296,7 +296,7 @@ fn wake_cancelled() { fn wake_completed() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - task!(task, _, f, s, DROP_D); + task!(task, _, f, s, DROP_T); task.run(); let w = waker(); @@ -304,7 +304,7 @@ fn wake_completed() { assert_eq!(SCHEDULE.load(), 0); assert_eq!(DROP_F.load(), 0); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); w.wake(); @@ -313,7 +313,7 @@ fn wake_completed() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 0); - assert_eq!(DROP_D.load(), 0); + assert_eq!(DROP_T.load(), 0); assert_eq!(chan.len(), 0); waker().wake(); @@ -321,6 +321,6 @@ fn wake_completed() { assert_eq!(SCHEDULE.load(), 1); assert_eq!(DROP_F.load(), 1); assert_eq!(DROP_S.load(), 1); - assert_eq!(DROP_D.load(), 1); + assert_eq!(DROP_T.load(), 1); assert_eq!(chan.len(), 0); } From 0b8b9ae77ea7f4dc8d65b8be4b8f3c3762941909 Mon Sep 17 00:00:00 2001 From: Stjepan Glavina Date: Fri, 27 Dec 2019 11:09:48 +0100 Subject: [PATCH 3/3] Don't rely on valgrind to catch errors --- tests/basic.rs | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/tests/basic.rs b/tests/basic.rs index c11fec9..8426d2a 100644 --- a/tests/basic.rs +++ b/tests/basic.rs @@ -313,14 +313,20 @@ fn schedule_counter() { #[test] fn drop_inside_schedule() { - let s = "1234".to_owned(); + struct DropGuard(AtomicUsize); + impl Drop for DropGuard { + fn drop(&mut self) { + self.0.fetch_add(1, Ordering::SeqCst); + } + } + let guard = DropGuard(AtomicUsize::new(0)); let (task, _) = async_task::spawn( async {}, move |task| { - println!("{:?}", s); + assert_eq!(guard.0.load(Ordering::SeqCst), 0); drop(task); - println!("{:?}", s); + assert_eq!(guard.0.load(Ordering::SeqCst), 0); }, (), );