use rrkernel::{scheduler, thread, IdlePolicy, Measure, SchedulerConfig, Slice};
use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
const RUN_MS: u64 = 600;
const WINDOW_MS: u64 = 50;
const WINDOWS: u32 = 3;
static SLEEPS: AtomicU32 = AtomicU32::new(0);
static EARLY: AtomicU32 = AtomicU32::new(0);
static WORST_LATE: AtomicU64 = AtomicU64::new(0);
static CHURN_SPAWNS: AtomicU32 = AtomicU32::new(0);
static CHURN_WINDOWS: AtomicU32 = AtomicU32::new(0);
static PAUSE: AtomicU32 = AtomicU32::new(0);
static WINDOW_SWITCHES: AtomicU64 = AtomicU64::new(0);
static WINDOW_TICKS: AtomicU64 = AtomicU64::new(0);
static WINDOW_MIN: AtomicU64 = AtomicU64::new(u64::MAX);
fn record(requested: u64, elapsed: u64) {
let _ = SLEEPS.fetch_add(1, Ordering::Relaxed);
if elapsed < requested {
let _ = EARLY.fetch_add(1, Ordering::Relaxed);
}
let late = elapsed.saturating_sub(requested);
let _ = WORST_LATE.fetch_max(late, Ordering::Relaxed);
let _ = WINDOW_MIN.fetch_min(elapsed, Ordering::Relaxed);
}
fn sleep_ticks_checked(ticks: u64) {
let t0 = scheduler::tick_count();
let w0 = std::time::Instant::now();
rrkernel::sleep_ms(ticks);
record(ticks, scheduler::tick_count().wrapping_sub(t0));
if !sync_parking() {
let want = std::time::Duration::from_millis(ticks);
while w0.elapsed() < want {
core::hint::spin_loop();
}
}
}
fn sync_parking() -> bool {
rrkernel::arch::parks_synchronously()
}
fn deadline_checked(period_ticks: u64) {
let mut next = rrkernel::deadline_after(rrkernel::Duration::from_millis(period_ticks));
let mut iterations = 0u32;
while PAUSE.load(Ordering::Relaxed) == 0 && iterations < 8 {
rrkernel::sleep_until(next);
let now = rrkernel::now();
if now >= next {
let _ = SLEEPS.fetch_add(1, Ordering::Relaxed);
} else {
let _ = EARLY.fetch_add(1, Ordering::Relaxed);
}
next = rrkernel::deadline_add(next, rrkernel::Duration::from_millis(period_ticks));
iterations += 1;
}
}
fn main() {
let limits = scheduler::platform_limits();
println!("platform: {}", limits.timer_note);
println!(
"slice limits: {} ns .. {} ns",
limits.min_slice_ns,
limits.max_slice_ns.unwrap_or(u64::MAX)
);
let cfg = SchedulerConfig {
slice: Slice::Millis(1),
timer_hz: 0,
stack_size: 16 * 1024,
arena: Some(Box::<[u8]>::leak(vec![0u8; 512 * 1024].into_boxed_slice())),
idle: IdlePolicy::Wait,
measure: Measure::Nanos,
};
if let Err(e) = scheduler::init_with(cfg) {
eprintln!("scheduler init failed: {e}");
std::process::exit(2);
}
println!("scheduler live: slice = {} ns", scheduler::slice_ns());
if !sync_parking() {
println!();
println!("PARKING : asynchronous on this backend — the strict scenario is NOT run.");
println!(" A blocking call can return before its caller is off the CPU, so a");
println!(" task-visible `elapsed` around a sleep is not evidence of anything.");
println!(" Run this example on hardware (or a bare-metal QEMU target) for the");
println!(" strict form; see docs/DESIGN.md, \"asymmetric parking\".");
println!("expected : more than 20 sleeps recorded, 0 early returns, bounded idle window",);
scheduler::shutdown(0);
}
thread::spawn(|| loop {
let n = if PAUSE.load(Ordering::Relaxed) != 0 {
WINDOW_MS
} else {
5
};
sleep_ticks_checked(n);
});
thread::spawn(|| loop {
let n = if PAUSE.load(Ordering::Relaxed) != 0 {
WINDOW_MS
} else {
7
};
sleep_ticks_checked(n);
});
thread::spawn(|| loop {
if PAUSE.load(Ordering::Relaxed) != 0 {
sleep_ticks_checked(WINDOW_MS);
continue;
}
deadline_checked(10);
});
if sync_parking() {
thread::spawn(|| loop {
if PAUSE.load(Ordering::Relaxed) != 0 {
sleep_ticks_checked(WINDOW_MS);
continue;
}
thread::spawn(core::hint::spin_loop); let _ = CHURN_SPAWNS.fetch_add(1, Ordering::Relaxed);
sleep_ticks_checked(1);
});
} else {
println!(
"reduced scenario: this backend's parking is asynchronous, so the churn and \
all-sleeping phases are skipped (they would measure the host, not the kernel)"
);
}
scheduler::main_body(|| {
let start = rrkernel::now();
while rrkernel::now().wrapping_sub(start) < RUN_MS {
rrkernel::sleep_ms(1);
}
let churn = CHURN_SPAWNS.load(Ordering::Relaxed);
for _ in 0..WINDOWS {
if !sync_parking() {
break;
}
PAUSE.store(1, Ordering::Relaxed);
rrkernel::sleep_ms(2); let s0 = scheduler::switch_count();
let t0 = scheduler::tick_count();
rrkernel::sleep_ms(WINDOW_MS); let sw = scheduler::switch_count().wrapping_sub(s0);
let tk = scheduler::tick_count().wrapping_sub(t0);
let _ = WINDOW_SWITCHES.fetch_add(sw, Ordering::Relaxed);
let _ = WINDOW_TICKS.fetch_add(tk, Ordering::Relaxed);
let _ = CHURN_WINDOWS.fetch_add(1, Ordering::Relaxed);
PAUSE.store(0, Ordering::Relaxed);
rrkernel::sleep_ms(2);
}
report(churn);
});
}
fn report(churn: u32) -> ! {
let st = scheduler::stats();
let sleeps = SLEEPS.load(Ordering::Relaxed);
let early = EARLY.load(Ordering::Relaxed);
let worst_late = WORST_LATE.load(Ordering::Relaxed);
let min_elapsed = WINDOW_MIN.load(Ordering::Relaxed);
let wsw = WINDOW_SWITCHES.load(Ordering::Relaxed);
let wtk = WINDOW_TICKS.load(Ordering::Relaxed);
println!("\n--- sleep fidelity report ---------------------------------");
println!(
"slice : {} ns ({} timer units, timer {} Hz)",
st.slice_ns, st.slice_cycles, st.timer_hz
);
println!("sleeps recorded : {sleeps} early returns: {early} (must be 0)");
println!("worst lateness : {worst_late} ticks (one slice is the bound)");
println!("min elapsed : {min_elapsed} ticks");
println!("churn : {churn} spawn/exit cycles during the load phase");
println!("ticks/switches : {} / {}", st.ticks, st.switches);
println!("all-sleeping : {wsw} switches over {wtk} ticks in {WINDOWS} windows");
println!(
"blocks w/o task : {} (must be 0)",
st.blocks_without_current
);
println!("-----------------------------------------------------------");
let bound = wtk.saturating_mul(2) + 16;
let sync = sync_parking();
let mut ok = true;
if sync {
if early != 0 {
println!("FAIL: {early} sleep(s) returned before their requested deadline");
ok = false;
}
} else if early != 0 {
println!(
"NOTE: {early} of {sleeps} sleeps observed fewer elapsed ticks than requested; on this \
backend parking is asynchronous (see the WARNING below)"
);
}
if st.blocks_without_current != 0 {
println!(
"FAIL: {} wait(s) were attempted with no current task",
st.blocks_without_current
);
ok = false;
}
if sync {
if sleeps < 20 {
println!("FAIL: only {sleeps} sleeps recorded; the scenario did not run");
ok = false;
}
if churn < 100 {
println!("FAIL: churn only reached {churn} spawn/exit cycles");
ok = false;
}
if wsw > bound {
println!("FAIL: the all-sleeping window did {wsw} switches, above the {bound} bound");
ok = false;
}
} else {
println!(
"observed : {churn} churn cycles, {wsw} switches over {wtk} idle-window ticks \
(not asserted: this backend cannot park synchronously)"
);
}
if !sync {
println!();
println!(
"WARNING: parking on this backend is ASYNCHRONOUS ({})",
limits_note()
);
println!(
" A task can return from its own `sleep`/`lock` before the CPU has been taken"
);
println!(
" away from it. The kernel books every wait correctly (blocks_without_current"
);
println!(
" = {}), so this is a host-backend property, not a scheduling bug.",
st.blocks_without_current
);
println!(
" Win32: the tick thread suspends the task a moment later. POSIX: the SIGALRM"
);
println!(
" handler has no idle context to switch to when nothing else is runnable."
);
println!(
" On metal the switch is synchronous, and this example asserts strictly there."
);
}
if ok {
println!(
"VERDICT : PASS{} ({sleeps} sleeps, {churn} churn cycles, {wsw} switches / {wtk} idle-window ticks)",
if sync {
" (strict: no early sleep)"
} else {
" (kernel invariants only)"
}
);
}
scheduler::shutdown(if ok { 0 } else { 1 })
}
fn limits_note() -> &'static str {
scheduler::platform_limits().timer_note
}