#![allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::panic,
clippy::indexing_slicing,
clippy::arithmetic_side_effects,
reason = "a differential test: it asserts by panicking, and indexes and counts small tables"
)]
use core::cell::Cell;
use core::fmt::Write as _;
use rusty_rtos_core::config::Config;
use rusty_rtos_core::handle::{
EventGroupHandle, QueueHandle, StreamBufferHandle, TaskHandle, TimerHandle,
};
use rusty_rtos_core::hooks::TickHook;
use rusty_rtos_core::isr::Woken;
use rusty_rtos_core::port::Port;
use rusty_rtos_core::tick::Bits32;
use rusty_rtos_core::trace::NoTrace;
use rusty_rtos_kernel_core::events::{PENDED_CLEAR_BITS, PENDED_SET_BITS};
use rusty_rtos_kernel_core::kernel::{NotifyAction, TaskState};
use rusty_rtos_kernel_core::queue::Wait;
use rusty_rtos_kernel_core::{Kernel, list_slots_for, lists_for};
const TRACE_1: &str = include_str!("../../../oracle/api/api1.trace");
const TRACE_2: &str = include_str!("../../../oracle/api/api2.trace");
struct Cfg<const CORES: u8, const TICK0: u64>;
impl<const CORES: u8, const TICK0: u64> Config for Cfg<CORES, TICK0> {
type Tick = Bits32;
const TICK_RATE_HZ: u32 = 1000;
const MAX_PRIORITIES: u8 = 5;
const MINIMAL_STACK_SIZE: usize = 128;
const MAX_TASK_NAME_LEN: usize = 8;
const TIMER_TASK_PRIORITY: u8 = 2;
const TIMER_TASK_STACK_DEPTH: usize = 128;
const TIMER_QUEUE_LENGTH: usize = 1;
const NOTIFICATION_ARRAY_ENTRIES: usize = 1;
const MESSAGE_LENGTH_BYTES: usize = core::mem::size_of::<usize>();
const NUMBER_OF_CORES: u8 = CORES;
const USE_TIME_SLICING: bool = true;
const USE_TICKLESS_IDLE: bool = true;
const INITIAL_TICK_COUNT: u64 = TICK0;
const DYNAMIC_ALLOCATION: bool = true;
const TOTAL_HEAP_SIZE: usize = 1024 * 1024;
}
const WRAP: u64 = 0xFFFF_FDA8;
#[derive(Default)]
struct DiffPort {
core: Cell<u8>,
yields: Cell<u32>,
}
impl Port for DiffPort {
const COMMITS_SWITCH: bool = true;
fn yield_now(&self) {
self.yields.set(self.yields.get() | (1 << self.core.get()));
}
fn yield_from_isr(&self, woken: Woken) {
if woken == Woken::YES {
self.yield_now();
}
}
fn enter_critical(&self) {}
fn exit_critical(&self) {}
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 = 20;
const QUEUES: usize = 12;
const ITEMS: usize = 32;
const SET_LEN: usize = 3 * QSLOTS;
const SLOTS: usize = 10;
const QSLOTS: usize = 3;
const GSLOTS: usize = 2;
const BSLOTS: usize = 2;
const BYTES: usize = 64;
const TSLOTS: usize = 3;
const TIMERS: usize = 6;
#[derive(Clone, Copy, Default)]
struct DiffHook {
timers: [Option<TimerHandle>; TSLOTS],
fired: [u64; TSLOTS + 1],
pended: u64,
work: u64,
}
#[derive(Clone, Copy)]
enum Call {
Take(u64),
QSend {
q: usize,
value: u64,
ticks: u64,
},
QSendFront {
q: usize,
value: u64,
ticks: u64,
},
QRecv {
q: usize,
ticks: u64,
},
QPeek {
q: usize,
ticks: u64,
},
MTake(u64),
RTake(u64),
CTake(u64),
NTake {
clear: bool,
ticks: u64,
},
NWait {
entry: u32,
exit: u32,
ticks: u64,
},
GWait {
g: usize,
mask: u32,
flags: u32,
ticks: u64,
},
GSync {
g: usize,
set: u32,
mask: u32,
ticks: u64,
},
BSend {
b: usize,
len: usize,
start: u8,
ticks: u64,
},
BRecv {
b: usize,
max: usize,
ticks: u64,
},
TCmd {
t: usize,
cmd: u32,
value: u64,
ticks: u64,
},
TPend {
value: u64,
ticks: u64,
},
SSelect(u64),
}
fn action(n: u64) -> NotifyAction {
match n {
0 => NotifyAction::None,
1 => NotifyAction::SetBits,
2 => NotifyAction::Increment,
3 => NotifyAction::Overwrite,
_ => NotifyAction::NoOverwrite,
}
}
fn waited<T>(r: Result<Wait<T>, rusty_rtos_core::error::Error>, ok: impl Fn(T) -> i64) -> i64 {
match r {
Ok(Wait::Ready(v)) => ok(v),
Ok(Wait::Blocked) => -2,
Err(_) => 0,
}
}
fn bytes(len: usize, start: u8) -> Vec<u8> {
(0..len).map(|i| start.wrapping_add(i as u8)).collect()
}
fn fold(data: &[u8]) -> i64 {
data.len() as i64 * 100_000 + data.iter().map(|b| i64::from(*b)).sum::<i64>()
}
fn fnv1a64(data: &[u8]) -> u64 {
data.iter().fold(0xcbf2_9ce4_8422_2325, |h, b| {
(h ^ u64::from(*b)).wrapping_mul(0x0000_0100_0000_01b3)
})
}
fn state_char(s: TaskState) -> char {
match s {
TaskState::Running => 'X',
TaskState::Ready => 'R',
TaskState::Blocked => 'B',
TaskState::Suspended => 'S',
TaskState::Deleted => 'D',
}
}
macro_rules! replay {
($name:ident, $config:ty) => {
fn $name(trace: &str, label: &str) -> usize {
type K = Kernel<
$config,
DiffPort,
NoTrace,
DiffHook,
TASKS,
{ list_slots_for(TASKS, TIMERS, lists_for(5, QUEUES, GSLOTS)) },
{ lists_for(5, QUEUES, GSLOTS) },
QUEUES,
ITEMS,
BSLOTS,
BYTES,
TIMERS,
GSLOTS,
1,
>;
impl TickHook<K> for DiffHook {
fn tick(self, _kernel: &mut K) -> Self {
self
}
fn timer(kernel: &mut K, timer: TimerHandle, _callback: u16, _id: u64) {
let h = kernel.tick_hook_mut();
let i = h.timers.iter().position(|t| *t == Some(timer)).unwrap_or(TSLOTS);
h.fired[i] += 1;
h.work += 1;
}
fn pended(kernel: &mut K, function: u16, param1: u64, param2: u64) {
if function == PENDED_SET_BITS || function == PENDED_CLEAR_BITS {
kernel
.event_group_pended_call(function, param1, param2)
.expect("a pended group call");
return;
}
let h = kernel.tick_hook_mut();
h.pended += param2;
h.work += 1;
}
}
const CORES: u8 = <$config as Config>::NUMBER_OF_CORES;
struct D {
k: K,
app: [Option<TaskHandle>; SLOTS],
pending: [Option<Call>; SLOTS],
sem: QueueHandle,
queues: [Option<QueueHandle>; QSLOTS],
mutex: QueueHandle,
rmutex: QueueHandle,
csem: QueueHandle,
groups: [Option<EventGroupHandle>; GSLOTS],
buffers: [Option<StreamBufferHandle>; BSLOTS],
qset: QueueHandle,
wake: [u64; SLOTS],
dead: Option<TaskHandle>,
timers: [Option<TimerHandle>; TSLOTS],
daemon: TaskHandle,
timer_queue: QueueHandle,
dpc: u8,
next_expire: u64,
list_was_empty: bool,
now: u64,
placed: bool,
resumed_yielded: bool,
}
impl D {
fn on(&self, core: u8) {
self.k.port().core.set(core);
}
fn name(&self, h: TaskHandle) -> String {
if h.is_null() {
return "-".to_owned();
}
self.k
.name_of(h)
.map(|n| n.as_str().to_owned())
.unwrap_or_else(|_| "?".to_owned())
}
fn slot_of(&self, h: TaskHandle) -> Option<usize> {
self.app.iter().position(|a| *a == Some(h))
}
fn take_mask(&mut self) -> u32 {
let own = self.k.port().yields.replace(0);
own | u32::from(self.k.take_core_yields())
}
fn switch_core(&mut self, c: u8) {
self.on(c);
self.k.switch_context();
}
fn call(&mut self, slot: usize, call: Call) -> i64 {
let q = |i: usize| self.queues[i].expect("a live queue");
let r = match call {
Call::Take(ticks) => waited(self.k.semaphore_take(self.sem, ticks), |()| 1),
Call::QSend { q: i, value, ticks } => {
waited(self.k.queue_send(q(i), value, ticks), |()| 1)
}
Call::QSendFront { q: i, value, ticks } => {
waited(self.k.queue_send_to_front(q(i), value, ticks), |()| 1)
}
Call::QRecv { q: i, ticks } => {
waited(self.k.queue_receive(q(i), ticks), |v| v as i64)
}
Call::QPeek { q: i, ticks } => {
waited(self.k.queue_peek(q(i), ticks), |v| v as i64)
}
Call::MTake(ticks) => waited(self.k.semaphore_take(self.mutex, ticks), |()| 1),
Call::RTake(ticks) => {
waited(self.k.mutex_take_recursive(self.rmutex, ticks), |()| 1)
}
Call::CTake(ticks) => waited(self.k.semaphore_take(self.csem, ticks), |()| 1),
Call::NTake { clear, ticks } => {
waited(self.k.notify_take(0, clear, ticks), i64::from)
}
Call::NWait { entry, exit, ticks } => waited(
self.k.notify_wait(0, entry, exit, ticks),
|(ok, v)| i64::from(ok) + 2 * i64::from(v),
),
Call::GWait { g, mask, flags, ticks } => {
let group = self.groups[g].expect("a live group");
waited(
self.k.event_group_wait_bits(
group,
mask,
flags & 1 != 0,
flags & 2 != 0,
ticks,
),
i64::from,
)
}
Call::GSync { g, set, mask, ticks } => {
let group = self.groups[g].expect("a live group");
waited(self.k.event_group_sync(group, set, mask, ticks), i64::from)
}
Call::BSend { b, len, start, ticks } => {
let h = self.buffers[b].expect("a live buffer");
let data = bytes(len, start);
waited(self.k.stream_buffer_send(h, &data, ticks), |n| n as i64)
}
Call::BRecv { b, max, ticks } => {
let h = self.buffers[b].expect("a live buffer");
let mut out = [0u8; 32];
let got = self.k.stream_buffer_receive(h, &mut out[..max], ticks);
waited(got, |n| fold(&out[..n]))
}
Call::TCmd { t, cmd, value, ticks } => {
let h = self.timers[t].expect("a live timer");
let r = match cmd {
0 => self.k.timer_start(h, ticks),
1 => self.k.timer_stop(h, ticks),
2 => self.k.timer_reset(h, ticks),
_ => self.k.timer_change_period(h, value, ticks),
};
waited(r, i64::from)
}
Call::TPend { value, ticks } => {
waited(self.k.timer_pend_function_call(1, 0, value, ticks), i64::from)
}
Call::SSelect(ticks) => match self.k.queue_select_from_set(self.qset, ticks) {
Ok(Wait::Blocked) => -2,
Ok(Wait::Ready(m)) => self.take_selected(m, false),
Err(_) => 0,
},
};
self.pending[slot] = (r == -2).then_some(call);
r
}
fn take_selected(&mut self, m: Option<QueueHandle>, from_isr: bool) -> i64 {
let Some(m) = m else {
return 0;
};
let i = self.queues.iter().position(|q| *q == Some(m)).expect("a member slot");
let v = if from_isr {
self.k.queue_receive_from_isr(m).map_or(0, |(v, _woken)| v as i64)
} else {
match self.k.queue_receive(m, 0) {
Ok(Wait::Ready(v)) => v as i64,
_ => 0,
}
};
(i as i64 + 1) * 100 + v
}
fn run_daemon(&mut self) -> i64 {
let before = self.k.tick_hook().work;
loop {
match self.dpc {
0 => {
let (next, empty) = self.k.timer_next_expire();
self.next_expire = next;
self.list_was_empty = empty;
self.dpc = 1;
}
1 => {
self.k.suspend_all();
self.dpc = 2;
}
2 => {
let (now, switched) = self.k.timer_sample_time_now().expect("sample");
self.now = now;
if switched {
self.dpc = 7;
} else if !self.list_was_empty && self.next_expire <= now {
self.dpc = 3;
} else {
if self.list_was_empty {
self.list_was_empty = self.k.overflow_timer_list_is_empty();
}
let wait = self.next_expire.wrapping_sub(self.now);
self.placed = self.k.queue_messages_waiting(self.timer_queue).expect("queue") == 0;
self.k
.wait_for_message_restricted(self.timer_queue, wait, self.list_was_empty)
.expect("wait");
self.dpc = 6;
}
}
3 => {
let _ = self.k.resume_all();
self.dpc = 4;
}
4 => {
self.k.process_expired_timer(self.next_expire, self.now).expect("expired");
self.dpc = 8;
}
6 => {
self.resumed_yielded = self.k.resume_all();
self.dpc = 9;
if self.resumed_yielded && self.placed {
break;
}
}
9 => {
self.dpc = 8;
if !self.resumed_yielded {
self.k.task_yield();
if self.placed {
break;
}
}
}
7 => {
let _ = self.k.resume_all();
self.dpc = 8;
}
_ => match self.k.process_one_timer_command(0) {
Ok(Wait::Ready(true)) => {}
_ => self.dpc = 0,
},
}
}
(self.k.tick_hook().work - before) as i64
}
fn observe(&mut self, r: i64, mask: u32) -> String {
for c in 0..CORES {
if mask & (1 << c) != 0 {
self.switch_core(c);
}
}
self.on(0);
let mut s = format!("r={r} y={mask} cur=");
for c in 0..CORES {
let n = self.name(self.k.current_on(usize::from(c)));
let _ = write!(s, "{}{n}", if c > 0 { "," } else { "" });
}
s.push_str(" T=");
for i in 0..SLOTS {
match self.app[i] {
None => s.push('-'),
Some(h) => {
let st = self.k.task_state_get(h).map_or('?', state_char);
let p = self.k.task_priority_get(Some(h)).map_or(9, |p| p);
let _ = write!(s, "{st}{p}");
}
}
if i + 1 < SLOTS {
s.push('.');
}
}
let count = self.k.semaphore_count(self.sem).unwrap_or(99);
let _ = write!(s, " s={count} Q=");
for i in 0..QSLOTS {
match self.queues[i] {
None => s.push('-'),
Some(h) => {
let n = self.k.queue_messages_waiting(h).unwrap_or(99);
let _ = write!(s, "{n}");
}
}
if i + 1 < QSLOTS {
s.push('.');
}
}
let m = self.k.mutex_holder(self.mutex).unwrap_or(TaskHandle::NULL);
let rm = self.k.mutex_holder(self.rmutex).unwrap_or(TaskHandle::NULL);
let c = self.k.semaphore_count(self.csem).unwrap_or(99);
let _ = write!(s, " M={} R={} C={c} N=", self.name(m), self.name(rm));
for i in 0..SLOTS {
match self.app[i] {
None => s.push('-'),
Some(h) => {
let v = self.k.notify_value(Some(h), 0).map_or(-1, i64::from);
let _ = write!(s, "{v}");
}
}
if i + 1 < SLOTS {
s.push('.');
}
}
s.push_str(" E=");
for g in 0..GSLOTS {
match self.groups[g] {
None => s.push('-'),
Some(h) => {
let bits = self.k.event_group_bits(h).map_or(-1, i64::from);
let _ = write!(s, "{bits}");
}
}
if g + 1 < GSLOTS {
s.push('.');
}
}
s.push_str(" B=");
for b in 0..BSLOTS {
match self.buffers[b] {
None => s.push('-'),
Some(h) => {
let n = self.k.stream_buffer_bytes_available(h).map_or(-1, |n| n as i64);
let _ = write!(s, "{n}");
}
}
if b + 1 < BSLOTS {
s.push('.');
}
}
s.push_str(" F=");
let hook = *self.k.tick_hook();
for t in 0..TSLOTS {
match self.timers[t] {
None => s.push('-'),
Some(h) => {
let a = if self.k.timer_is_active(h).expect("active") { 'a' } else { 'i' };
let _ = write!(s, "{}{a}", hook.fired[t]);
}
}
if t + 1 < TSLOTS {
s.push('.');
}
}
let set = self.k.queue_messages_waiting(self.qset).unwrap_or(99);
let _ = write!(s, "/{} P={} S={set}", hook.fired[TSLOTS], hook.pended);
self.k.check_tasks_waiting_termination();
s
}
}
let mut lines = trace.lines();
let header = lines.next().expect("a header line");
let init: Vec<u8> = header
.split_whitespace()
.find_map(|w| w.strip_prefix("init="))
.expect("init= in the header")
.split(',')
.map(|p| p.parse().unwrap())
.collect();
assert!(
header.contains(&format!("cores={CORES} ")),
"this trace is not a {CORES}-core one: {header}"
);
let mut k = K::new(DiffPort::default(), NoTrace).expect("geometry");
let sem = k.semaphore_create_binary().expect("semaphore");
let mutex = k.mutex_create().expect("mutex");
let rmutex = k.mutex_create_recursive().expect("recursive mutex");
let csem = k.semaphore_create_counting(3, 1).expect("counting semaphore");
let qset = k.queue_create_set(SET_LEN).expect("queue set");
let mut d = D {
k,
app: [None; SLOTS],
pending: [None; SLOTS],
sem,
queues: [None; QSLOTS],
mutex,
rmutex,
csem,
groups: [None; GSLOTS],
buffers: [None; BSLOTS],
qset,
wake: [0; SLOTS],
dead: None,
timers: [None; TSLOTS],
daemon: TaskHandle::NULL,
timer_queue: QueueHandle::NULL,
dpc: 0,
next_expire: 0,
list_was_empty: false,
now: 0,
placed: false,
resumed_yielded: false,
};
for (i, p) in init.iter().enumerate() {
d.app[i] = Some(d.k.create_task(&format!("t{i}"), *p).expect("initial task"));
}
let started = d.k.start_scheduler().expect("start");
d.daemon = started.timer;
d.timer_queue = started.timer_queue;
d.on(0);
let _ = d.take_mask();
for c in 0..CORES {
d.switch_core(c);
}
let _ = d.take_mask();
let mut seen: Vec<&str> = Vec::new();
for line in lines {
let (step, want) = line.split_once(" | ").expect("a step line");
let mut w = step.split_whitespace();
let _n = w.next();
let core: u8 = w.next().unwrap().trim_start_matches('c').parse().unwrap();
let op = w.next().unwrap();
let args: Vec<&str> = w.collect();
let num = |i: usize| -> u64 { args[i].parse().unwrap() };
d.on(core);
let _ = d.take_mask();
let cur_slot = d.slot_of(d.k.current_on(usize::from(core)));
let mut r: i64 = 0;
match op {
"start" | "noop" => {}
"abort" => {
r = i64::from(d.k.abort_delay(d.app[num(0) as usize].unwrap()).expect("abort"));
}
"setwake" => {
if let Some(s) = cur_slot {
d.wake[s] = num(0);
}
}
"dlyuntil" => {
let s = cur_slot.expect("delay until from an app task");
let mut prev = d.wake[s];
let ok = d.k.delay_until(&mut prev, num(0)).expect("delay until");
d.wake[s] = prev;
r = i64::from(ok) + 2 * prev as i64;
}
"gethandle" => {
let want = d.app[num(0) as usize];
r = match d.k.task_get_handle(args[1]) {
Ok(h) if h.is_null() => 0,
Ok(h) if Some(h) == want => 1,
Ok(_) => 2,
Err(_) => 0,
};
}
"sall" => {
d.k.suspend_all();
let a: i64 = match num(0) {
0 => {
let t = d.k.increment_tick();
if t {
d.k.port().yield_now();
}
i64::from(t)
}
1 => i64::from(matches!(d.k.semaphore_give(d.sem), Ok(Wait::Ready(())))),
_ => match d.k.semaphore_give_from_isr(d.sem) {
Ok(woken) => {
d.k.port().yield_from_isr(woken);
1
}
Err(_) => 0,
},
};
r = 2 * a + i64::from(d.k.resume_all());
}
"crit" => {
d.k.enter_critical();
d.k.exit_critical();
}
"tickcount" => r = d.k.tick_count() as i64,
"tickcount_isr" => r = d.k.tick_count_from_isr() as i64,
"semspaces" => r = d.k.queue_spaces_available(d.sem).unwrap() as i64,
"steptick" => {
if d.k.tick_count() != 0xFFFF_FFFF {
d.k.suspend_all();
d.k.step_tick(1);
r = 1 + 2 * i64::from(d.k.resume_all());
}
}
"deadstate" => {
let h = d.dead.expect("a task deleted while running");
r = match d.k.task_state_get(h) {
Ok(TaskState::Running) => 0,
Ok(TaskState::Ready) => 1,
Ok(TaskState::Blocked) => 2,
Ok(TaskState::Suspended) => 3,
Ok(TaskState::Deleted) => 4,
Err(_) => 5,
};
}
"qspaces" => {
r = d.k.queue_spaces_available(d.queues[num(0) as usize].unwrap()).unwrap() as i64;
}
"saddnotaset" => {
r = i64::from(d.k.queue_add_to_set(d.csem, d.sem).expect("add to a non-set"));
}
"sadd" => {
let q = d.queues[num(0) as usize].unwrap();
r = i64::from(d.k.queue_add_to_set(q, d.qset).expect("add to set"));
}
"sremove" => {
let q = d.queues[num(0) as usize].unwrap();
r = i64::from(d.k.queue_remove_from_set(q, d.qset).expect("remove from set"));
}
"sselect" => {
let s = cur_slot.expect("a select from an app task");
r = d.call(s, Call::SSelect(num(0)));
}
"sselect_isr" => {
let m = d.k.queue_select_from_set_from_isr(d.qset).expect("select from ISR");
r = d.take_selected(m, true);
}
"daemon" => {
assert_eq!(d.k.current_on(usize::from(core)), d.daemon, "daemon: not current");
r = d.run_daemon();
}
"tcreate" => {
let t = num(0) as usize;
match d.k.timer_create("T", num(1), num(2) == 1, t as u64, 0) {
Ok(h) => {
d.timers[t] = Some(h);
d.k.tick_hook_mut().timers[t] = Some(h);
r = 1;
}
Err(_) => r = -1,
}
}
"tdelete" => {
let t = num(0) as usize;
let h = d.timers[t].unwrap();
r = waited(d.k.timer_delete(h, 0), i64::from);
if r == 1 {
d.timers[t] = None;
d.k.tick_hook_mut().timers[t] = None;
}
}
"tstart" | "tstop" | "treset" | "tperiod" => {
let s = cur_slot.expect("a timer command from an app task");
let cmd = match op {
"tstart" => 0,
"tstop" => 1,
"treset" => 2,
_ => 3,
};
let call = Call::TCmd { t: num(0) as usize, cmd, value: num(1), ticks: num(2) };
r = d.call(s, call);
}
"tstart_isr" | "tstop_isr" | "treset_isr" | "tperiod_isr" => {
let h = d.timers[num(0) as usize].unwrap();
let (ok, woken) = match op {
"tstart_isr" => d.k.timer_start_from_isr(h),
"tstop_isr" => d.k.timer_stop_from_isr(h),
"treset_isr" => d.k.timer_reset_from_isr(h),
_ => d.k.timer_change_period_from_isr(h, num(1)),
}
.expect("a timer command from an ISR");
d.k.port().yield_from_isr(woken);
r = i64::from(ok);
}
"tactive" | "tinfo" | "treload" | "tsetid" | "texpiry" | "tinactive" => {
let h = d.timers[num(0) as usize].unwrap();
r = match op {
"tactive" => i64::from(d.k.timer_is_active(h).unwrap()),
"tinfo" => {
d.k.timer_period(h).unwrap() as i64
+ 100 * i64::from(d.k.timer_auto_reload(h).unwrap())
+ 1000 * d.k.timer_id(h).unwrap() as i64
}
"treload" => {
d.k.timer_set_auto_reload(h, num(1) == 1).unwrap();
0
}
"tsetid" => {
d.k.timer_set_id(h, num(1)).unwrap();
0
}
"tinactive" => {
assert!(!d.k.timer_is_active(h).unwrap(), "tinactive: active");
0
}
_ => {
assert!(d.k.timer_is_active(h).unwrap(), "texpiry: inactive");
d.k.timer_expiry_time(h).unwrap() as i64
}
};
}
"tpend" => {
let s = cur_slot.expect("a pended call from an app task");
r = d.call(s, Call::TPend { value: num(0), ticks: num(1) });
}
"tpend_isr" => {
let (ok, woken) = d.k.timer_pend_function_call_from_isr(1, 0, num(0)).unwrap();
d.k.port().yield_from_isr(woken);
r = i64::from(ok);
}
"gset_isr" => {
let h = d.groups[num(0) as usize].unwrap();
let (ok, woken) = d.k.event_group_set_bits_from_isr(h, num(1) as u32).unwrap();
d.k.port().yield_from_isr(woken);
r = i64::from(ok);
}
"gclear_isr" => {
let h = d.groups[num(0) as usize].unwrap();
let (ok, _woken) = d.k.event_group_clear_bits_from_isr(h, num(1) as u32).unwrap();
r = i64::from(ok);
}
"cont" => {
let s = cur_slot.expect("cont: the current task is an app task");
let call = d.pending[s].expect("cont: a call is pending");
r = d.call(s, call);
}
"create" => {
let slot = num(0) as usize;
match d.k.create_task(args[1], num(2) as u8) {
Ok(h) => {
d.app[slot] = Some(h);
d.wake[slot] = 0;
r = 1;
}
Err(_) => r = -1,
}
}
"delete" => {
let slot = num(0) as usize;
let h = d.app[slot].take().unwrap();
d.pending[slot] = None;
if (0..CORES).any(|c| d.k.current_on(usize::from(c)) == h) {
d.dead = Some(h);
}
d.k.task_delete(Some(h)).expect("delete");
}
"suspend" => d.k.suspend(d.app[num(0) as usize]).expect("suspend"),
"resume" => d.k.resume(d.app[num(0) as usize].unwrap()).expect("resume"),
"prio" => d
.k
.set_priority(d.app[num(0) as usize], num(1) as u8)
.expect("priority"),
"delay" => d.k.delay(num(0)).expect("delay"),
"give" => {
r = i64::from(matches!(d.k.semaphore_give(d.sem), Ok(Wait::Ready(()))));
}
"give_isr" => match d.k.semaphore_give_from_isr(d.sem) {
Ok(woken) => {
r = 1;
d.k.port().yield_from_isr(woken);
}
Err(_) => r = 0,
},
"take" => {
let s = cur_slot.expect("take: the current task is an app task");
let ticks = num(0);
if ticks == 0 {
r = i64::from(matches!(
d.k.semaphore_take(d.sem, 0),
Ok(Wait::Ready(()))
));
} else {
r = d.call(s, Call::Take(ticks));
}
}
"qcreate" => match d.k.queue_create(num(1) as usize) {
Ok(h) => {
d.queues[num(0) as usize] = Some(h);
r = 1;
}
Err(_) => r = -1,
},
"qdelete" => {
let h = d.queues[num(0) as usize].take().unwrap();
d.k.queue_delete(h).expect("queue delete");
}
"qsend" | "qsendf" | "qrecv" | "qpeek" => {
let s = cur_slot.expect("a queue call from an app task");
let q = num(0) as usize;
let call = match op {
"qsend" => Call::QSend { q, value: num(1), ticks: num(2) },
"qsendf" => Call::QSendFront { q, value: num(1), ticks: num(2) },
"qrecv" => Call::QRecv { q, ticks: num(1) },
_ => Call::QPeek { q, ticks: num(1) },
};
r = d.call(s, call);
}
"qover" => {
let h = d.queues[num(0) as usize].unwrap();
r = waited(d.k.queue_overwrite(h, num(1)), |()| 1);
}
"qreset" => {
let h = d.queues[num(0) as usize].unwrap();
d.k.queue_reset(h).expect("reset");
r = 1; }
"qsend_isr" | "qsendf_isr" | "qover_isr" => {
let h = d.queues[num(0) as usize].unwrap();
let sent = match op {
"qsend_isr" => d.k.queue_send_from_isr(h, num(1)),
"qsendf_isr" => d.k.queue_send_to_front_from_isr(h, num(1)),
_ => d.k.queue_overwrite_from_isr(h, num(1)),
};
match sent {
Ok(woken) => {
r = 1;
d.k.port().yield_from_isr(woken);
}
Err(_) => r = 0,
}
}
"qrecv_isr" => {
let h = d.queues[num(0) as usize].unwrap();
match d.k.queue_receive_from_isr(h) {
Ok((v, woken)) => {
r = v as i64;
d.k.port().yield_from_isr(woken);
}
Err(_) => r = 0,
}
}
"qpeek_isr" => {
let h = d.queues[num(0) as usize].unwrap();
r = d.k.queue_peek_from_isr(h).map_or(0, |v| v as i64);
}
"qfull_isr" => {
let h = d.queues[num(0) as usize].unwrap();
r = i64::from(d.k.queue_is_full_from_isr(h).unwrap_or(false));
}
"bcreate" => {
let b = num(0) as usize;
let made = if b == 0 {
d.k.stream_buffer_create(12, num(1) as usize)
} else {
d.k.message_buffer_create(20)
};
match made {
Ok(h) => {
d.buffers[b] = Some(h);
r = 1;
}
Err(_) => r = -1,
}
}
"bdelete" => {
let h = d.buffers[num(0) as usize].take().unwrap();
d.k.stream_buffer_delete(h).expect("buffer delete");
}
"bsend" | "brecv" => {
let s = cur_slot.expect("a buffer call from an app task");
let b = num(0) as usize;
let call = if op == "bsend" {
Call::BSend { b, len: num(1) as usize, start: num(2) as u8, ticks: num(3) }
} else {
Call::BRecv { b, max: num(1) as usize, ticks: num(2) }
};
r = d.call(s, call);
}
"bsend_isr" => {
let h = d.buffers[num(0) as usize].unwrap();
let data = bytes(num(1) as usize, num(2) as u8);
let (n, woken) = d.k.stream_buffer_send_from_isr(h, &data).unwrap();
d.k.port().yield_from_isr(woken);
r = n as i64;
}
"brecv_isr" => {
let h = d.buffers[num(0) as usize].unwrap();
let mut out = [0u8; 32];
let max = num(1) as usize;
let (n, woken) = d.k.stream_buffer_receive_from_isr(h, &mut out[..max]).unwrap();
d.k.port().yield_from_isr(woken);
r = fold(&out[..n]);
}
"bspace" | "bfullempty" | "bnext" | "btrigger" | "breset" | "bdone_isr" => {
let h = d.buffers[num(0) as usize].unwrap();
r = match op {
"bspace" => d.k.stream_buffer_spaces_available(h).unwrap() as i64,
"bfullempty" => {
i64::from(d.k.stream_buffer_is_full(h).unwrap())
+ 2 * i64::from(d.k.stream_buffer_is_empty(h).unwrap())
}
"bnext" => d.k.stream_buffer_next_message_length(h).unwrap() as i64,
"btrigger" => i64::from(
d.k.stream_buffer_set_trigger_level(h, num(1) as usize).unwrap(),
),
"breset" => i64::from(d.k.stream_buffer_reset(h).unwrap()),
_ => {
let (was, woken) = d.k.stream_buffer_send_completed_from_isr(h).unwrap();
d.k.port().yield_from_isr(woken);
i64::from(was)
}
};
}
"gcreate" => match d.k.event_group_create() {
Ok(h) => {
d.groups[num(0) as usize] = Some(h);
r = 1;
}
Err(_) => r = -1,
},
"gdelete" => {
let h = d.groups[num(0) as usize].take().unwrap();
d.k.event_group_delete(h).expect("group delete");
}
"gset" | "gclear" | "gget_isr" => {
let h = d.groups[num(0) as usize].unwrap();
r = i64::from(match op {
"gset" => d.k.event_group_set_bits(h, num(1) as u32).unwrap(),
"gclear" => d.k.event_group_clear_bits(h, num(1) as u32).unwrap(),
_ => d.k.event_group_bits_from_isr(h).unwrap(),
});
}
"gwait" | "gsync" => {
let s = cur_slot.expect("a group wait from an app task");
let g = num(0) as usize;
let call = if op == "gwait" {
Call::GWait {
g,
mask: num(1) as u32,
flags: num(2) as u32,
ticks: num(3),
}
} else {
Call::GSync {
g,
set: num(1) as u32,
mask: num(2) as u32,
ticks: num(3),
}
};
r = d.call(s, call);
}
"ntf" | "ntfq" | "ntf_isr" | "ntfq_isr" => {
let t = d.app[num(0) as usize].unwrap();
let (a, v) = (action(num(1)), num(2) as u32);
r = match op {
"ntf" => i64::from(d.k.notify(t, 0, v, a).unwrap()),
"ntfq" => {
let (ok, prev) = d.k.notify_and_query(t, 0, v, a).unwrap();
i64::from(ok) + 2 * i64::from(prev)
}
"ntf_isr" => {
let (ok, woken) = d.k.notify_from_isr(t, 0, v, a).unwrap();
d.k.port().yield_from_isr(woken);
i64::from(ok)
}
_ => {
let (ok, prev, woken) =
d.k.notify_and_query_from_isr(t, 0, v, a).unwrap();
d.k.port().yield_from_isr(woken);
i64::from(ok) + 2 * i64::from(prev)
}
};
}
"ngive_isr" => {
let t = d.app[num(0) as usize].unwrap();
let (_, woken) = d.k.notify_from_isr(t, 0, 0, NotifyAction::Increment).unwrap();
d.k.port().yield_from_isr(woken);
}
"ntake" | "nwait" => {
let s = cur_slot.expect("a notification wait from an app task");
let call = if op == "ntake" {
Call::NTake { clear: num(0) != 0, ticks: num(1) }
} else {
Call::NWait { entry: num(0) as u32, exit: num(1) as u32, ticks: num(2) }
};
r = d.call(s, call);
}
"nstate_clear" => {
let t = d.app[num(0) as usize];
r = i64::from(d.k.notify_state_clear(t, 0).unwrap());
}
"nvalue_clear" => {
let t = d.app[num(0) as usize];
r = i64::from(d.k.notify_value_clear(t, 0, num(1) as u32).unwrap());
}
"mtake" | "rtake" | "ctake" => {
let s = cur_slot.expect("a take from an app task");
let call = match op {
"mtake" => Call::MTake(num(0)),
"rtake" => Call::RTake(num(0)),
_ => Call::CTake(num(0)),
};
r = d.call(s, call);
}
"mgive" => r = waited(d.k.semaphore_give(d.mutex), |()| 1),
"rgive" => r = i64::from(d.k.mutex_give_recursive(d.rmutex).is_ok()),
"cgive" => r = waited(d.k.semaphore_give(d.csem), |()| 1),
"cgive_isr" => match d.k.semaphore_give_from_isr(d.csem) {
Ok(woken) => {
r = 1;
d.k.port().yield_from_isr(woken);
}
Err(_) => r = 0,
},
"tick" => {
r = i64::from(d.k.increment_tick());
if r != 0 {
d.k.port().yield_now();
}
}
"yield" => d.k.port().yield_now(),
other => panic!("an op this replay does not know: {other:?}"),
}
let mask = d.take_mask();
let got = d.observe(r, mask);
let same = match want.strip_prefix('#') {
Some(digest) => format!("{:016x}", fnv1a64(got.as_bytes())) == digest,
None => got == want,
};
if !same {
let from = seen.len().saturating_sub(4);
panic!(
"{label}: divergence at step line {}\n C: {line}\n Kairos: {step} | {got}\n preceding (C):\n {}",
seen.len(),
seen[from..].join("\n ")
);
}
seen.push(line);
}
seen.len()
}
};
}
replay!(replay_one_wrap, Cfg<1, WRAP>);
replay!(replay_two_wrap, Cfg<2, WRAP>);
replay!(replay_one_zero, Cfg<1, 0>);
replay!(replay_two_zero, Cfg<2, 0>);
fn replay(trace: &str, label: &str) -> usize {
let header = trace.lines().next().expect("a header line");
let field = |k: &str| header.split_whitespace().find_map(|w| w.strip_prefix(k));
let cores = field("cores=").expect("cores= in the header");
let tick0 = field("tick0=").map_or(0, |t| {
u64::from_str_radix(t.trim_start_matches("0x"), 16).expect("tick0= in hex")
});
match (cores, tick0) {
("1", 0) => replay_one_zero(trace, label),
("2", 0) => replay_two_zero(trace, label),
("1", WRAP) => replay_one_wrap(trace, label),
("2", WRAP) => replay_two_wrap(trace, label),
other => panic!("{label}: no replay is built for {other:?}"),
}
}
fn exercised(trace: &str) {
let t = trace.replace("\r\n", "\n");
let op = |l: &str| l.split_whitespace().nth(2).unwrap_or("").to_owned();
let count = |pred: &dyn Fn(&str) -> bool| t.lines().skip(1).filter(|l| pred(l)).count();
for (name, floor) in [
("create", 50),
("delete", 50),
("suspend", 100),
("resume", 100),
("prio", 100),
("delay", 100),
("give", 100),
("give_isr", 100),
("take", 100),
("qcreate", 40),
("qdelete", 40),
("qsend", 150),
("qsendf", 80),
("qrecv", 70),
("qpeek", 100),
("qover", 50),
("qreset", 70),
("qsend_isr", 100),
("qsendf_isr", 100),
("qover_isr", 30),
("qrecv_isr", 60),
("qpeek_isr", 50),
("qfull_isr", 50),
("mtake", 150),
("mgive", 25),
("rtake", 100),
("rgive", 100),
("ctake", 100),
("cgive", 100),
("cgive_isr", 100),
("ntf", 60),
("ntfq", 60),
("ntf_isr", 60),
("ntfq_isr", 60),
("ngive_isr", 60),
("ntake", 60),
("nwait", 60),
("nstate_clear", 60),
("nvalue_clear", 60),
("gcreate", 40),
("gdelete", 40),
("gset", 100),
("gclear", 50),
("gget_isr", 50),
("gwait", 100),
("gsync", 30),
("bcreate", 50),
("bdelete", 50),
("bsend", 50),
("brecv", 50),
("bsend_isr", 50),
("brecv_isr", 50),
("bspace", 50),
("bfullempty", 50),
("bnext", 50),
("btrigger", 40),
("breset", 50),
("bdone_isr", 50),
("daemon", 500),
("tcreate", 50),
("tdelete", 50),
("tstart", 30),
("tstop", 20),
("treset", 25),
("tperiod", 20),
("tstart_isr", 30),
("tstop_isr", 30),
("treset_isr", 30),
("tperiod_isr", 30),
("tactive", 50),
("tinfo", 40),
("treload", 40),
("tsetid", 40),
("texpiry", 15),
("tpend", 20),
("tpend_isr", 40),
("gset_isr", 30),
("gclear_isr", 30),
("abort", 60),
("dlyuntil", 50),
("gethandle", 80),
("sall", 80),
("crit", 80),
("tickcount", 60),
("tickcount_isr", 60),
("semspaces", 60),
("steptick", 60),
("deadstate", 50),
("qspaces", 60),
("sadd", 30),
("sremove", 30),
("sselect", 100),
("sselect_isr", 80),
("tick", 500),
("cont", 200),
] {
let n = count(&|l| op(l) == name);
assert!(n >= floor, "only {n} `{name}` steps (floor {floor})");
}
let blocked = count(&|l| l.contains(" r=-2 ") && op(l) != "cont");
let timeouts = count(&|l| op(l) == "cont" && l.contains(" r=0 "));
let values = count(&|l| {
let v: i64 = l
.split(" r=")
.nth(1)
.and_then(|r| r.split_whitespace().next())
.and_then(|r| r.parse().ok())
.unwrap_or(0);
v >= 10
});
assert!(blocked >= 300, "only {blocked} calls blocked");
assert!(timeouts >= 50, "only {timeouts} blocked calls timed out");
assert!(values >= 500, "only {values} values received");
}
#[test]
fn one_core_answers_every_step_as_the_c_kernel_does() {
if !same_width(TRACE_1) {
return;
}
exercised(TRACE_1);
let n = replay(&TRACE_1.replace("\r\n", "\n"), "one core");
assert_eq!(n, 28_001, "every step replayed");
}
#[test]
fn two_cores_answer_every_step_as_the_c_kernel_does() {
if !same_width(TRACE_2) {
return;
}
exercised(TRACE_2);
let n = replay(&TRACE_2.replace("\r\n", "\n"), "two cores");
assert_eq!(n, 28_001, "every step replayed");
}
fn same_width(trace: &str) -> bool {
let header = trace.lines().next().unwrap_or("");
header.split_whitespace().any(|w| w == "width=32") == cfg!(target_pointer_width = "32")
}
#[test]
fn pinned_seeds_answer_every_step_as_the_c_kernel_does() {
let only = std::env::var("API_PINS").unwrap_or_default();
let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../../oracle/api/pins");
let mut entries: Vec<_> = std::fs::read_dir(dir)
.expect("oracle/api/pins")
.map(|e| e.unwrap().path())
.collect();
entries.sort();
let mut seen = 0;
for path in entries {
let name = path.file_name().unwrap().to_string_lossy().into_owned();
let pin = std::fs::read_to_string(&path)
.unwrap()
.replace("\r\n", "\n");
let steps = pin.lines().count();
if !(name.starts_with("api1-") || name.starts_with("api2-"))
|| !name.starts_with(&only)
|| !same_width(&pin)
{
continue;
}
let n = replay(&pin, &name);
assert_eq!(n + 1, steps, "{name}: every step replayed");
seen += 1;
}
let want = if only.is_empty() { 2 } else { 1 };
assert!(seen >= want, "the pins are missing from {dir}");
}
#[test]
fn authored_sweeps_answer_every_step_as_the_c_kernel_does() {
let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../../oracle/api/sweeps");
let only = std::env::var("API_PINS").unwrap_or_default();
let mut entries: Vec<_> = std::fs::read_dir(dir)
.expect("oracle/api/sweeps")
.map(|e| e.unwrap().path())
.collect();
entries.sort();
let mut seen = 0;
for path in entries {
let name = path.file_name().unwrap().to_string_lossy().into_owned();
if !name.ends_with(".trace") || !name.starts_with(&only) {
continue;
}
let trace = std::fs::read_to_string(&path)
.unwrap()
.replace("\r\n", "\n");
let n = replay(&trace, &name);
assert_eq!(n + 1, trace.lines().count(), "{name}: every step replayed");
seen += 1;
}
assert!(seen >= 1, "the sweeps are missing from {dir}");
}
#[test]
#[ignore = "needs traces from oracle/api/fresh.sh"]
fn fresh_seeds_answer_every_step_as_the_c_kernel_does() {
let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../../oracle/api/fresh");
let mut seen = 0;
let mut entries: Vec<_> = std::fs::read_dir(dir)
.expect("oracle/api/fresh: run oracle/api/fresh.sh first")
.map(|e| e.unwrap().path())
.collect();
entries.sort();
for path in entries {
let name = path.file_name().unwrap().to_string_lossy().into_owned();
let trace = std::fs::read_to_string(&path)
.unwrap()
.replace("\r\n", "\n");
if !(name.starts_with("api1-") || name.starts_with("api2-")) {
continue;
}
replay(&trace, &name);
seen += 1;
}
assert!(seen > 0, "no traces in {dir}");
}