use rusty_rtos_core::config::Config;
use rusty_rtos_core::error::{Error, Result};
use rusty_rtos_core::handle::{EventGroupHandle, TaskHandle};
use rusty_rtos_core::hooks::TickHook;
use rusty_rtos_core::isr::Woken;
use rusty_rtos_core::list::ListId;
use rusty_rtos_core::port::Port;
use rusty_rtos_core::trace::{Event, Trace};
use crate::kernel::{Kernel, OwedTrace};
use crate::lists_for;
use crate::queue::Wait::{self, Ready};
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct EventGroup {
pub(crate) bits: u32,
}
const CLEAR_EVENTS_ON_EXIT: u64 = 0x0100_0000;
const UNBLOCKED_DUE_TO_BIT_SET: u64 = 0x0200_0000;
const WAIT_FOR_ALL_BITS: u64 = 0x0400_0000;
pub(crate) const EVENT_BITS_CONTROL_BYTES: u64 = 0xff00_0000;
pub const PENDED_SET_BITS: u16 = u16::MAX;
pub const PENDED_CLEAR_BITS: u16 = u16::MAX - 1;
impl<
C: Config,
P: Port,
T: Trace,
H,
const TASKS: usize,
const ITEMS: usize,
const LISTS: usize,
const QUEUES: usize,
const SLOTS: usize,
const BUFFERS: usize,
const BYTES: usize,
const TIMERS: usize,
const GROUPS: usize,
const TIMER_CMDS: usize,
> Kernel<C, P, T, H, TASKS, ITEMS, LISTS, QUEUES, SLOTS, BUFFERS, BYTES, TIMERS, GROUPS, TIMER_CMDS>
where
H: TickHook<Self>,
{
pub(crate) fn event_group_list(group: EventGroupHandle) -> ListId {
let base = u8::try_from(lists_for(C::MAX_PRIORITIES, QUEUES, 0)).unwrap_or(u8::MAX);
base.saturating_add(u8::try_from(group.index()).unwrap_or(u8::MAX))
}
const fn wait_condition_met(current: u32, wait_for: u32, all: bool) -> bool {
if all {
current & wait_for == wait_for
} else {
current & wait_for != 0
}
}
pub fn event_group_create(&mut self) -> Result<EventGroupHandle> {
self.account_for_allocation();
let group = self
.groups
.try_insert(EventGroup::default())
.map_err(|_| Error::Full)?;
let tick = self.tick;
self.note_exits();
self.trace.event(tick, Event::EventGroupCreate { group });
Ok(group)
}
pub fn event_group_delete(&mut self, group: EventGroupHandle) -> Result<()> {
self.groups.resolve(group)?;
self.suspend_all();
let list = Self::event_group_list(group);
while let Ok(Some(item)) = self.lists.head(list) {
self.remove_from_unordered_event_list(item, UNBLOCKED_DUE_TO_BIT_SET)?;
}
let _ = self.groups.discard(group);
let _ = self.resume_all();
self.account_for_allocation();
Ok(())
}
pub fn event_group_bits(&mut self, group: EventGroupHandle) -> Result<u32> {
self.event_group_clear_bits(group, 0)
}
pub fn event_group_bits_from_isr(&self, group: EventGroupHandle) -> Result<u32> {
Ok(self.groups.resolve(group)?.bits)
}
pub fn event_group_clear_bits(&mut self, group: EventGroupHandle, bits: u32) -> Result<u32> {
self.enter_critical();
let result = self.groups.resolve_mut(group).map(|g| {
let before = g.bits;
g.bits &= !bits;
before
});
self.exit_critical();
result
}
pub fn event_group_set_bits(&mut self, group: EventGroupHandle, bits: u32) -> Result<u32> {
self.groups.resolve(group)?;
let list = Self::event_group_list(group);
self.suspend_all();
let tick = self.tick;
self.note_exits();
self.trace
.event(tick, Event::EventGroupSetBits { group, bits });
let mut after: u32 = 0;
if let Ok(g) = self.groups.resolve_mut(group) {
g.bits |= bits;
after = g.bits;
}
let mut to_clear: u32 = 0;
let mut item = self.lists.head(list)?;
while let Some(this) = item {
let (next, value) = self.lists.next_and_value(this)?;
let control = value & EVENT_BITS_CONTROL_BYTES;
let waited_for = (value & !EVENT_BITS_CONTROL_BYTES) as u32;
let current = after;
if Self::wait_condition_met(current, waited_for, control & WAIT_FOR_ALL_BITS != 0) {
if control & CLEAR_EVENTS_ON_EXIT != 0 {
to_clear |= waited_for;
}
self.remove_from_unordered_event_list(
this,
u64::from(current) | UNBLOCKED_DUE_TO_BIT_SET,
)?;
}
item = next;
}
let result = if to_clear == 0 {
after
} else {
match self.groups.resolve_mut(group) {
Ok(g) => {
g.bits &= !to_clear;
g.bits
}
Err(_) => 0,
}
};
let _ = self.resume_all_inline();
Ok(result)
}
pub fn event_group_set_bits_from_isr(
&mut self,
group: EventGroupHandle,
bits: u32,
) -> Result<(bool, Woken)> {
self.pend_group_call(PENDED_SET_BITS, group, bits)
}
pub fn event_group_clear_bits_from_isr(
&mut self,
group: EventGroupHandle,
bits: u32,
) -> Result<(bool, Woken)> {
self.pend_group_call(PENDED_CLEAR_BITS, group, bits)
}
fn pend_group_call(
&mut self,
function: u16,
group: EventGroupHandle,
bits: u32,
) -> Result<(bool, Woken)> {
self.timer_pend_function_call_from_isr(function, u64::from(group.index()), u64::from(bits))
}
pub fn event_group_pended_call(
&mut self,
function: u16,
param1: u64,
param2: u64,
) -> Result<()> {
let Some(group) = self.groups.handle_at(param1 as u16) else {
return Err(Error::Gone);
};
let bits = param2 as u32;
match function {
PENDED_SET_BITS => {
self.event_group_set_bits(group, bits)?;
}
PENDED_CLEAR_BITS => {
self.event_group_clear_bits(group, bits)?;
}
_ => {}
}
Ok(())
}
pub fn event_group_wait_bits(
&mut self,
group: EventGroupHandle,
wait_for: u32,
clear_on_exit: bool,
wait_for_all: bool,
ticks: u64,
) -> Result<Wait<u32>> {
let caller = self.current();
if self.take_event_resume(caller) {
let value = self.reset_event_item_value(caller)?;
let bits = self.finish_wait(group, value, wait_for, clear_on_exit, wait_for_all)?;
self.trace_wait_bits_end(
caller,
group,
wait_for,
value & UNBLOCKED_DUE_TO_BIT_SET == 0,
);
return Ok(Ready(bits));
}
self.groups.resolve(group)?;
self.suspend_all();
let current = self.groups.resolve(group)?.bits;
let mut blocked = false;
let mut timed_out = false;
let mut result = current;
if Self::wait_condition_met(current, wait_for, wait_for_all) {
if clear_on_exit {
if let Ok(g) = self.groups.resolve_mut(group) {
g.bits &= !wait_for;
}
}
} else if ticks == 0 {
timed_out = true;
} else {
let mut control = 0;
if clear_on_exit {
control |= CLEAR_EVENTS_ON_EXIT;
}
if wait_for_all {
control |= WAIT_FOR_ALL_BITS;
}
self.place_on_unordered_event_list(
Self::event_group_list(group),
u64::from(wait_for) | control,
ticks,
)?;
result = 0;
let tick = self.tick;
self.note_exits();
self.trace.event(
tick,
Event::EventGroupWaitBitsBlock {
group,
bits: wait_for,
},
);
blocked = true;
}
let already_yielded = self.resume_all_inline();
if blocked {
if !already_yielded {
self.yield_or_owe(caller);
}
self.set_event_resume(caller);
return Ok(Wait::Blocked);
}
self.trace_wait_bits_end(caller, group, wait_for, timed_out);
Ok(Ready(result))
}
pub fn event_group_sync(
&mut self,
group: EventGroupHandle,
set: u32,
wait_for: u32,
ticks: u64,
) -> Result<Wait<u32>> {
let caller = self.current();
if self.take_event_resume(caller) {
let value = self.reset_event_item_value(caller)?;
return Ok(Ready(self.finish_wait(group, value, wait_for, true, true)?));
}
self.groups.resolve(group)?;
self.suspend_all();
let original = self.groups.resolve(group)?.bits;
self.event_group_set_bits(group, set)?;
let mut blocked = false;
let result;
if (original | set) & wait_for == wait_for {
result = original | set;
if let Ok(g) = self.groups.resolve_mut(group) {
g.bits &= !wait_for;
}
} else if ticks == 0 {
result = self.groups.resolve(group)?.bits;
} else {
self.place_on_unordered_event_list(
Self::event_group_list(group),
u64::from(wait_for) | CLEAR_EVENTS_ON_EXIT | WAIT_FOR_ALL_BITS,
ticks,
)?;
result = 0;
blocked = true;
}
let already_yielded = self.resume_all();
if blocked {
if !already_yielded {
self.yield_or_owe(caller);
}
self.set_event_resume(caller);
return Ok(Wait::Blocked);
}
Ok(Ready(result))
}
#[inline(always)]
fn finish_wait(
&mut self,
group: EventGroupHandle,
value: u64,
wait_for: u32,
clear_on_exit: bool,
wait_for_all: bool,
) -> Result<u32> {
if value & UNBLOCKED_DUE_TO_BIT_SET != 0 {
return Ok((value & !EVENT_BITS_CONTROL_BYTES) as u32);
}
self.enter_critical();
let bits = self.groups.resolve(group).map(|g| g.bits);
if let Ok(bits) = bits {
if Self::wait_condition_met(bits, wait_for, wait_for_all) && clear_on_exit {
if let Ok(g) = self.groups.resolve_mut(group) {
g.bits &= !wait_for;
}
}
}
self.exit_critical();
Ok((u64::from(bits?) & !EVENT_BITS_CONTROL_BYTES) as u32)
}
fn trace_wait_bits_end(
&mut self,
caller: TaskHandle,
group: EventGroupHandle,
bits: u32,
timed_out: bool,
) {
self.trace_failure_or_owe(
caller,
OwedTrace::EventGroupWaitBitsEnd {
group,
bits,
timed_out,
},
);
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
mod tests {
use rusty_rtos_core::config::Config;
use rusty_rtos_core::hooks::NoTickHook;
use crate::events::{PENDED_CLEAR_BITS, PENDED_SET_BITS};
use crate::queue::Wait;
use crate::system::tests::{NoTrace, TestConfig, TestPort};
type K = crate::Kernel<
TestConfig,
TestPort,
NoTrace,
NoTickHook,
4,
{ crate::list_slots_for(4, 1, crate::lists_for(TestConfig::MAX_PRIORITIES, 1, 2)) },
{ crate::lists_for(TestConfig::MAX_PRIORITIES, 1, 2) },
1,
2,
0,
0,
1,
2,
{ <TestConfig as ::rusty_rtos_core::config::Config>::TIMER_QUEUE_LENGTH },
>;
fn kernel() -> K {
K::new(TestPort::default(), NoTrace).expect("the declared geometry adds up")
}
fn started() -> K {
let mut k = kernel();
let h = k.start_scheduler().expect("start");
k.suspend(Some(h.timer)).expect("park the daemon");
k
}
#[test]
fn clear_bits_answers_the_value_from_before_the_clear() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.event_group_set_bits(g, 0b1111).expect("set");
assert_eq!(
k.event_group_clear_bits(g, 0b0101),
Ok(0b1111),
"the value BEFORE: it still has the bits being cleared in it"
);
assert_eq!(
k.event_group_bits(g),
Ok(0b1010),
"and this is what is actually left"
);
}
#[test]
fn set_bits_answers_a_value_a_woken_waiter_has_already_cleared() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.create_task("w", 1).expect("a waiter");
let h = k.start_scheduler().expect("start");
k.suspend(Some(h.timer)).expect("park the daemon");
let mut blocked = false;
for _ in 0..50_u32 {
let running = k.name_of(k.current()).expect("a name");
if running.as_str() == "w" {
assert_eq!(
k.event_group_wait_bits(g, 0b0001, true, false, 20),
Ok(Wait::Blocked)
);
blocked = true;
break;
}
k.switch_context();
}
assert!(blocked, "never got the waiter onto the CPU");
assert_eq!(
k.event_group_set_bits(g, 0b0001),
Ok(0b0000),
"the bit was set, the waiter matched, its clear-on-exit ran, \
and the snapshot came after all of that"
);
assert_eq!(k.event_group_bits(g), Ok(0b0000));
}
#[test]
fn set_bits_keeps_the_bit_when_the_waiter_does_not_clear_on_exit() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.create_task("w", 1).expect("a waiter");
let h = k.start_scheduler().expect("start");
k.suspend(Some(h.timer)).expect("park the daemon");
let mut blocked = false;
for _ in 0..50_u32 {
let running = k.name_of(k.current()).expect("a name");
if running.as_str() == "w" {
assert_eq!(
k.event_group_wait_bits(g, 0b0001, false, false, 20),
Ok(Wait::Blocked)
);
blocked = true;
break;
}
k.switch_context();
}
assert!(blocked, "never got the waiter onto the CPU");
assert_eq!(
k.event_group_set_bits(g, 0b0001),
Ok(0b0001),
"no clear-on-exit, so the bit is still there when the set returns"
);
}
#[test]
fn wait_for_all_needs_every_bit_and_wait_for_any_needs_one() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.event_group_set_bits(g, 0b0001).expect("set one of two");
assert_eq!(
k.event_group_wait_bits(g, 0b0011, false, false, 0),
Ok(Wait::Ready(0b0001)),
"one of the two is enough for ANY"
);
assert_eq!(
k.event_group_wait_bits(g, 0b0011, false, true, 0),
Ok(Wait::Ready(0b0001)),
"ALL is not met, and the answer is still the CURRENT bits -- \
the return value does not say whether the wait succeeded"
);
k.event_group_set_bits(g, 0b0010).expect("set the other");
assert_eq!(
k.event_group_wait_bits(g, 0b0011, false, true, 0),
Ok(Wait::Ready(0b0011)),
"now ALL is met"
);
}
#[test]
fn clear_on_exit_takes_only_the_bits_that_were_waited_for() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.event_group_set_bits(g, 0b1101).expect("set");
assert_eq!(
k.event_group_wait_bits(g, 0b0001, true, false, 0),
Ok(Wait::Ready(0b1101)),
"the answer is the value at the moment the wait was satisfied"
);
assert_eq!(
k.event_group_bits(g),
Ok(0b1100),
"and only bit 0 was taken: the other two were nobody's business"
);
}
#[test]
fn a_reused_group_slot_does_not_inherit_the_last_groups_waiters() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.create_task("w", 1).expect("a waiter");
let h = k.start_scheduler().expect("start");
k.suspend(Some(h.timer)).expect("park the daemon");
let list = K::event_group_list(g);
let mut blocked = false;
for _ in 0..50_u32 {
if k.name_of(k.current()).expect("a name").as_str() == "w" {
assert_eq!(
k.event_group_wait_bits(g, 0b0011, false, true, 50),
Ok(Wait::Blocked),
"ALL of two bits, neither set"
);
blocked = true;
break;
}
k.switch_context();
}
assert!(blocked, "never got the waiter onto the CPU");
assert!(
k.lists.head(list).expect("a list").is_some(),
"the premise: a blocked waiter IS on the group's list, so the list this test is about is not trivially empty"
);
k.event_group_delete(g).expect("delete");
assert!(
k.lists.head(list).expect("a list").is_none(),
"delete unblocks every waiter, so it leaves the list empty -- this is the invariant that replaced create's drain"
);
let g2 = k.event_group_create().expect("a second group");
assert_eq!(
g2.index(),
g.index(),
"the premise of the hazard: the arena reused the same slot, so both groups name the SAME list"
);
assert!(
k.lists
.head(K::event_group_list(g2))
.expect("a list")
.is_none(),
"and the fresh group has inherited no waiters"
);
}
#[test]
fn a_new_group_is_empty_and_a_deleted_one_is_gone() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
assert_eq!(k.event_group_bits(g), Ok(0));
k.event_group_delete(g).expect("delete");
assert!(
k.event_group_bits(g).is_err(),
"a stale handle is an error, not a zero"
);
}
#[test]
fn the_all_and_any_predicates_decide_whether_clear_on_exit_runs() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.event_group_set_bits(g, 0b0001).expect("set");
k.event_group_wait_bits(g, 0b0011, true, false, 0)
.expect("wait");
assert_eq!(
k.event_group_bits(g),
Ok(0b0000),
"ANY was satisfied by one bit, so clear-on-exit took it"
);
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.event_group_set_bits(g, 0b0001).expect("set");
k.event_group_wait_bits(g, 0b0011, true, true, 0)
.expect("wait");
assert_eq!(
k.event_group_bits(g),
Ok(0b0001),
"ALL was NOT satisfied, so clear-on-exit did not run"
);
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.event_group_set_bits(g, 0b1011).expect("set");
k.event_group_wait_bits(g, 0b0011, true, true, 0)
.expect("wait");
assert_eq!(
k.event_group_bits(g),
Ok(0b1000),
"ALL satisfied: bits 0 and 1 taken, bit 3 was nobody's business"
);
}
#[test]
fn set_bits_from_isr_only_queues_the_work() {
let mut k = started();
let g = k.event_group_create().expect("a group");
let (queued, _woken) = k.event_group_set_bits_from_isr(g, 0b0101).expect("isr");
assert!(queued, "the callback was queued");
assert_eq!(
k.event_group_bits(g),
Ok(0),
"and NOTHING is set yet: the daemon has not run"
);
k.event_group_pended_call(PENDED_SET_BITS, u64::from(g.index()), 0b0101)
.expect("the daemon runs the callback");
assert_eq!(k.event_group_bits(g), Ok(0b0101));
}
#[test]
fn clear_bits_from_isr_only_queues_the_work() {
let mut k = started();
let g = k.event_group_create().expect("a group");
k.event_group_set_bits(g, 0b1111).expect("set");
let (queued, _woken) = k.event_group_clear_bits_from_isr(g, 0b0101).expect("isr");
assert!(queued, "the callback was queued");
assert_eq!(
k.event_group_bits(g),
Ok(0b1111),
"and nothing is cleared yet"
);
k.event_group_pended_call(PENDED_CLEAR_BITS, u64::from(g.index()), 0b0101)
.expect("the daemon runs the callback");
assert_eq!(k.event_group_bits(g), Ok(0b1010));
}
#[test]
fn bits_from_isr_reads_directly_and_is_not_deferred() {
let mut k = started();
let g = k.event_group_create().expect("a group");
assert_eq!(k.event_group_bits_from_isr(g), Ok(0));
k.event_group_set_bits(g, 0b0110).expect("set from a task");
assert_eq!(
k.event_group_bits_from_isr(g),
Ok(0b0110),
"read straight through, unlike set and clear"
);
assert_eq!(k.event_group_bits_from_isr(g), k.event_group_bits(g));
}
#[test]
fn a_pended_call_for_a_deleted_group_is_an_error() {
let mut k = started();
let g = k.event_group_create().expect("a group");
let index = u64::from(g.index());
k.event_group_delete(g).expect("delete");
assert!(
k.event_group_pended_call(PENDED_SET_BITS, index, 0b0001)
.is_err(),
"the slot is empty and the daemon must not write into it"
);
}
#[test]
fn a_sync_that_completes_answers_the_value_from_before_it_clears() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.event_group_set_bits(g, 0b0001)
.expect("the other half arrived");
assert_eq!(
k.event_group_sync(g, 0b0010, 0b0011, 0),
Ok(Wait::Ready(0b0011)),
"original | set, INCLUDING the bits it is about to clear"
);
assert_eq!(
k.event_group_bits(g),
Ok(0b0000),
"and the rendezvous bits are gone: sync always clears on exit"
);
}
#[test]
fn a_sync_that_does_not_complete_still_leaves_its_own_bits_set() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
assert_eq!(
k.event_group_sync(g, 0b0001, 0b0011, 0),
Ok(Wait::Ready(0b0001)),
"not satisfied, so the answer is the CURRENT bits"
);
assert_eq!(
k.event_group_bits(g),
Ok(0b0001),
"and this caller's arrival is still recorded for the others"
);
}
#[test]
fn a_sync_clears_only_its_own_rendezvous_bits() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.event_group_set_bits(g, 0b1000)
.expect("somebody else's bit");
assert_eq!(
k.event_group_sync(g, 0b0001, 0b0001, 0),
Ok(Wait::Ready(0b1001)),
"the answer carries the unrelated bit too"
);
assert_eq!(
k.event_group_bits(g),
Ok(0b1000),
"and the unrelated bit survives the clear"
);
}
#[test]
fn a_woken_waiter_resumes_and_is_told_which_bits_satisfied_it() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.create_task("w", 1).expect("a waiter");
let h = k.start_scheduler().expect("start");
k.suspend(Some(h.timer)).expect("park the daemon");
let mut blocked = false;
for _ in 0..50_u32 {
if k.name_of(k.current()).expect("a name").as_str() == "w" {
assert_eq!(
k.event_group_wait_bits(g, 0b0011, true, true, 50),
Ok(Wait::Blocked),
"ALL of two bits, neither set yet"
);
blocked = true;
break;
}
k.switch_context();
}
assert!(blocked, "never got the waiter onto the CPU");
k.event_group_set_bits(g, 0b0001).expect("half of it");
assert_eq!(
k.event_group_bits(g),
Ok(0b0001),
"one bit does not satisfy ALL, so nothing was consumed"
);
k.event_group_set_bits(g, 0b0010).expect("the other half");
assert_eq!(
k.event_group_bits(g),
Ok(0b0000),
"both bits matched, so the waiter took them"
);
let mut finished = false;
for _ in 0..50_u32 {
if k.name_of(k.current()).expect("a name").as_str() == "w" {
assert_eq!(
k.event_group_wait_bits(g, 0b0011, true, true, 50),
Ok(Wait::Ready(0b0011)),
"it is told the bits that satisfied it, not what is \
left in the group after its own clear"
);
finished = true;
break;
}
k.switch_context();
}
assert!(finished, "the waiter never ran again");
}
#[test]
fn two_tasks_rendezvous_and_the_one_that_waited_is_told_it_completed() {
let mut k = kernel();
let g = k.event_group_create().expect("a group");
k.create_task("a", 1).expect("first arrival");
k.create_task("b", 1).expect("second arrival");
let h = k.start_scheduler().expect("start");
k.suspend(Some(h.timer)).expect("park the daemon");
const A: u32 = 0b0001;
const B: u32 = 0b0010;
const BOTH: u32 = A | B;
let mut waited = false;
for _ in 0..50_u32 {
if k.name_of(k.current()).expect("a name").as_str() == "a" {
assert_eq!(
k.event_group_sync(g, A, BOTH, 50),
Ok(Wait::Blocked),
"only one of the two has arrived"
);
waited = true;
break;
}
k.switch_context();
}
assert!(waited, "task a never reached the CPU");
assert_eq!(
k.event_group_bits(g),
Ok(A),
"and its arrival is recorded while it waits"
);
let mut completed = false;
for _ in 0..50_u32 {
if k.name_of(k.current()).expect("a name").as_str() == "b" {
assert_eq!(
k.event_group_sync(g, B, BOTH, 50),
Ok(Wait::Ready(BOTH)),
"the second arrival sees both and does not block"
);
completed = true;
break;
}
k.switch_context();
}
assert!(completed, "task b never reached the CPU");
assert_eq!(
k.event_group_bits(g),
Ok(0),
"the rendezvous bits are consumed once, not twice"
);
let mut resumed = false;
for _ in 0..50_u32 {
if k.name_of(k.current()).expect("a name").as_str() == "a" {
assert_eq!(
k.event_group_sync(g, A, BOTH, 50),
Ok(Wait::Ready(BOTH)),
"it is told the rendezvous completed, even though the group is empty again by the time it runs"
);
resumed = true;
break;
}
k.switch_context();
}
assert!(resumed, "task a never ran again");
}
}