diff --git a/awkernel_async_lib/src/scheduler.rs b/awkernel_async_lib/src/scheduler.rs index 1637ee06f..8cdfab7df 100644 --- a/awkernel_async_lib/src/scheduler.rs +++ b/awkernel_async_lib/src/scheduler.rs @@ -20,6 +20,7 @@ use awkernel_lib::{ use alloc::boxed::Box; mod clustered_edf; +pub mod dag_edf; pub mod gedf; pub(super) mod panicked; mod prioritized_fifo; diff --git a/awkernel_async_lib/src/scheduler/dag_edf.rs b/awkernel_async_lib/src/scheduler/dag_edf.rs new file mode 100644 index 000000000..0c13a7627 --- /dev/null +++ b/awkernel_async_lib/src/scheduler/dag_edf.rs @@ -0,0 +1,246 @@ +//! Shared EDF scheduling for tasks that may belong to a DAG. + +use core::{cmp::max, marker::PhantomData}; + +use super::{Scheduler, SchedulerType, Task}; +use crate::{ + dag::{get_dag, Dag}, + scheduler::GLOBAL_WAKE_GET_MUTEX, + scheduler::{ + get_priority, peek_preemption_pending, push_preemption_pending, PREEMPTION_ENABLED, + }, + task::{ + get_task, get_tasks_running, set_current_task, set_need_preemption, DagInfo, State, + MAX_TASK_PRIORITY, + }, +}; +use alloc::{collections::BinaryHeap, sync::Arc, vec::Vec}; +use awkernel_lib::sync::mutex::{MCSNode, Mutex}; + +/// The deadline rules used by a DAG-aware EDF scheduler. +pub trait DagEdfPolicy: 'static { + /// Scheduler type with a dummy deadline, used to select its priority. + const SCHEDULER_TYPE: SchedulerType; + + /// Scheduler name used in diagnostics. + const NAME: &'static str; + + /// Extract a non-DAG task's relative deadline for this policy. + fn relative_deadline(scheduler_type: &SchedulerType) -> Option; + + /// Calculate the deadline of the DAG job processed by this node. + fn dag_deadline(dag: &Dag, node_id: u32, release: bool, wake_time: u64) -> u64; +} + +/// Returns the next DAG job deadline according to policy `P`. +/// +/// # Panics +/// +/// Panics if the DAG does not exist or if the policy panics. +pub fn calculate_dag_deadline( + dag_info: &DagInfo, + wake_time: u64, + state: State, +) -> u64 { + let dag_id = dag_info.dag_id; + let dag = + get_dag(dag_id).unwrap_or_else(|| panic!("{} scheduler: DAG {dag_id} not found", P::NAME)); + + // A preempted task resumes without releasing a new job. + let release = state != State::Preempted; + P::dag_deadline(&dag, dag_info.node_id, release, wake_time) +} + +/// DAG-aware EDF scheduler using the deadline rules supplied by `P`. +/// +/// Runtime paths use dynamically sized heaps and vectors, locks, and scans over +/// running or queued tasks. Allocation, lock contention, and scan lengths are +/// not statically bounded, so this scheduler has no fixed WCET guarantee. +pub struct DagEdfScheduler { + data: Mutex>, // Run queue. + priority: u8, + policy: PhantomData P>, +} + +struct DagEdfTask { + task: Arc, + absolute_deadline: u64, + wake_time: u64, +} + +impl PartialOrd for DagEdfTask { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl PartialEq for DagEdfTask { + fn eq(&self, other: &Self) -> bool { + self.absolute_deadline == other.absolute_deadline && self.wake_time == other.wake_time + } +} + +impl Ord for DagEdfTask { + fn cmp(&self, other: &Self) -> core::cmp::Ordering { + match other.absolute_deadline.cmp(&self.absolute_deadline) { + core::cmp::Ordering::Equal => other.wake_time.cmp(&self.wake_time), + other => other, + } + } +} + +impl Eq for DagEdfTask {} + +struct DagEdfData { + queue: BinaryHeap, +} + +impl DagEdfData { + fn new() -> Self { + Self { + queue: BinaryHeap::new(), + } + } +} + +impl Scheduler for DagEdfScheduler

{ + fn wake_task(&self, task: Arc) { + let (wake_time, absolute_deadline) = { + let mut node_inner = MCSNode::new(); + let mut info = task.info.lock(&mut node_inner); + let dag_info = info.get_dag_info(); + match P::relative_deadline(&info.scheduler_type) { + Some(relative_deadline) => { + let wake_time = awkernel_lib::delay::uptime(); + let absolute_deadline = if let Some(ref dag_info) = dag_info { + calculate_dag_deadline::

(dag_info, wake_time, info.state) + } else { + // If dag_info is not present, the task is treated as a regular task, and + // the absolute_deadline is calculated using the scheduler's relative_deadline. + wake_time + relative_deadline + }; + + task.priority + .update_priority_info(self.priority, MAX_TASK_PRIORITY - absolute_deadline); + info.update_absolute_deadline(absolute_deadline); + + (wake_time, absolute_deadline) + } + None => unreachable!(), + } + }; + + let mut node = MCSNode::new(); + let _guard = GLOBAL_WAKE_GET_MUTEX.lock(&mut node); + if !self.invoke_preemption(task.clone()) { + let mut node_inner = MCSNode::new(); + let mut data = self.data.lock(&mut node_inner); + let internal_data = data.get_or_insert_with(DagEdfData::new); + internal_data.queue.push(DagEdfTask { + task: task.clone(), + absolute_deadline, + wake_time, + }); + } + } + + fn get_next(&self, execution_ensured: bool) -> Option> { + let mut node = MCSNode::new(); + let mut data = self.data.lock(&mut node); + + let data = (*data).as_mut()?; + + loop { + // Pop a task from the run queue. + let task = data.queue.pop()?; + + // Make the state of the task Running. + { + let mut node = MCSNode::new(); + let mut task_info = task.task.info.lock(&mut node); + + if matches!(task_info.state, State::Terminated | State::Panicked) { + continue; + } + + if task_info.state == State::Preempted { + task_info.need_preemption = false; + } + if execution_ensured { + task_info.state = State::Running; + set_current_task(awkernel_lib::cpu::cpu_id(), task.task.id); + } + } + + return Some(task.task); + } + } + + fn scheduler_name(&self) -> SchedulerType { + P::SCHEDULER_TYPE + } + + fn priority(&self) -> u8 { + self.priority + } +} + +impl Default for DagEdfScheduler

{ + fn default() -> Self { + Self::new() + } +} + +impl DagEdfScheduler

{ + /// Create an empty scheduler for policy `P`. + pub const fn new() -> Self { + Self { + data: Mutex::new(None), + priority: get_priority(&P::SCHEDULER_TYPE), + policy: PhantomData, + } + } + + fn invoke_preemption(&self, task: Arc) -> bool { + if !PREEMPTION_ENABLED { + return false; + } + + let tasks_running = get_tasks_running() + .into_iter() + .filter(|rt| rt.task_id != 0) // Filter out idle CPUs + .collect::>(); + + // If the task has already been running, preempt is not required. + if tasks_running.is_empty() || tasks_running.iter().any(|rt| rt.task_id == task.id) { + return false; + } + + let preemption_target = tasks_running + .iter() + .filter_map(|rt| { + get_task(rt.task_id).map(|t| { + let highest_pending = peek_preemption_pending(rt.cpu_id).unwrap_or(t.clone()); + (max(t, highest_pending), rt.cpu_id) + }) + }) + .min() + .unwrap(); + + let (target_task, target_cpu) = preemption_target; + if task.preempts(&target_task) { + push_preemption_pending(target_cpu, task); + let preempt_irq = awkernel_lib::interrupt::get_preempt_irq(); + set_need_preemption(target_task.id, target_cpu); + awkernel_lib::interrupt::send_ipi(preempt_irq, target_cpu as u32); + + // NOTE(atsushi421): Currently, preemption is requested regardless of the number of idle CPUs. + // While this implementation easily prevents priority inversion, it may also cause unnecessary preemption. + // Therefore, a more sophisticated implementation will be considered in the future. + + return true; + } + + false + } +} diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index f7cdb5259..7924d065f 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -1,201 +1,47 @@ //! A GEDF scheduler. -use core::cmp::max; - -use super::{Scheduler, SchedulerType, Task}; +use super::{ + dag_edf::{calculate_dag_deadline, DagEdfPolicy, DagEdfScheduler}, + SchedulerType, +}; use crate::{ - dag::{get_dag, to_node_index}, - scheduler::GLOBAL_WAKE_GET_MUTEX, - scheduler::{ - get_priority, peek_preemption_pending, push_preemption_pending, PREEMPTION_ENABLED, - }, - task::{ - get_task, get_tasks_running, set_current_task, set_need_preemption, DagInfo, State, - MAX_TASK_PRIORITY, - }, + dag::{to_node_index, Dag}, + task::{DagInfo, State}, }; -use alloc::{collections::BinaryHeap, sync::Arc, vec::Vec}; -use awkernel_lib::sync::mutex::{MCSNode, Mutex}; - -pub struct GEDFScheduler { - data: Mutex>, // Run queue. - priority: u8, -} - -struct GEDFTask { - task: Arc, - absolute_deadline: u64, - wake_time: u64, -} - -impl PartialOrd for GEDFTask { - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(other)) - } -} - -impl PartialEq for GEDFTask { - fn eq(&self, other: &Self) -> bool { - self.absolute_deadline == other.absolute_deadline && self.wake_time == other.wake_time - } -} - -impl Ord for GEDFTask { - fn cmp(&self, other: &Self) -> core::cmp::Ordering { - match other.absolute_deadline.cmp(&self.absolute_deadline) { - core::cmp::Ordering::Equal => other.wake_time.cmp(&self.wake_time), - other => other, - } - } -} - -impl Eq for GEDFTask {} - -struct GEDFData { - queue: BinaryHeap, -} - -impl GEDFData { - fn new() -> Self { - Self { - queue: BinaryHeap::new(), - } - } -} - -impl Scheduler for GEDFScheduler { - fn wake_task(&self, task: Arc) { - let (wake_time, absolute_deadline) = { - let mut node_inner = MCSNode::new(); - let mut info = task.info.lock(&mut node_inner); - let dag_info = info.get_dag_info(); - match info.scheduler_type { - SchedulerType::GEDF(relative_deadline) => { - let wake_time = awkernel_lib::delay::uptime(); - let absolute_deadline = if let Some(ref dag_info) = dag_info { - calculate_and_update_dag_deadline(dag_info, wake_time, info.state) - } else { - // If dag_info is not present, the task is treated as a regular task, and - // the absolute_deadline is calculated using the scheduler's relative_deadline. - wake_time + relative_deadline - }; - - task.priority - .update_priority_info(self.priority, MAX_TASK_PRIORITY - absolute_deadline); - info.update_absolute_deadline(absolute_deadline); - (wake_time, absolute_deadline) - } - _ => unreachable!(), - } - }; +pub struct GedfPolicy; - let mut node = MCSNode::new(); - let _guard = GLOBAL_WAKE_GET_MUTEX.lock(&mut node); - if !self.invoke_preemption(task.clone()) { - let mut node_inner = MCSNode::new(); - let mut data = self.data.lock(&mut node_inner); - let internal_data = data.get_or_insert_with(GEDFData::new); - internal_data.queue.push(GEDFTask { - task: task.clone(), - absolute_deadline, - wake_time, - }); - } - } - - fn get_next(&self, execution_ensured: bool) -> Option> { - let mut node = MCSNode::new(); - let mut data = self.data.lock(&mut node); - - #[allow(clippy::question_mark)] - let data = match data.as_mut() { - Some(data) => data, - None => return None, - }; +pub type GEDFScheduler = DagEdfScheduler; - loop { - // Pop a task from the run queue. - let task = data.queue.pop()?; +pub static SCHEDULER: GEDFScheduler = GEDFScheduler::new(); - // Make the state of the task Running. - { - let mut node = MCSNode::new(); - let mut task_info = task.task.info.lock(&mut node); +impl DagEdfPolicy for GedfPolicy { + const SCHEDULER_TYPE: SchedulerType = SchedulerType::GEDF(0); + const NAME: &'static str = "GEDF"; - if matches!(task_info.state, State::Terminated | State::Panicked) { - continue; - } - - if task_info.state == State::Preempted { - task_info.need_preemption = false; - } - if execution_ensured { - task_info.state = State::Running; - set_current_task(awkernel_lib::cpu::cpu_id(), task.task.id); - } - } - - return Some(task.task); + fn relative_deadline(scheduler_type: &SchedulerType) -> Option { + match scheduler_type { + SchedulerType::GEDF(relative_deadline) => Some(*relative_deadline), + _ => None, } } - fn scheduler_name(&self) -> SchedulerType { - SchedulerType::GEDF(0) - } - - fn priority(&self) -> u8 { - self.priority - } -} - -pub static SCHEDULER: GEDFScheduler = GEDFScheduler { - data: Mutex::new(None), - priority: get_priority(&SchedulerType::GEDF(0)), -}; - -impl GEDFScheduler { - fn invoke_preemption(&self, task: Arc) -> bool { - if !PREEMPTION_ENABLED { - return false; - } - - let tasks_running = get_tasks_running() - .into_iter() - .filter(|rt| rt.task_id != 0) // Filter out idle CPUs - .collect::>(); - - // If the task has already been running, preempt is not required. - if tasks_running.is_empty() || tasks_running.iter().any(|rt| rt.task_id == task.id) { - return false; - } - - let preemption_target = tasks_running - .iter() - .filter_map(|rt| { - get_task(rt.task_id).map(|t| { - let highest_pending = peek_preemption_pending(rt.cpu_id).unwrap_or(t.clone()); - (max(t, highest_pending), rt.cpu_id) - }) - }) - .min() - .unwrap(); - - let (target_task, target_cpu) = preemption_target; - if task.preempts(&target_task) { - push_preemption_pending(target_cpu, task); - let preempt_irq = awkernel_lib::interrupt::get_preempt_irq(); - set_need_preemption(target_task.id, target_cpu); - awkernel_lib::interrupt::send_ipi(preempt_irq, target_cpu as u32); - - // NOTE(atsushi421): Currently, preemption is requested regardless of the number of idle CPUs. - // While this implementation easily prevents priority inversion, it may also cause unnecessary preemption. - // Therefore, a more sophisticated implementation will be considered in the future. - - return true; - } - - false + fn dag_deadline(dag: &Dag, node_id: u32, release: bool, wake_time: u64) -> u64 { + dag.get_or_release_job(to_node_index(node_id), release) + .map_or_else( + || { + // Microseconds, the unit of `awkernel_lib::delay::uptime()`. + let relative_deadline_us = dag + .get_sink_relative_deadline() + .map(|deadline| deadline.as_micros() as u64) + .unwrap_or_else(|_| { + let dag_id = dag.get_id(); + panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set") + }); + wake_time + relative_deadline_us + }, + |job| job.absolute_deadline, + ) } } @@ -209,26 +55,5 @@ impl GEDFScheduler { /// Panics if the DAG does not exist, has no node `dag_info.node_id`, or has no sink relative /// deadline, or the source releases a job without an interval tick target. pub fn calculate_and_update_dag_deadline(dag_info: &DagInfo, wake_time: u64, state: State) -> u64 { - let dag_id = dag_info.dag_id; - let dag = get_dag(dag_id).unwrap_or_else(|| panic!("GEDF scheduler: DAG {dag_id} not found")); - - // The wake of a preempted task resumes it and does not release a job. Any other wake - // of the source node at an unreleased job must come from its `Interval` tick. After the - // source node finishes a job, it waits only for that tick, because it has no subscriber. - let release = state != State::Preempted; - - dag.get_or_release_job(to_node_index(dag_info.node_id), release) - .map_or_else( - || { - // Microseconds, the unit of `awkernel_lib::delay::uptime()`. - let relative_deadline_us = dag - .get_sink_relative_deadline() - .map(|deadline| deadline.as_micros() as u64) - .unwrap_or_else(|_| { - panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set") - }); - wake_time + relative_deadline_us - }, - |job| job.absolute_deadline, - ) + calculate_dag_deadline::(dag_info, wake_time, state) }