use core::cell::Cell;
use rusty_rtos_core::config::Config;
use rusty_rtos_core::hooks::NoTickHook;
use rusty_rtos_core::isr::Woken;
use rusty_rtos_core::port::Port;
use rusty_rtos_core::tick::Bits32;
use crate::system::tests::NoTrace;
struct SmpConfig;
impl Config for SmpConfig {
type Tick = Bits32;
const TICK_RATE_HZ: u32 = 100;
const MAX_PRIORITIES: u8 = 5;
const MINIMAL_STACK_SIZE: usize = 1;
const MAX_TASK_NAME_LEN: usize = 8;
const TIMER_TASK_PRIORITY: u8 = 1;
const TIMER_TASK_STACK_DEPTH: usize = 1;
const TIMER_QUEUE_LENGTH: usize = 1;
const NOTIFICATION_ARRAY_ENTRIES: usize = 1;
const NUMBER_OF_CORES: u8 = 2;
}
struct SlicingConfig;
impl Config for SlicingConfig {
type Tick = Bits32;
const TICK_RATE_HZ: u32 = 100;
const MAX_PRIORITIES: u8 = 5;
const MINIMAL_STACK_SIZE: usize = 1;
const MAX_TASK_NAME_LEN: usize = 8;
const TIMER_TASK_PRIORITY: u8 = 1;
const TIMER_TASK_STACK_DEPTH: usize = 1;
const TIMER_QUEUE_LENGTH: usize = 1;
const NOTIFICATION_ARRAY_ENTRIES: usize = 1;
const NUMBER_OF_CORES: u8 = 2;
const USE_TIME_SLICING: bool = true;
}
struct CooperativeConfig;
impl Config for CooperativeConfig {
type Tick = Bits32;
const TICK_RATE_HZ: u32 = 100;
const MAX_PRIORITIES: u8 = 5;
const MINIMAL_STACK_SIZE: usize = 1;
const MAX_TASK_NAME_LEN: usize = 8;
const TIMER_TASK_PRIORITY: u8 = 1;
const TIMER_TASK_STACK_DEPTH: usize = 1;
const TIMER_QUEUE_LENGTH: usize = 1;
const NOTIFICATION_ARRAY_ENTRIES: usize = 1;
const NUMBER_OF_CORES: u8 = 2;
const USE_PREEMPTION: bool = false;
}
#[derive(Default)]
struct SmpPort {
core: Cell<u8>,
nesting: Cell<u32>,
yields: Cell<u32>,
}
impl SmpPort {
fn on(&self, core: u8) {
self.core.set(core);
}
}
impl Port for SmpPort {
const COMMITS_SWITCH: bool = true;
fn count_yield(&self) {
self.yields.set(self.yields.get() + 1);
}
fn yield_now(&self) {}
fn yield_from_isr(&self, _woken: Woken) {}
fn enter_critical(&self) {
self.nesting.set(self.nesting.get() + 1);
}
fn exit_critical(&self) {
self.nesting.set(self.nesting.get().saturating_sub(1));
}
fn set_interrupt_mask_from_isr(&self) -> u32 {
0
}
fn clear_interrupt_mask_from_isr(&self, _saved: u32) {}
fn in_isr(&self) -> bool {
false
}
fn core_id(&self) -> u8 {
self.core.get()
}
fn set_in_tick_entry(&self, _yes: bool) {}
}
const TASKS: usize = 8;
const QUEUES: usize = 2;
type K<Cfg> = crate::Kernel<
Cfg,
SmpPort,
NoTrace,
NoTickHook,
TASKS,
{ crate::list_slots_for(TASKS, 0, crate::lists_for(5, QUEUES, 0)) },
{ crate::lists_for(5, QUEUES, 0) },
QUEUES,
4,
0,
0,
0,
0,
1,
>;
fn kernel<Cfg: Config>() -> K<Cfg> {
K::<Cfg>::new(SmpPort::default(), NoTrace).expect("the declared geometry adds up")
}
fn switch<Cfg: Config>(k: &mut K<Cfg>, core: u8) {
k.port().on(core);
k.switch_context();
}
#[test]
fn every_core_starts_on_its_own_idle_task() {
let mut k = kernel::<SmpConfig>();
let a = k.create_task("a", 3).expect("a");
let started = k.start_scheduler().expect("start");
assert!(!started.passive_idle.is_null(), "two cores, two idle tasks");
assert_eq!(k.current_on(0), started.idle);
assert_eq!(k.current_on(1), started.passive_idle);
assert_ne!(k.current_on(0), a);
assert_ne!(k.current_on(1), a);
}
#[test]
fn two_cores_run_the_two_highest_tasks_and_never_the_same_one() {
let mut k = kernel::<SmpConfig>();
let a = k.create_task("a", 3).expect("a");
let b = k.create_task("b", 2).expect("b");
k.start_scheduler().expect("start");
switch(&mut k, 0);
switch(&mut k, 1);
assert_eq!(k.current_on(0), a, "core 0 takes the highest");
assert_eq!(
k.current_on(1),
b,
"core 1 cannot take `a`: core 0 holds it"
);
switch(&mut k, 0);
switch(&mut k, 1);
assert_eq!((k.current_on(0), k.current_on(1)), (a, b));
}
#[test]
fn a_newly_ready_task_preempts_the_core_running_the_lowest_priority() {
let mut k = kernel::<SmpConfig>();
let a = k.create_task("a", 3).expect("a");
let b = k.create_task("b", 2).expect("b");
k.start_scheduler().expect("start");
switch(&mut k, 0);
switch(&mut k, 1);
let _ = k.take_core_yields();
k.port().on(0);
let c = k.create_task("c", 3).expect("c");
assert_eq!(k.take_core_yields(), 0b10, "core 1 is interrupted");
assert_eq!(k.take_core_yields(), 0, "the read clears it");
assert_eq!(k.current_on(0), a, "the caller keeps running");
switch(&mut k, 1);
assert_eq!(
k.current_on(1),
c,
"core 1 skips `a` (held by core 0) and takes `c`"
);
let _ = b;
}
#[test]
fn a_second_request_does_not_interrupt_a_core_twice() {
let mut k = kernel::<SmpConfig>();
k.create_task("a", 3).expect("a");
k.create_task("b", 2).expect("b");
k.start_scheduler().expect("start");
switch(&mut k, 0);
switch(&mut k, 1);
let _ = k.take_core_yields();
k.port().on(0);
k.create_task("c", 3).expect("c");
k.create_task("d", 3).expect("d");
assert_eq!(k.take_core_yields(), 0b10);
}
#[test]
fn a_running_idle_task_ranks_below_a_real_priority_zero_task() {
let mut k = kernel::<SmpConfig>();
let a = k.create_task("a", 3).expect("a");
let started = k.start_scheduler().expect("start");
switch(&mut k, 0);
switch(&mut k, 1);
let _ = k.take_core_yields();
assert_eq!(k.current_on(0), a);
k.port().on(1);
k.delay(100).expect("the daemon blocks");
switch(&mut k, 1);
let idle_on_1 = k.current_on(1);
assert!(idle_on_1 == started.idle || idle_on_1 == started.passive_idle);
assert_eq!(idle_on_1, started.idle, "the head of level 0");
let _ = k.take_core_yields();
k.port().on(0);
let z = k.create_task("z", 0).expect("z");
assert_eq!(k.take_core_yields(), 0b10);
switch(&mut k, 1);
assert_eq!(k.current_on(1), started.passive_idle);
switch(&mut k, 1);
assert_eq!(k.current_on(1), z);
}
#[test]
fn the_tick_yields_every_core_whose_priority_has_a_second_ready_task() {
let mut k = kernel::<SlicingConfig>();
let a = k.create_task("a", 3).expect("a");
let b = k.create_task("b", 3).expect("b");
k.create_task("c", 3).expect("c");
k.start_scheduler().expect("start");
switch(&mut k, 0);
switch(&mut k, 1);
assert_eq!((k.current_on(0), k.current_on(1)), (a, b));
let _ = k.take_core_yields();
k.port().on(0);
let switch_here = k.increment_tick();
assert!(switch_here, "core 0 slices");
assert_eq!(k.take_core_yields(), 0b10, "core 1 slices too");
}
struct NoSlicingConfig;
impl Config for NoSlicingConfig {
type Tick = Bits32;
const TICK_RATE_HZ: u32 = 100;
const MAX_PRIORITIES: u8 = 5;
const MINIMAL_STACK_SIZE: usize = 1;
const MAX_TASK_NAME_LEN: usize = 8;
const TIMER_TASK_PRIORITY: u8 = 1;
const TIMER_TASK_STACK_DEPTH: usize = 1;
const TIMER_QUEUE_LENGTH: usize = 1;
const NOTIFICATION_ARRAY_ENTRIES: usize = 1;
const NUMBER_OF_CORES: u8 = 2;
const USE_TIME_SLICING: bool = false;
}
#[test]
fn without_time_slicing_the_tick_yields_no_core() {
let mut k = kernel::<NoSlicingConfig>();
let a = k.create_task("a", 3).expect("a");
let b = k.create_task("b", 3).expect("b");
k.create_task("c", 3).expect("c");
k.start_scheduler().expect("start");
switch(&mut k, 0);
switch(&mut k, 1);
assert_eq!((k.current_on(0), k.current_on(1)), (a, b));
let _ = k.take_core_yields();
k.port().on(0);
assert!(!k.increment_tick(), "core 0 does not slice");
assert_eq!(k.take_core_yields(), 0, "nor does core 1");
}
#[test]
fn a_yielding_task_goes_behind_the_tasks_that_waited() {
let mut k = kernel::<SmpConfig>();
let a = k.create_task("a", 3).expect("a");
let b = k.create_task("b", 3).expect("b");
let c = k.create_task("c", 3).expect("c");
k.start_scheduler().expect("start");
switch(&mut k, 0);
switch(&mut k, 1);
assert_eq!((k.current_on(0), k.current_on(1)), (a, b));
switch(&mut k, 0);
assert_eq!(k.current_on(0), c);
switch(&mut k, 1);
assert_eq!(k.current_on(1), a);
}
#[test]
fn a_semaphore_give_wakes_its_waiter_on_the_lowest_core() {
let mut k = kernel::<SmpConfig>();
let hi = k.create_task("hi", 4).expect("hi");
let mid = k.create_task("mid", 3).expect("mid");
let low = k.create_task("low", 2).expect("low");
let sem = k.semaphore_create_binary().expect("a semaphore");
k.start_scheduler().expect("start");
switch(&mut k, 0);
switch(&mut k, 1);
assert_eq!((k.current_on(0), k.current_on(1)), (hi, mid));
let _ = k.take_core_yields();
k.port().on(0);
let wait = k.semaphore_take(sem, 100).expect("take");
assert!(matches!(wait, crate::queue::Wait::Blocked));
switch(&mut k, 0);
assert_eq!(k.current_on(0), low);
let _ = k.take_core_yields();
k.port().on(1);
let _ = k.semaphore_give(sem).expect("give");
assert_eq!(k.take_core_yields(), 0b01);
switch(&mut k, 0);
assert_eq!(k.current_on(0), hi);
assert_eq!(k.current_on(1), mid, "the giver keeps running");
}
#[test]
fn one_core_builds_never_ask_for_a_cross_core_yield() {
use crate::system::tests::{TestConfig, TestPort};
type One = crate::Kernel<
TestConfig,
TestPort,
NoTrace,
NoTickHook,
4,
{ crate::list_slots_for(4, 0, crate::lists_for(TestConfig::MAX_PRIORITIES, 1, 0)) },
{ crate::lists_for(TestConfig::MAX_PRIORITIES, 1, 0) },
1,
1,
0,
0,
0,
0,
{ <TestConfig as Config>::TIMER_QUEUE_LENGTH },
>;
let mut k = One::new(TestPort::default(), NoTrace).expect("geometry");
k.create_task("a", 1).expect("a");
let started = k.start_scheduler().expect("start");
assert!(started.passive_idle.is_null());
k.create_task("b", 2).expect("b");
assert_eq!(k.take_core_yields(), 0);
}
fn two_running() -> (
K<SmpConfig>,
crate::StartHandles,
[rusty_rtos_core::handle::TaskHandle; 3],
) {
let mut k = kernel::<SmpConfig>();
let a = k.create_task("a", 3).expect("a");
let b = k.create_task("b", 3).expect("b");
let c = k.create_task("c", 2).expect("c");
let started = k.start_scheduler().expect("start");
switch(&mut k, 0);
switch(&mut k, 1);
assert_eq!((k.current_on(0), k.current_on(1)), (a, b));
let _ = k.take_core_yields();
(k, started, [a, b, c])
}
#[test]
fn deleting_a_task_another_core_is_running_waits_for_that_core() {
let (mut k, _, [_a, b, c]) = two_running();
k.port().on(0);
k.task_delete(Some(b)).expect("delete b from core 0");
assert_eq!(k.take_core_yields(), 0b10, "core 1 is told to switch away");
k.check_tasks_waiting_termination();
assert!(
k.priority_of(Some(b)).is_ok(),
"the TCB outlives its core's switch"
);
switch(&mut k, 1);
assert_eq!(k.current_on(1), c);
k.check_tasks_waiting_termination();
assert!(
k.priority_of(Some(b)).is_err(),
"reaped once no core holds it"
);
}
#[test]
fn two_deferred_deletions_are_both_reaped() {
let (mut k, _, [a, b, _c]) = two_running();
k.port().on(0);
k.task_delete(Some(b)).expect("b");
k.task_delete(None).expect("a deletes itself");
switch(&mut k, 0);
switch(&mut k, 1);
k.check_tasks_waiting_termination();
assert!(k.priority_of(Some(a)).is_err());
assert!(k.priority_of(Some(b)).is_err());
}
#[test]
fn the_second_reap_slot_is_reaped_after_the_first_empties() {
let (mut k, _, [a, b, _c]) = two_running();
k.port().on(0);
k.task_delete(Some(b)).expect("b");
k.task_delete(None).expect("a deletes itself");
switch(&mut k, 1);
k.check_tasks_waiting_termination();
assert!(
k.priority_of(Some(b)).is_err(),
"b, in the first slot, reaped"
);
assert!(k.priority_of(Some(a)).is_ok(), "a is still core 0's");
switch(&mut k, 0);
k.check_tasks_waiting_termination();
assert!(
k.priority_of(Some(a)).is_err(),
"a, alone in the second slot, reaped"
);
}
#[test]
fn suspending_a_task_another_core_is_running_yields_that_core() {
let (mut k, _, [_a, b, c]) = two_running();
k.port().on(0);
k.suspend(Some(b)).expect("suspend b");
assert_eq!(k.take_core_yields(), 0b10);
switch(&mut k, 1);
assert_eq!(k.current_on(1), c, "a suspended task is not selected");
}
#[test]
fn lowering_a_running_task_on_another_core_yields_that_core() {
let (mut k, _, [_a, b, c]) = two_running();
let d = {
k.port().on(0);
k.create_task("d", 3).expect("d")
};
assert_eq!(k.take_core_yields(), 0);
k.set_priority(Some(b), 1).expect("lower b");
assert_eq!(k.take_core_yields(), 0b10);
switch(&mut k, 1);
assert_eq!(
k.current_on(1),
d,
"core 1 takes the waiting priority-3 task"
);
let _ = c;
}
#[test]
fn raising_a_ready_task_preempts_the_lowest_core() {
let mut k = kernel::<SmpConfig>();
let a = k.create_task("a", 3).expect("a");
let b = k.create_task("b", 2).expect("b");
let c = k.create_task("c", 1).expect("c");
k.start_scheduler().expect("start");
switch(&mut k, 0);
switch(&mut k, 1);
assert_eq!((k.current_on(0), k.current_on(1)), (a, b));
let _ = k.take_core_yields();
k.port().on(0);
k.set_priority(Some(c), 4).expect("raise c");
assert_eq!(k.take_core_yields(), 0b10);
switch(&mut k, 1);
assert_eq!(k.current_on(1), c);
}
#[test]
fn resuming_a_task_wakes_the_lowest_core() {
let (mut k, started, [_a, b, _c]) = two_running();
let hi = {
k.port().on(0);
let hi = k.create_task("hi", 4).expect("hi");
assert_eq!(k.take_core_yields(), 0b10);
switch(&mut k, 1);
assert_eq!(k.current_on(1), hi);
k.port().on(1);
k.suspend(None).expect("hi suspends itself");
switch(&mut k, 1);
hi
};
assert_eq!(k.current_on(1), b);
let _ = k.take_core_yields();
k.port().on(0);
k.resume(hi).expect("resume hi");
assert_eq!(
k.take_core_yields(),
0b10,
"the resumed task preempts core 1"
);
let _ = started;
}
#[test]
fn a_notification_wakes_its_waiter_on_another_core() {
let (mut k, _, [a, b, c]) = two_running();
k.port().on(1);
let w = k.notify_take(0, true, 100).expect("take");
assert!(matches!(w, crate::queue::Wait::Blocked));
switch(&mut k, 1);
assert_eq!(k.current_on(1), c);
let _ = k.take_core_yields();
k.port().on(0);
k.notify(b, 0, 1, crate::kernel::NotifyAction::Increment)
.expect("notify");
assert_eq!(k.take_core_yields(), 0b10);
switch(&mut k, 1);
assert_eq!(k.current_on(1), b);
assert_eq!(k.current_on(0), a, "the notifier keeps running");
}
#[test]
fn a_raised_holder_is_yielded_for_without_preemption_too() {
let mut k = kernel::<CooperativeConfig>();
let h = k.create_task("h", 2).expect("h");
let x = k.create_task("x", 2).expect("x");
let m = k.mutex_create().expect("a mutex");
k.start_scheduler().expect("start");
switch(&mut k, 0);
switch(&mut k, 1);
assert_eq!((k.current_on(0), k.current_on(1)), (h, x));
k.port().on(0);
assert_eq!(k.semaphore_take(m, 0), Ok(crate::Wait::Ready(())));
let w = k.create_task("w", 4).expect("w");
k.task_yield();
switch(&mut k, 0);
assert_eq!(
(k.current_on(0), k.current_on(1)),
(w, x),
"h holds m, ready, not running"
);
let _ = k.take_core_yields();
k.port().on(0);
assert_eq!(k.semaphore_take(m, 10), Ok(crate::Wait::Blocked));
assert_eq!(k.priority_of(Some(h)), Ok(4), "h inherits w's priority");
assert_eq!(
k.take_core_yields() & 0b10,
0b10,
"core 1 runs x (2), below the raised h (4): the C asks it to yield, preemption or not"
);
}