use core::fmt;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Slice {
Nanos(u64),
Micros(u64),
Millis(u64),
Hertz(u32),
Cycles(u32),
}
impl Slice {
pub const fn as_nanos(self, timer_hz: u32) -> u64 {
match self {
Slice::Nanos(n) => n,
Slice::Micros(us) => us.saturating_mul(1_000),
Slice::Millis(ms) => ms.saturating_mul(1_000_000),
Slice::Hertz(hz) => {
if hz == 0 {
0
} else {
1_000_000_000u64 / hz as u64
}
}
Slice::Cycles(c) => {
if timer_hz == 0 {
0
} else {
(c as u64).saturating_mul(1_000_000_000) / timer_hz as u64
}
}
}
}
pub const fn from_nanos(ns: u64) -> Slice {
Slice::Nanos(ns)
}
pub const fn to_cycles(self, timer_hz: u32) -> u64 {
if timer_hz == 0 {
return 0;
}
let ns = self.as_nanos(timer_hz) as u128;
let hz = timer_hz as u128;
let cycles = (ns * hz + 500_000_000) / 1_000_000_000;
if cycles == 0 {
1
} else {
cycles as u64
}
}
}
impl fmt::Display for Slice {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Slice::Nanos(n) => write!(f, "{} ns", n),
Slice::Micros(n) => write!(f, "{} us", n),
Slice::Millis(n) => write!(f, "{} ms", n),
Slice::Hertz(n) => write!(f, "{} Hz", n),
Slice::Cycles(n) => write!(f, "{} cycles", n),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PlatformLimits {
pub min_slice_ns: u64,
pub max_slice_ns: Option<u64>,
pub timer_hz: u32,
pub timer_note: &'static str,
}
#[derive(Debug)]
pub struct SchedulerConfig {
pub slice: Slice,
pub timer_hz: u32,
pub stack_size: usize,
pub arena: Option<&'static mut [u8]>,
pub idle: crate::tcb::IdlePolicy,
pub measure: crate::tcb::Measure,
}
impl Default for SchedulerConfig {
fn default() -> Self {
SchedulerConfig {
slice: Slice::Millis(1),
timer_hz: 0,
stack_size: crate::thread::DEFAULT_STACK_SIZE,
arena: None,
idle: crate::tcb::IdlePolicy::Wait,
measure: crate::tcb::Measure::Off,
}
}
}
impl SchedulerConfig {
pub const fn with_slice(slice: Slice) -> Self {
SchedulerConfig {
slice,
timer_hz: 0,
stack_size: crate::thread::DEFAULT_STACK_SIZE,
arena: None,
idle: crate::tcb::IdlePolicy::Wait,
measure: crate::tcb::Measure::Off,
}
}
pub const fn embedded(slice: Slice, core_clock_hz: u32) -> Self {
SchedulerConfig {
slice,
timer_hz: core_clock_hz,
stack_size: crate::thread::DEFAULT_STACK_SIZE,
arena: None,
idle: crate::tcb::IdlePolicy::Wait,
measure: crate::tcb::Measure::Cycles,
}
}
#[must_use]
pub const fn stack_size(mut self, bytes: usize) -> Self {
self.stack_size = bytes;
self
}
#[must_use]
pub const fn idle(mut self, policy: crate::tcb::IdlePolicy) -> Self {
self.idle = policy;
self
}
#[must_use]
pub const fn measure(mut self, mode: crate::tcb::Measure) -> Self {
self.measure = mode;
self
}
#[must_use]
pub fn arena(mut self, region: &'static mut [u8]) -> Self {
self.arena = Some(region);
self
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConfigError {
ZeroSlice,
TimerClockRequired,
SliceBelowPlatformMinimum { requested_ns: u64, minimum_ns: u64 },
SliceAboveTimerRange { requested_ns: u64, maximum_ns: u64 },
ArenaTooSmall { provided: usize, minimum: usize },
AlreadyInitialized,
NotInitialized,
Platform(&'static str),
}
impl fmt::Display for ConfigError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
ConfigError::ZeroSlice => write!(f, "slice resolved to zero"),
ConfigError::TimerClockRequired => write!(
f,
"timer_hz (core clock) must be set on bare metal: \
SchedulerConfig::embedded(slice, core_clock_hz)"
),
ConfigError::SliceBelowPlatformMinimum {
requested_ns,
minimum_ns,
} => write!(
f,
"requested slice {requested_ns} ns is below the platform minimum {minimum_ns} ns"
),
ConfigError::SliceAboveTimerRange {
requested_ns,
maximum_ns,
} => write!(
f,
"requested slice {requested_ns} ns exceeds the timer range (max {maximum_ns} ns)"
),
ConfigError::ArenaTooSmall { provided, minimum } => write!(
f,
"arena of {provided} bytes is too small (need at least {minimum} bytes)"
),
ConfigError::AlreadyInitialized => write!(f, "scheduler already initialized"),
ConfigError::NotInitialized => write!(f, "scheduler not initialized"),
ConfigError::Platform(msg) => write!(f, "platform error: {msg}"),
}
}
}