From 6dffb4bc5619e45080d1d180811385e7efc8e2f8 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Mon, 18 Aug 2025 10:45:47 +0900 Subject: [PATCH 01/55] test: for develop #1 Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 135 +++++++++++++++++++++++++++++ awkernel_async_lib/src/task.rs | 149 +++++++++++++++++++++++++++++++++ 2 files changed, 284 insertions(+) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index abae2d814..a8291776f 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -53,6 +53,7 @@ mod visit; #[cfg(feature = "perf")] mod performance; +use crate::task; use crate::{ dag::{ graph::{ @@ -167,6 +168,7 @@ impl core::fmt::Display for DagError { pub struct Dag { id: u32, graph: Mutex>, + absolute_deadline: Mutex>, // DAG全体の絶対デッドライン #[cfg(feature = "perf")] response_info: Mutex, @@ -177,6 +179,46 @@ impl Dag { self.id } + /// 引数のnode_idxが今動かしているDAGに所属しているか + /// 将来的にいらなさそう + // pub fn get_node_dag_id(&self, node_idx: NodeIndex) -> Option { + // let mut node = MCSNode::new(); + // let graph = self.graph.lock(&mut node); + // graph.node_weight(node_idx).map(|node_info| node_info.dag_id) + // } + + /// 指定されたノードの情報を取得 + pub fn get_node_info(&self, node_idx: NodeIndex) -> Option { + let mut node = MCSNode::new(); + let graph = self.graph.lock(&mut node); + graph.node_weight(node_idx).cloned() + } + + /// 指定されたtask_idを持つノードを検索 + pub fn find_node_by_task_id(&self, task_id: u32) -> Option { + let mut node = MCSNode::new(); + let graph = self.graph.lock(&mut node); + graph.node_indices().find(|&idx| { + graph.node_weight(idx) + .map(|node_info| node_info.task_id == task_id) + .unwrap_or(false) + }) + } + + /// このDAGに属するすべてのノードのインデックスを取得 + pub fn get_all_node_indices(&self) -> Vec { + let mut node = MCSNode::new(); + let graph = self.graph.lock(&mut node); + graph.node_indices().collect() + } + + /// このDAGに属するすべてのノードの情報を取得 + pub fn get_all_node_infos(&self) -> Vec<(NodeIndex, NodeInfo)> { + let mut node = MCSNode::new(); + let graph = self.graph.lock(&mut node); + graph.node_references().map(|node_ref| (node_ref.id(), node_ref.weight().clone())).collect() + } + fn get_source_nodes(&self) -> Vec { let mut node = MCSNode::new(); let graph = self.graph.lock(&mut node); @@ -202,6 +244,7 @@ impl Dag { ) -> NodeIndex { let add_node_info = NodeInfo { task_id: 0, // Temporary task_id + dag_id: self.id, subscribe_topic_names: subscribe_topic_names.to_vec(), publish_topic_names: publish_topic_names.to_vec(), relative_deadline: None, @@ -436,6 +479,41 @@ impl Dag { .push(node_idx.index()); } } + + // タスクのDAG情報を取得（タプル形式） + #[inline(always)] + pub fn get_dag_info(&self, node_idx: NodeIndex) -> Option<(u32, u32)> { + match (self.get_id(), self.get_node_info(node_idx)) { + (dag_id, Some(node_info)) => Some((dag_id, node_info.task_id)), + _ => None, + } + } + + // DAG絶対デッドライン管理メソッド + + // DAGの絶対デッドラインを設定 + #[inline(always)] + pub fn set_absolute_deadline(&self, deadline: u64) { + let mut node = MCSNode::new(); + let mut absolute_deadline = self.absolute_deadline.lock(&mut node); + *absolute_deadline = Some(deadline); + } + + // DAGの絶対デッドラインを取得 + #[inline(always)] + pub fn get_absolute_deadline(&self) -> Option { + let mut node = MCSNode::new(); + let absolute_deadline = self.absolute_deadline.lock(&mut node); + *absolute_deadline + } + + // DAGの絶対デッドラインをクリア：多分いらない + // #[inline(always)] + // pub fn clear_absolute_deadline(&self) { + // let mut node = MCSNode::new(); + // let mut absolute_deadline = self.absolute_deadline.lock(&mut node); + // *absolute_deadline = None; + // } } struct PendingTask { @@ -455,8 +533,10 @@ impl PendingTask { } } +#[derive(Clone)] struct NodeInfo { task_id: u32, + dag_id: u32, // どのDAGからspawnされたかを示す：多分いらない、taskinfoの方にdag_idが必要 subscribe_topic_names: Vec>, publish_topic_names: Vec>, relative_deadline: Option, @@ -488,6 +568,7 @@ impl Dags { let dag = Arc::new(Dag { id, graph: Mutex::new(graph::Graph::new()), + absolute_deadline: Mutex::new(None), #[cfg(feature = "perf")] response_info: Mutex::new(ResponseInfo::new()), @@ -524,6 +605,50 @@ pub fn get_dag(id: u32) -> Option> { dags.id_to_dag.get(&id).cloned() } +/// 指定されたDAG IDとノードインデックスからノードのDAG IDを取得 +// pub fn get_node_dag_id(dag_id: u32, node_idx: NodeIndex) -> Option { +// get_dag(dag_id)?.get_node_dag_id(node_idx) +// } + +/// 指定されたDAG IDとノードインデックスからノード情報を取得 +// pub fn get_node_info(dag_id: u32, node_idx: NodeIndex) -> Option<&NodeInfo> { +// get_dag(dag_id)?.get_node_info(node_idx) +// } + +/// 指定されたtask_idを持つノードを全DAGから検索 +// pub fn find_node_by_task_id_global(task_id: u32) -> Option<(u32, NodeIndex)> { +// let mut node = MCSNode::new(); +// let dags = DAGS.lock(&mut node); + +// for (dag_id, dag) in dags.id_to_dag.iter() { +// if let Some(node_idx) = dag.find_node_by_task_id(task_id) { +// return Some((*dag_id, node_idx)); +// } +// } +// None +// } + + + +/// DAG IDから絶対デッドラインを取得 +#[inline(always)] +pub fn get_dag_absolute_deadline(dag_id: u32) -> Option { + get_dag(dag_id)?.get_absolute_deadline() +} + +/// DAG IDから絶対デッドラインを設定 +#[inline(always)] +pub fn set_dag_absolute_deadline(dag_id: u32, deadline: u64) -> bool { + if let Some(dag) = get_dag(dag_id) { + dag.set_absolute_deadline(deadline); + true + } else { + false + } +} + + + pub async fn finish_create_dags(dags: &[Arc]) -> Result<(), Vec> { match validate_all_rules(dags) { Ok(()) => { @@ -807,7 +932,12 @@ async fn spawn_dag(dag: &Arc) { let mut graph = dag.graph.lock(&mut node); if let Some(node_info) = graph.node_weight_mut(task.node_idx) { node_info.task_id = task_id; + //ここでdag_idを設定 + node_info.dag_id = dag_id; } + + // タスクのDAG情報を設定上で設定しているのでここはいらなさそう + task::set_dag_info_by_task_id(task_id, dag_id, task.node_idx.index() as u32); } // To prevent message drops, source reactor is spawned after all subsequent reactors have been spawned. @@ -823,7 +953,12 @@ async fn spawn_dag(dag: &Arc) { let mut graph = dag.graph.lock(&mut node); if let Some(node_info) = graph.node_weight_mut(source_pending_task.node_idx) { node_info.task_id = task_id; + //ここでdag_idを設定 + node_info.dag_id = dag_id; } + + // ソースタスクのDAG情報を設定上で設定しているのでここはいらなさそう + task::set_dag_info_by_task_id(task_id, dag_id, source_pending_task.node_idx.index() as u32); } async fn spawn_reactor( diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index c469e05ac..0c3961715 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -158,6 +158,10 @@ pub struct TaskInfo { pub(crate) need_preemption: bool, panicked: bool, + // DAG関連の情報 + pub(crate) dag_id: Option, // 所属するDAGのID + pub(crate) node_index: Option, // DAG内のノードインデックス + #[cfg(not(feature = "no_preempt"))] thread: Option, } @@ -219,6 +223,49 @@ impl TaskInfo { pub fn panicked(&self) -> bool { self.panicked } + + // DAG関連のメソッド + + /// タスクがDAGに所属しているかを確認：多分いらない + #[inline(always)] + pub fn belongs_to_dag(&self) -> bool { + self.dag_id.is_some() + } + + /// タスクが所属するDAGのIDを取得 + #[inline(always)] + pub fn get_dag_id(&self) -> Option { + self.dag_id + } + + /// タスクがDAG内で占めるノードインデックスを取得 + #[inline(always)] + pub fn get_node_index(&self) -> Option { + self.node_index + } + + /// タスクのDAG情報を設定 + #[inline(always)] + pub fn set_dag_info(&mut self, dag_id: u32, node_index: u32) { + self.dag_id = Some(dag_id); + self.node_index = Some(node_index); + } + + /// タスクのDAG情報をクリア：多分いらない + #[inline(always)] + pub fn clear_dag_info(&mut self) { + self.dag_id = None; + self.node_index = None; + } + + /// タスクのDAG情報を取得（タプル形式） + #[inline(always)] + pub fn get_dag_info(&self) -> Option<(u32, u32)> { + match (self.dag_id, self.node_index) { + (Some(dag_id), Some(node_index)) => Some((dag_id, node_index)), + _ => None, + } + } } /// State of task. @@ -273,6 +320,10 @@ impl Tasks { need_preemption: false, panicked: false, + // DAG関連の情報 + dag_id: None, + node_index: None, + #[cfg(not(feature = "no_preempt"))] thread: None, }); @@ -953,6 +1004,104 @@ pub fn get_absolute_deadline_by_task_id(task_id: u32) -> Option { }) } + +/// タスクIDからrelative_deadlineを取得 +// #[inline(always)] +// pub fn get_relative_deadline_by_task_id(task_id: u32) -> Option { +// let mut node = MCSNode::new(); +// let tasks = TASKS.lock(&mut node); + +// tasks.id_to_task.get(&task_id).and_then(|task| { +// let mut node = MCSNode::new(); +// let info = task.info.lock(&mut node); + +// // タスクがDAGに所属しているかを確認 +// if let Some((dag_id, node_index)) = info.get_dag_info() { +// // DAGに所属している場合、NodeInfoからrelative_deadlineを取得 +// if let Some(dag) = get_dag(dag_id) { +// if let Some(node_info) = dag.get_node_info(NodeIndex::new(node_index as usize)) { +// node_info.relative_deadline +// } else { +// None +// } +// } else { +// None +// } +// } else { +// // DAGに所属していない場合、Noneを返す +// None +// } +// }) +// } + +/// タスクIDからDAG情報を取得 +#[inline(always)] +pub fn get_dag_info_by_task_id(task_id: u32) -> Option<(u32, u32)> { + let mut node = MCSNode::new(); + let tasks = TASKS.lock(&mut node); + + tasks.id_to_task.get(&task_id).and_then(|task| { + let mut node = MCSNode::new(); + let info = task.info.lock(&mut node); + info.get_dag_info() + }) +} + +/// タスクIDからDAG IDを取得 +#[inline(always)] +pub fn get_dag_id_by_task_id(task_id: u32) -> Option { + let mut node = MCSNode::new(); + let tasks = TASKS.lock(&mut node); + + tasks.id_to_task.get(&task_id).and_then(|task| { + let mut node = MCSNode::new(); + let info = task.info.lock(&mut node); + info.get_dag_id() + }) +} + +/// タスクIDからノードインデックスを取得 +#[inline(always)] +pub fn get_node_index_by_task_id(task_id: u32) -> Option { + let mut node = MCSNode::new(); + let tasks = TASKS.lock(&mut node); + + tasks.id_to_task.get(&task_id).and_then(|task| { + let mut node = MCSNode::new(); + let info = task.info.lock(&mut node); + info.get_node_index() + }) +} + +/// タスクがDAGに所属しているかを確認：あってもいいけど二度手間 +#[inline(always)] +pub fn task_belongs_to_dag(task_id: u32) -> bool { + let mut node = MCSNode::new(); + let tasks = TASKS.lock(&mut node); + + tasks.id_to_task.get(&task_id).map_or(false, |task| { + let mut node = MCSNode::new(); + let info = task.info.lock(&mut node); + info.belongs_to_dag() + }) +} + +/// タスクのDAG情報を設定 +#[inline(always)] +pub fn set_dag_info_by_task_id(task_id: u32, dag_id: u32, node_index: u32) -> bool { + let mut node = MCSNode::new(); + let tasks = TASKS.lock(&mut node); + + if let Some(task) = tasks.id_to_task.get(&task_id) { + let mut node = MCSNode::new(); + let mut info = task.info.lock(&mut node); + info.set_dag_info(dag_id, node_index); + true + } else { + false + } +} + #[inline(always)] pub fn set_need_preemption(task_id: u32, cpu_id: usize) { let mut node = MCSNode::new(); From 00518aece0791c4e0ea237f6c65b6c5cd5322c38 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Mon, 18 Aug 2025 11:01:18 +0900 Subject: [PATCH 02/55] test: for develop #2 Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 20 ++++++------- awkernel_async_lib/src/scheduler/gedf.rs | 37 ++++++++++++++++++++++-- 2 files changed, 45 insertions(+), 12 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index a8291776f..53dfb06fc 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -616,17 +616,17 @@ pub fn get_dag(id: u32) -> Option> { // } /// 指定されたtask_idを持つノードを全DAGから検索 -// pub fn find_node_by_task_id_global(task_id: u32) -> Option<(u32, NodeIndex)> { -// let mut node = MCSNode::new(); -// let dags = DAGS.lock(&mut node); +pub fn find_node_by_task_id_global(task_id: u32) -> Option<(u32, NodeIndex)> { + let mut node = MCSNode::new(); + let dags = DAGS.lock(&mut node); -// for (dag_id, dag) in dags.id_to_dag.iter() { -// if let Some(node_idx) = dag.find_node_by_task_id(task_id) { -// return Some((*dag_id, node_idx)); -// } -// } -// None -// } + for (dag_id, dag) in dags.id_to_dag.iter() { + if let Some(node_idx) = dag.find_node_by_task_id(task_id) { + return Some((*dag_id, node_idx)); + } + } + None +} diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 937872785..62848a9f8 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -2,8 +2,9 @@ use super::{Scheduler, SchedulerType, Task}; use crate::{ + dag::{get_dag_absolute_deadline, set_dag_absolute_deadline}, scheduler::get_priority, - task::{get_absolute_deadline_by_task_id, get_tasks_running, set_need_preemption, State}, + task::{get_absolute_deadline_by_task_id, get_dag_id_by_task_id, get_tasks_running, set_need_preemption, State, task_belongs_to_dag}, }; use alloc::{collections::BinaryHeap, sync::Arc}; use awkernel_lib::{ @@ -71,7 +72,39 @@ impl Scheduler for GEDFScheduler { }; let wake_time = awkernel_lib::delay::uptime(); - let absolute_deadline = wake_time + relative_deadline; + let absolute_deadline ; + // DAGに所属している場合 + if let Some(dag_id) = get_dag_id_by_task_id(task.id) {//ここでnode_indexを持ってくる + // DAGの絶対デッドラインを取得 + if let Some(dag_absolute_deadline) = get_dag_absolute_deadline(dag_id) {//今持ってきたnode_indexのidとソースノードのidを比較 + //ではない→if letでDAGの絶対デッドラインを取得 + //if letのelseはunreachable!()でエラーを出す + //ソースノードだった場合：所属しているDAGのsink_nodeの相対デッドライン(DAGの相対デッドライン)を取得→wake+relativeで絶対デッドラインを計算 + //けいさんしたものをDAGの絶対デッドラインとして更新→キューに入れる + + // DAGの絶対デッドラインが既に設定されている場合、それを使用 + absolute_deadline = dag_absolute_deadline; + } else {//周期ごとにdlがかわる→DAGの最初のノードが起き始めた時(wake)が更新タイミング→relativeを足す(101行目) + // DAGの絶対デッドラインが未設定の場合、NodeInfoからrelative_deadlineを取得して計算 + // if let Some(relative_deadline) = get_relative_deadline_by_task_id(task.id) { + // let relative_deadline_ms = relative_deadline.as_millis() as u64; + // absolute_deadline = wake_time + relative_deadline_ms; + // set_dag_absolute_deadline(dag_id, absolute_deadline); + // } else { + // // NodeInfoからrelative_deadlineが取得できない場合（エラーケース） + // // スケジューラータイプから取得したrelative_deadlineを使用 + // let SchedulerType::GEDF(relative_deadline) = info.scheduler_type else { + // unreachable!(); + // }; + // absolute_deadline = wake_time + relative_deadline; + // set_dag_absolute_deadline(dag_id, absolute_deadline); + // } + absolute_deadline = 0; + } + } else { + // DAGに所属していない単一タスクの場合 + absolute_deadline = 0; + } task.priority .update_priority_info(self.priority, absolute_deadline); From dc772c55ee8b87d1b3b966405f1b01b325af0013 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Mon, 18 Aug 2025 12:18:43 +0900 Subject: [PATCH 03/55] test: whether source_nodes or others & modify DAG struct #3 Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 45 +++++++++++++++- awkernel_async_lib/src/scheduler/gedf.rs | 69 ++++++++++++++---------- 2 files changed, 83 insertions(+), 31 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index bdaf58acd..d3fee1fc2 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -193,8 +193,11 @@ impl Dag { let mut node = MCSNode::new(); let graph = self.graph.lock(&mut node); graph.node_weight(node_idx).cloned() + //ここは参照を返す方が良さそう、将来的に変える } + + /// 指定されたtask_idを持つノードを検索 pub fn find_node_by_task_id(&self, task_id: u32) -> Option { let mut node = MCSNode::new(); @@ -220,18 +223,40 @@ impl Dag { graph.node_references().map(|node_ref| (node_ref.id(), node_ref.weight().clone())).collect() } - fn get_source_nodes(&self) -> Vec { + pub fn get_source_nodes(&self) -> Vec { let mut node = MCSNode::new(); let graph = self.graph.lock(&mut node); graph.externals(Direction::Incoming).collect() } - fn get_sink_nodes(&self) -> Vec { + pub fn get_sink_nodes(&self) -> Vec { let mut node = MCSNode::new(); let graph = self.graph.lock(&mut node); graph.externals(Direction::Outgoing).collect() } + /// 指定されたノードインデックスがソースノードかどうかを判定 + pub fn is_source_node(&self, node_index: NodeIndex) -> bool { + let source_nodes = self.get_source_nodes(); + source_nodes.contains(&node_index) + } + + /// 指定されたノードインデックスがシンクノードかどうかを判定 + pub fn is_sink_node(&self, node_index: NodeIndex) -> bool { + let sink_nodes = self.get_sink_nodes(); + sink_nodes.contains(&node_index) + } + + /// このDAGのシンクノードの相対デッドラインを取得 + pub fn get_sink_relative_deadline(&self) -> Option { + let sink_nodes = self.get_sink_nodes(); + if let Some(sink_node_index) = sink_nodes.first() { + self.get_node_info(*sink_node_index)?.get_relative_deadline() + } else { + None + } + } + fn set_relative_deadline(&self, node_idx: NodeIndex, deadline: Duration) { let mut node = MCSNode::new(); let mut graph = self.graph.lock(&mut node); @@ -543,6 +568,22 @@ struct NodeInfo { relative_deadline: Option, } +impl NodeInfo { + /// ノードの相対デッドラインを取得 + pub fn get_relative_deadline(&self) -> Option { + self.relative_deadline + } +} + + + + + +pub fn to_node_index(index: u32) -> NodeIndex { + NodeIndex::new(index as usize) +} + + struct EdgeInfo { topic_name: Cow<'static, str>, } diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 62848a9f8..687dd0d92 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -2,9 +2,9 @@ use super::{Scheduler, SchedulerType, Task}; use crate::{ - dag::{get_dag_absolute_deadline, set_dag_absolute_deadline}, + dag::{get_dag_absolute_deadline, set_dag_absolute_deadline, get_dag, to_node_index}, scheduler::get_priority, - task::{get_absolute_deadline_by_task_id, get_dag_id_by_task_id, get_tasks_running, set_need_preemption, State, task_belongs_to_dag}, + task::{get_absolute_deadline_by_task_id, get_dag_id_by_task_id, get_tasks_running, set_need_preemption, State, task_belongs_to_dag, get_dag_info_by_task_id}, }; use alloc::{collections::BinaryHeap, sync::Arc}; use awkernel_lib::{ @@ -12,6 +12,8 @@ use awkernel_lib::{ sync::mutex::{MCSNode, Mutex}, }; + + pub struct GEDFScheduler { data: Mutex>, // Run queue. priority: u8, @@ -74,36 +76,45 @@ impl Scheduler for GEDFScheduler { let wake_time = awkernel_lib::delay::uptime(); let absolute_deadline ; // DAGに所属している場合 - if let Some(dag_id) = get_dag_id_by_task_id(task.id) {//ここでnode_indexを持ってくる - // DAGの絶対デッドラインを取得 - if let Some(dag_absolute_deadline) = get_dag_absolute_deadline(dag_id) {//今持ってきたnode_indexのidとソースノードのidを比較 - //ではない→if letでDAGの絶対デッドラインを取得 - //if letのelseはunreachable!()でエラーを出す - //ソースノードだった場合：所属しているDAGのsink_nodeの相対デッドライン(DAGの相対デッドライン)を取得→wake+relativeで絶対デッドラインを計算 - //けいさんしたものをDAGの絶対デッドラインとして更新→キューに入れる - - // DAGの絶対デッドラインが既に設定されている場合、それを使用 - absolute_deadline = dag_absolute_deadline; - } else {//周期ごとにdlがかわる→DAGの最初のノードが起き始めた時(wake)が更新タイミング→relativeを足す(101行目) - // DAGの絶対デッドラインが未設定の場合、NodeInfoからrelative_deadlineを取得して計算 - // if let Some(relative_deadline) = get_relative_deadline_by_task_id(task.id) { - // let relative_deadline_ms = relative_deadline.as_millis() as u64; - // absolute_deadline = wake_time + relative_deadline_ms; - // set_dag_absolute_deadline(dag_id, absolute_deadline); - // } else { - // // NodeInfoからrelative_deadlineが取得できない場合（エラーケース） - // // スケジューラータイプから取得したrelative_deadlineを使用 - // let SchedulerType::GEDF(relative_deadline) = info.scheduler_type else { - // unreachable!(); - // }; - // absolute_deadline = wake_time + relative_deadline; - // set_dag_absolute_deadline(dag_id, absolute_deadline); - // } - absolute_deadline = 0; + if let Some((dag_id, node_index)) = get_dag_info_by_task_id(task.id) { + // DAGを取得してソースノードかどうかを判定 + if let Some(dag) = get_dag(dag_id) { + //u32-->nodeindex + let current_node_index = to_node_index(node_index); + let is_source_node = dag.is_source_node(current_node_index); + + if is_source_node { + // ソースノードの場合：DAGのsink_nodeの相対デッドラインを取得して絶対デッドラインを計算 + // DAGの絶対デッドラインを更新してキューに入れる + let sink_relative_deadline = dag.get_sink_relative_deadline(); + + // relative_deadlineが設定されている場合はそれを使用、そうでなければスケジューラータイプから取得 + let relative_deadline_ms = if let Some(deadline) = sink_relative_deadline { + deadline.as_millis() as u64 + } else { + relative_deadline + }; + + absolute_deadline = wake_time + relative_deadline_ms; + set_dag_absolute_deadline(dag_id, absolute_deadline); + } else { + // ソースノードではない場合：DAGの絶対デッドラインを取得 + if let Some(dag_absolute_deadline) = get_dag_absolute_deadline(dag_id) { + // DAGの絶対デッドラインが既に設定されている場合、それを使用 + absolute_deadline = dag_absolute_deadline; + } else { + // DAGの絶対デッドラインが未設定の場合（エラーケース） + // 最初は絶対デッドラインが未設定なので必ずここに来る→この部分の処理を考える：最初の周期だけ + unreachable!(); + } + } + } else { + // DAGが見つからない場合（エラーケース） + unreachable!(); } } else { // DAGに所属していない単一タスクの場合 - absolute_deadline = 0; + absolute_deadline = wake_time + relative_deadline; } task.priority From 5b645fd54eeab5d48b98fc414490c5a44e1479da Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Mon, 18 Aug 2025 12:53:07 +0900 Subject: [PATCH 04/55] test: add else process for initial period #4 Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 5 +++++ awkernel_async_lib/src/scheduler/gedf.rs | 16 ++++++++++++---- 2 files changed, 17 insertions(+), 4 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index d3fee1fc2..34fc35900 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -257,6 +257,11 @@ impl Dag { } } + /// 指定されたノードの相対デッドラインを取得 + pub fn get_node_relative_deadline(&self, node_idx: NodeIndex) -> Option { + self.get_node_info(node_idx)?.get_relative_deadline() + } + fn set_relative_deadline(&self, node_idx: NodeIndex, deadline: Duration) { let mut node = MCSNode::new(); let mut graph = self.graph.lock(&mut node); diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 687dd0d92..c6b368c86 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -4,7 +4,7 @@ use super::{Scheduler, SchedulerType, Task}; use crate::{ dag::{get_dag_absolute_deadline, set_dag_absolute_deadline, get_dag, to_node_index}, scheduler::get_priority, - task::{get_absolute_deadline_by_task_id, get_dag_id_by_task_id, get_tasks_running, set_need_preemption, State, task_belongs_to_dag, get_dag_info_by_task_id}, + task::{get_absolute_deadline_by_task_id, get_tasks_running, set_need_preemption, State, get_dag_info_by_task_id}, }; use alloc::{collections::BinaryHeap, sync::Arc}; use awkernel_lib::{ @@ -103,9 +103,17 @@ impl Scheduler for GEDFScheduler { // DAGの絶対デッドラインが既に設定されている場合、それを使用 absolute_deadline = dag_absolute_deadline; } else { - // DAGの絶対デッドラインが未設定の場合（エラーケース） - // 最初は絶対デッドラインが未設定なので必ずここに来る→この部分の処理を考える：最初の周期だけ - unreachable!(); + // DAGの絶対デッドラインが未設定の場合（最初の周期） + // このタスクの相対デッドラインを使用して一時的な絶対デッドラインを設定 + // これにより、DAG全体の一貫性を保ちながら適切な優先度スケジューリングを実現 + + // DAGノードの相対デッドラインを取得 + let dag_relative_deadline = dag.get_node_relative_deadline(current_node_index) + .map(|deadline| deadline.as_millis() as u64) + .unwrap_or(1000); // デフォルト値: 1秒 + + absolute_deadline = wake_time + dag_relative_deadline; + set_dag_absolute_deadline(dag_id, absolute_deadline); } } } else { From 4be6763371c0a712c410169b7714eef060901dbf Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 21 Aug 2025 10:38:36 +0900 Subject: [PATCH 05/55] test: absolute deadline setting #5 Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 38 +++++++++--------------- 1 file changed, 14 insertions(+), 24 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index c6b368c86..d606a1827 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -80,41 +80,31 @@ impl Scheduler for GEDFScheduler { // DAGを取得してソースノードかどうかを判定 if let Some(dag) = get_dag(dag_id) { //u32-->nodeindex - let current_node_index = to_node_index(node_index); - let is_source_node = dag.is_source_node(current_node_index); + // let current_node_index = to_node_index(node_index); + // let is_source_node = dag.is_source_node(current_node_index); - if is_source_node { - // ソースノードの場合：DAGのsink_nodeの相対デッドラインを取得して絶対デッドラインを計算 - // DAGの絶対デッドラインを更新してキューに入れる + // DAGの絶対デッドラインを取得 + if let Some(dag_absolute_deadline) = get_dag_absolute_deadline(dag_id) { + // DAGの絶対デッドラインが既に設定されている場合、それを使用 + absolute_deadline = dag_absolute_deadline; + } else { + // DAGの絶対デッドラインが未設定の場合（最初の周期） + // 最初にwakeしたノードがDAG全体の周期を決定 + + // DAGのsink_nodeの相対デッドラインを取得して周期を決定 let sink_relative_deadline = dag.get_sink_relative_deadline(); - // relative_deadlineが設定されている場合はそれを使用、そうでなければスケジューラータイプから取得 + // sink_nodeの相対デッドラインが設定されている場合はそれを使用、 + // そうでなければスケジューラータイプから取得→後で消去 let relative_deadline_ms = if let Some(deadline) = sink_relative_deadline { deadline.as_millis() as u64 } else { relative_deadline }; + // 絶対デッドラインを計算してDAGに設定 absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, absolute_deadline); - } else { - // ソースノードではない場合：DAGの絶対デッドラインを取得 - if let Some(dag_absolute_deadline) = get_dag_absolute_deadline(dag_id) { - // DAGの絶対デッドラインが既に設定されている場合、それを使用 - absolute_deadline = dag_absolute_deadline; - } else { - // DAGの絶対デッドラインが未設定の場合（最初の周期） - // このタスクの相対デッドラインを使用して一時的な絶対デッドラインを設定 - // これにより、DAG全体の一貫性を保ちながら適切な優先度スケジューリングを実現 - - // DAGノードの相対デッドラインを取得 - let dag_relative_deadline = dag.get_node_relative_deadline(current_node_index) - .map(|deadline| deadline.as_millis() as u64) - .unwrap_or(1000); // デフォルト値: 1秒 - - absolute_deadline = wake_time + dag_relative_deadline; - set_dag_absolute_deadline(dag_id, absolute_deadline); - } } } else { // DAGが見つからない場合（エラーケース） From 555ead5ebb239febfd88adc63af21e626fe3d23c Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 21 Aug 2025 10:58:13 +0900 Subject: [PATCH 06/55] fix: absolute deadline setting #6 Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 175 +++++++++++++---------- 1 file changed, 101 insertions(+), 74 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index d606a1827..515f721ae 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -63,69 +63,82 @@ impl GEDFData { impl Scheduler for GEDFScheduler { fn wake_task(&self, task: Arc) { let mut node = MCSNode::new(); + // The reason for acquiring this lock before invoke_preemption() is to prevent priority inversion from occurring + // when invoke_preemption() is executed between the time the next task is determined and the RUNNING is updated + // within the scheduler's get_next(). let mut data = self.data.lock(&mut node); - let data = data.get_or_insert_with(GEDFData::new); + let internal_data = data.get_or_insert_with(GEDFData::new); - let mut node = MCSNode::new(); - let mut info = task.info.lock(&mut node); - - let SchedulerType::GEDF(relative_deadline) = info.scheduler_type else { - unreachable!(); - }; - - let wake_time = awkernel_lib::delay::uptime(); - let absolute_deadline ; - // DAGに所属している場合 - if let Some((dag_id, node_index)) = get_dag_info_by_task_id(task.id) { - // DAGを取得してソースノードかどうかを判定 - if let Some(dag) = get_dag(dag_id) { - //u32-->nodeindex - // let current_node_index = to_node_index(node_index); - // let is_source_node = dag.is_source_node(current_node_index); - - // DAGの絶対デッドラインを取得 - if let Some(dag_absolute_deadline) = get_dag_absolute_deadline(dag_id) { - // DAGの絶対デッドラインが既に設定されている場合、それを使用 - absolute_deadline = dag_absolute_deadline; - } else { - // DAGの絶対デッドラインが未設定の場合（最初の周期） - // 最初にwakeしたノードがDAG全体の周期を決定 - - // DAGのsink_nodeの相対デッドラインを取得して周期を決定 - let sink_relative_deadline = dag.get_sink_relative_deadline(); - - // sink_nodeの相対デッドラインが設定されている場合はそれを使用、 - // そうでなければスケジューラータイプから取得→後で消去 - let relative_deadline_ms = if let Some(deadline) = sink_relative_deadline { - deadline.as_millis() as u64 + let mut data = self.data.lock(&mut node); + let internal_data = data.get_or_insert_with(GEDFData::new); + + let (wake_time, absolute_deadline) = { + let mut node_inner = MCSNode::new(); + let mut info = task.info.lock(&mut node_inner); + match info.scheduler_type { + SchedulerType::GEDF(relative_deadline) => { + let wake_time = awkernel_lib::delay::uptime(); + let absolute_deadline = wake_time + relative_deadline; + // DAGに所属している場合 + if let Some((dag_id, node_index)) = get_dag_info_by_task_id(task.id) { + // DAGを取得してソースノードかどうかを判定 + if let Some(dag) = get_dag(dag_id) { + //u32-->nodeindex + // let current_node_index = to_node_index(node_index); + // let is_source_node = dag.is_source_node(current_node_index); + + // DAGの絶対デッドラインを取得 + if let Some(dag_absolute_deadline) = get_dag_absolute_deadline(dag_id) { + // DAGの絶対デッドラインが既に設定されている場合、それを使用 + absolute_deadline = dag_absolute_deadline; + } else { + // DAGの絶対デッドラインが未設定の場合（最初の周期） + // 最初にwakeしたノードがDAG全体の周期を決定 + + // DAGのsink_nodeの相対デッドラインを取得して周期を決定 + let sink_relative_deadline = dag.get_sink_relative_deadline(); + + // sink_nodeの相対デッドラインが設定されている場合はそれを使用、 + // そうでなければスケジューラータイプから取得→後で消去 + let relative_deadline_ms = if let Some(deadline) = sink_relative_deadline { + deadline.as_millis() as u64 + } else { + relative_deadline + }; + + // 絶対デッドラインを計算してDAGに設定 + absolute_deadline = wake_time + relative_deadline_ms; + set_dag_absolute_deadline(dag_id, absolute_deadline); + } + } else { + // DAGが見つからない場合（エラーケース） + unreachable!(); + } } else { - relative_deadline - }; - - // 絶対デッドラインを計算してDAGに設定 - absolute_deadline = wake_time + relative_deadline_ms; - set_dag_absolute_deadline(dag_id, absolute_deadline); + // DAGに所属していない単一タスクの場合 + absolute_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) } - } else { - // DAGが見つからない場合（エラーケース） - unreachable!(); + _ => unreachable!(), } - } else { - // DAGに所属していない単一タスクの場合 - absolute_deadline = wake_time + relative_deadline; - } + }; task.priority .update_priority_info(self.priority, absolute_deadline); info.update_absolute_deadline(absolute_deadline); - data.queue.push(GEDFTask { - task: task.clone(), - absolute_deadline, - wake_time, - }); - - self.invoke_preemption(absolute_deadline); + if !self.invoke_preemption(task.clone()) { + internal_data.queue.push(GEDFTask { + task: task.clone(), + absolute_deadline, + wake_time, + }); + } } fn get_next(&self) -> Option> { @@ -177,29 +190,43 @@ pub static SCHEDULER: GEDFScheduler = GEDFScheduler { impl GEDFScheduler { fn invoke_preemption(&self, absolute_deadline: u64) { - // Get running tasks and filter out tasks with task_id == 0. - let mut tasks = get_tasks_running(); - tasks.retain(|task| task.task_id != 0); - - // If the number of running tasks is less than the number of non-primary CPUs, preempt is not required. - let num_non_primary_cpus = num_cpu() - 1; - if tasks.len() < num_non_primary_cpus { - return; - } - - let task_with_max_deadline = tasks - .iter() - .filter_map(|task| { - get_absolute_deadline_by_task_id(task.task_id).map(|deadline| (task, deadline)) - }) - .max_by_key(|&(_, deadline)| deadline); - - if let Some((task, max_absolute_deadline)) = task_with_max_deadline { - if max_absolute_deadline > absolute_deadline { + fn invoke_preemption(&self, task: Arc) -> bool { + 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 > target_task { + push_preemption_pending(target_cpu, task); let preempt_irq = awkernel_lib::interrupt::get_preempt_irq(); - set_need_preemption(task.task_id, task.cpu_id); - awkernel_lib::interrupt::send_ipi(preempt_irq, task.cpu_id as u32); + 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 } } } From b6cd0566db2c7a713292d00f83587ab5aa314802 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 21 Aug 2025 15:44:04 +0900 Subject: [PATCH 07/55] fix absolute deadline #7 Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 32c06bc03..f79c222fc 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -80,7 +80,7 @@ impl Scheduler for GEDFScheduler { match info.scheduler_type { SchedulerType::GEDF(relative_deadline) => { let wake_time = awkernel_lib::delay::uptime(); - let mut absolute_deadline = wake_time + relative_deadline; + let absolute_deadline ; // DAGに所属している場合 if let Some((dag_id, node_index)) = get_dag_info_by_task_id(task.id) { // DAGを取得してソースノードかどうかを判定 From 785c02fbbac44a906361f74f5e4f6156595e802b Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Fri, 22 Aug 2025 20:20:25 +0900 Subject: [PATCH 08/55] test: change gedf.rs #8 Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 60 ++++++++++++------------ 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 1753b031b..643524f84 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -4,20 +4,15 @@ use core::cmp::max; use super::{Scheduler, SchedulerType, Task}; use crate::{ - dag::{get_dag_absolute_deadline, set_dag_absolute_deadline, get_dag, to_node_index}, scheduler::{get_priority, peek_preemption_pending, push_preemption_pending}, task::{ - get_absolute_deadline_by_task_id, get_task, get_tasks_running, set_current_task, set_need_preemption, State, - get_dag_info_by_task_id, MAX_TASK_PRIORITY, + get_task, get_tasks_running, set_current_task, set_need_preemption, State, + MAX_TASK_PRIORITY, get_dag_info_by_task_id }, + dag::{get_dag_absolute_deadline, set_dag_absolute_deadline, get_dag, to_node_index}, }; use alloc::{collections::BinaryHeap, sync::Arc, vec::Vec}; -use awkernel_lib::{ - cpu::num_cpu, - sync::mutex::{MCSNode, Mutex}, -}; - - +use awkernel_lib::sync::mutex::{MCSNode, Mutex}; pub struct GEDFScheduler { data: Mutex>, // Run queue. @@ -83,23 +78,12 @@ impl Scheduler for GEDFScheduler { let absolute_deadline ; // DAGに所属している場合 if let Some((dag_id, node_index)) = get_dag_info_by_task_id(task.id) { - // DAGを取得してソースノードかどうかを判定 - if let Some(dag) = get_dag(dag_id) { - //u32-->nodeindex - // let current_node_index = to_node_index(node_index); - // let is_source_node = dag.is_source_node(current_node_index); - - // DAGの絶対デッドラインを取得 - if let Some(dag_absolute_deadline) = get_dag_absolute_deadline(dag_id) { - // DAGの絶対デッドラインが既に設定されている場合、それを使用 - absolute_deadline = dag_absolute_deadline; - } else { - // DAGの絶対デッドラインが未設定の場合（最初の周期） - // 最初にwakeしたノードがDAG全体の周期を決定 - - // DAGのsink_nodeの相対デッドラインを取得して周期を決定 + // DAGの絶対デッドラインを取得 + if get_dag_absolute_deadline(dag_id).is_none() { + // DAGの絶対デッドラインが設定されていない場合（1周期目） + // DAGを取得してsinkノードの相対デッドラインを取得 + if let Some(dag) = get_dag(dag_id) { let sink_relative_deadline = dag.get_sink_relative_deadline(); - // sink_nodeの相対デッドラインが設定されている場合はそれを使用、 // そうでなければスケジューラータイプから取得→後で消去 let relative_deadline_ms = if let Some(deadline) = sink_relative_deadline { @@ -107,28 +91,44 @@ impl Scheduler for GEDFScheduler { } else { relative_deadline }; - // 絶対デッドラインを計算してDAGに設定 absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, absolute_deadline); - } + } else { + // DAGが見つからない場合（エラーケース） + unreachable!(); + } } else { - // DAGが見つからない場合（エラーケース） - unreachable!(); + // DAGの絶対デッドラインが既に設定されている場合（2周期以降）、ソースノード以外ならそれを使用 + if let Some(dag) = get_dag(dag_id){ + // u32-->nodeindex + let current_node_index = to_node_index(node_index); + let is_source_node = dag.is_source_node(current_node_index); + if is_source_node { + absolute_deadline = wake_time + relative_deadline; + } else { + absolute_deadline = get_dag_absolute_deadline(dag_id).unwrap(); + } + } else { + // DAGが見つからない場合（エラーケース） + unreachable!(); + } } } else { // DAGに所属していない単一タスクの場合 absolute_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!(), } }; + if !self.invoke_preemption(task.clone()) { internal_data.queue.push(GEDFTask { task: task.clone(), From 68ea963555d5fe6dbb883715f374aea7ef9132a7 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Fri, 22 Aug 2025 20:51:14 +0900 Subject: [PATCH 09/55] test: change gedf.rs #9 Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 643524f84..d732f4d10 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -99,13 +99,25 @@ impl Scheduler for GEDFScheduler { unreachable!(); } } else { - // DAGの絶対デッドラインが既に設定されている場合（2周期以降）、ソースノード以外ならそれを使用 + // DAGの絶対デッドラインが既に設定されている場合（2周期以降）、ソースノードかどうか判定 if let Some(dag) = get_dag(dag_id){ // u32-->nodeindex let current_node_index = to_node_index(node_index); let is_source_node = dag.is_source_node(current_node_index); + //ソースノードの場合：sink node の相対デッドラインを取得 + wake time = 絶対デッドラインを計算し、DAGにset、source node自身もその絶対デッドラインを優先度として使用 + //それ以外の場合：DAGに絶対デッドラインがあるはずなのでそれを取得して優先度として使用する if is_source_node { - absolute_deadline = wake_time + relative_deadline; + let sink_relative_deadline = dag.get_sink_relative_deadline(); + // sink_nodeの相対デッドラインが設定されている場合はそれを使用、 + // そうでなければスケジューラータイプから取得→後で消去 + let relative_deadline_ms = if let Some(deadline) = sink_relative_deadline { + deadline.as_millis() as u64 + } else { + relative_deadline + }; + // 絶対デッドラインを計算してDAGに設定 + absolute_deadline = wake_time + relative_deadline_ms; + set_dag_absolute_deadline(dag_id, absolute_deadline); } else { absolute_deadline = get_dag_absolute_deadline(dag_id).unwrap(); } From 85ba2f8961362e971e498f2f02f749be0a0db8b1 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Wed, 27 Aug 2025 10:22:54 +0900 Subject: [PATCH 10/55] fix: delete unnecessary code Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 9 ------ awkernel_async_lib/src/task.rs | 56 ---------------------------------- 2 files changed, 65 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 34fc35900..5910d4ebd 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -511,15 +511,6 @@ impl Dag { } } - // タスクのDAG情報を取得（タプル形式） - #[inline(always)] - pub fn get_dag_info(&self, node_idx: NodeIndex) -> Option<(u32, u32)> { - match (self.get_id(), self.get_node_info(node_idx)) { - (dag_id, Some(node_info)) => Some((dag_id, node_info.task_id)), - _ => None, - } - } - // DAG絶対デッドライン管理メソッド // DAGの絶対デッドラインを設定 diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 04b783581..e39bf6c10 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -226,12 +226,6 @@ impl TaskInfo { // DAG関連のメソッド - /// タスクがDAGに所属しているかを確認：多分いらない - #[inline(always)] - pub fn belongs_to_dag(&self) -> bool { - self.dag_id.is_some() - } - /// タスクが所属するDAGのIDを取得 #[inline(always)] pub fn get_dag_id(&self) -> Option { @@ -251,13 +245,6 @@ impl TaskInfo { self.node_index = Some(node_index); } - /// タスクのDAG情報をクリア：多分いらない - #[inline(always)] - pub fn clear_dag_info(&mut self) { - self.dag_id = None; - self.node_index = None; - } - /// タスクのDAG情報を取得（タプル形式） #[inline(always)] pub fn get_dag_info(&self) -> Option<(u32, u32)> { @@ -1007,36 +994,6 @@ pub fn get_absolute_deadline_by_task_id(task_id: u32) -> Option { }) } - -/// タスクIDからrelative_deadlineを取得 -// #[inline(always)] -// pub fn get_relative_deadline_by_task_id(task_id: u32) -> Option { -// let mut node = MCSNode::new(); -// let tasks = TASKS.lock(&mut node); - -// tasks.id_to_task.get(&task_id).and_then(|task| { -// let mut node = MCSNode::new(); -// let info = task.info.lock(&mut node); - -// // タスクがDAGに所属しているかを確認 -// if let Some((dag_id, node_index)) = info.get_dag_info() { -// // DAGに所属している場合、NodeInfoからrelative_deadlineを取得 -// if let Some(dag) = get_dag(dag_id) { -// if let Some(node_info) = dag.get_node_info(NodeIndex::new(node_index as usize)) { -// node_info.relative_deadline -// } else { -// None -// } -// } else { -// None -// } -// } else { -// // DAGに所属していない場合、Noneを返す -// None -// } -// }) -// } - /// タスクIDからDAG情報を取得 #[inline(always)] pub fn get_dag_info_by_task_id(task_id: u32) -> Option<(u32, u32)> { @@ -1076,19 +1033,6 @@ pub fn get_node_index_by_task_id(task_id: u32) -> Option { }) } -/// タスクがDAGに所属しているかを確認：あってもいいけど二度手間 -#[inline(always)] -pub fn task_belongs_to_dag(task_id: u32) -> bool { - let mut node = MCSNode::new(); - let tasks = TASKS.lock(&mut node); - - tasks.id_to_task.get(&task_id).map_or(false, |task| { - let mut node = MCSNode::new(); - let info = task.info.lock(&mut node); - info.belongs_to_dag() - }) -} - /// タスクのDAG情報を設定 #[inline(always)] pub fn set_dag_info_by_task_id(task_id: u32, dag_id: u32, node_index: u32) -> bool { From 4a57f81197b6941543792f6d23401fffabe1bdea Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Wed, 27 Aug 2025 10:49:05 +0900 Subject: [PATCH 11/55] fix: modify get_node_info and etc Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 29 +++++++++++++---------------- awkernel_async_lib/src/task.rs | 26 -------------------------- 2 files changed, 13 insertions(+), 42 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 5910d4ebd..7e59094bc 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -180,24 +180,23 @@ impl Dag { self.id } - /// 引数のnode_idxが今動かしているDAGに所属しているか - /// 将来的にいらなさそう - // pub fn get_node_dag_id(&self, node_idx: NodeIndex) -> Option { + /// 指定されたノードの情報を取得（従来のクローン版） + // pub fn get_node_info(&self, node_idx: NodeIndex) -> Option { // let mut node = MCSNode::new(); // let graph = self.graph.lock(&mut node); - // graph.node_weight(node_idx).map(|node_info| node_info.dag_id) + // graph.node_weight(node_idx).cloned() // } - /// 指定されたノードの情報を取得 - pub fn get_node_info(&self, node_idx: NodeIndex) -> Option { + /// 指定されたノードの情報を取得（コールバック版） + pub fn with_node_info(&self, node_idx: NodeIndex, f: F) -> Option + where + F: FnOnce(&NodeInfo) -> R, + { let mut node = MCSNode::new(); let graph = self.graph.lock(&mut node); - graph.node_weight(node_idx).cloned() - //ここは参照を返す方が良さそう、将来的に変える + graph.node_weight(node_idx).map(f) } - - /// 指定されたtask_idを持つノードを検索 pub fn find_node_by_task_id(&self, task_id: u32) -> Option { let mut node = MCSNode::new(); @@ -251,7 +250,7 @@ impl Dag { pub fn get_sink_relative_deadline(&self) -> Option { let sink_nodes = self.get_sink_nodes(); if let Some(sink_node_index) = sink_nodes.first() { - self.get_node_info(*sink_node_index)?.get_relative_deadline() + self.with_node_info(*sink_node_index, |info| info.get_relative_deadline())? } else { None } @@ -259,7 +258,7 @@ impl Dag { /// 指定されたノードの相対デッドラインを取得 pub fn get_node_relative_deadline(&self, node_idx: NodeIndex) -> Option { - self.get_node_info(node_idx)?.get_relative_deadline() + self.with_node_info(node_idx, |info| info.get_relative_deadline())? } fn set_relative_deadline(&self, node_idx: NodeIndex, deadline: Duration) { @@ -275,7 +274,6 @@ impl Dag { ) -> NodeIndex { let add_node_info = NodeInfo { task_id: 0, // Temporary task_id - dag_id: self.id, subscribe_topic_names: subscribe_topic_names.to_vec(), publish_topic_names: publish_topic_names.to_vec(), relative_deadline: None, @@ -558,7 +556,6 @@ impl PendingTask { #[derive(Clone)] struct NodeInfo { task_id: u32, - dag_id: u32, // どのDAGからspawnされたかを示す：多分いらない、taskinfoの方にdag_idが必要 subscribe_topic_names: Vec>, publish_topic_names: Vec>, relative_deadline: Option, @@ -971,7 +968,7 @@ async fn spawn_dag(dag: &Arc) { if let Some(node_info) = graph.node_weight_mut(task.node_idx) { node_info.task_id = task_id; //ここでdag_idを設定 - node_info.dag_id = dag_id; + // node_info.dag_id = dag_id; } // タスクのDAG情報を設定上で設定しているのでここはいらなさそう @@ -992,7 +989,7 @@ async fn spawn_dag(dag: &Arc) { if let Some(node_info) = graph.node_weight_mut(source_pending_task.node_idx) { node_info.task_id = task_id; //ここでdag_idを設定 - node_info.dag_id = dag_id; + // node_info.dag_id = dag_id; } // ソースタスクのDAG情報を設定上で設定しているのでここはいらなさそう diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index e39bf6c10..10f15ba70 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -1007,32 +1007,6 @@ pub fn get_dag_info_by_task_id(task_id: u32) -> Option<(u32, u32)> { }) } -/// タスクIDからDAG IDを取得 -#[inline(always)] -pub fn get_dag_id_by_task_id(task_id: u32) -> Option { - let mut node = MCSNode::new(); - let tasks = TASKS.lock(&mut node); - - tasks.id_to_task.get(&task_id).and_then(|task| { - let mut node = MCSNode::new(); - let info = task.info.lock(&mut node); - info.get_dag_id() - }) -} - -/// タスクIDからノードインデックスを取得 -#[inline(always)] -pub fn get_node_index_by_task_id(task_id: u32) -> Option { - let mut node = MCSNode::new(); - let tasks = TASKS.lock(&mut node); - - tasks.id_to_task.get(&task_id).and_then(|task| { - let mut node = MCSNode::new(); - let info = task.info.lock(&mut node); - info.get_node_index() - }) -} - /// タスクのDAG情報を設定 #[inline(always)] pub fn set_dag_info_by_task_id(task_id: u32, dag_id: u32, node_index: u32) -> bool { From f0fef01865e915c78fab090dedcd78dec317194b Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Wed, 27 Aug 2025 10:51:51 +0900 Subject: [PATCH 12/55] fix: change function name Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 7e59094bc..765f04fc5 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -188,7 +188,7 @@ impl Dag { // } /// 指定されたノードの情報を取得（コールバック版） - pub fn with_node_info(&self, node_idx: NodeIndex, f: F) -> Option + pub fn get_node_info(&self, node_idx: NodeIndex, f: F) -> Option where F: FnOnce(&NodeInfo) -> R, { @@ -250,7 +250,7 @@ impl Dag { pub fn get_sink_relative_deadline(&self) -> Option { let sink_nodes = self.get_sink_nodes(); if let Some(sink_node_index) = sink_nodes.first() { - self.with_node_info(*sink_node_index, |info| info.get_relative_deadline())? + self.get_node_info(*sink_node_index, |info| info.get_relative_deadline())? } else { None } @@ -258,7 +258,7 @@ impl Dag { /// 指定されたノードの相対デッドラインを取得 pub fn get_node_relative_deadline(&self, node_idx: NodeIndex) -> Option { - self.with_node_info(node_idx, |info| info.get_relative_deadline())? + self.get_node_info(node_idx, |info| info.get_relative_deadline())? } fn set_relative_deadline(&self, node_idx: NodeIndex, deadline: Duration) { From 4f27a2e1d3e788604bb583c0d31e6ae3924c327f Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Fri, 29 Aug 2025 13:24:53 +0900 Subject: [PATCH 13/55] fix: organizing comments & modify else handling Signed-off-by: nokosaaan --- applications/tests/test_dag/src/lib.rs | 2 +- awkernel_async_lib/src/dag.rs | 108 ++--------------------- awkernel_async_lib/src/scheduler.rs | 3 + awkernel_async_lib/src/scheduler/gedf.rs | 65 ++++++++++---- awkernel_async_lib/src/task.rs | 16 +--- 5 files changed, 62 insertions(+), 132 deletions(-) diff --git a/applications/tests/test_dag/src/lib.rs b/applications/tests/test_dag/src/lib.rs index 7e799f694..9ec1646be 100644 --- a/applications/tests/test_dag/src/lib.rs +++ b/applications/tests/test_dag/src/lib.rs @@ -7,7 +7,7 @@ use awkernel_async_lib::scheduler::SchedulerType; use awkernel_lib::delay::wait_microsec; use core::time::Duration; -const LOG_ENABLE: bool = false; +const LOG_ENABLE: bool = true; pub async fn run() { wait_microsec(1000000); diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 765f04fc5..1653e73c2 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -169,7 +169,7 @@ impl core::fmt::Display for DagError { pub struct Dag { id: u32, graph: Mutex>, - absolute_deadline: Mutex>, // DAG全体の絶対デッドライン + absolute_deadline: Mutex>, #[cfg(feature = "perf")] response_info: Mutex, @@ -180,42 +180,12 @@ impl Dag { self.id } - /// 指定されたノードの情報を取得（従来のクローン版） - // pub fn get_node_info(&self, node_idx: NodeIndex) -> Option { - // let mut node = MCSNode::new(); - // let graph = self.graph.lock(&mut node); - // graph.node_weight(node_idx).cloned() - // } - - /// 指定されたノードの情報を取得（コールバック版） - pub fn get_node_info(&self, node_idx: NodeIndex, f: F) -> Option - where - F: FnOnce(&NodeInfo) -> R, - { - let mut node = MCSNode::new(); - let graph = self.graph.lock(&mut node); - graph.node_weight(node_idx).map(f) - } - - /// 指定されたtask_idを持つノードを検索 - pub fn find_node_by_task_id(&self, task_id: u32) -> Option { - let mut node = MCSNode::new(); - let graph = self.graph.lock(&mut node); - graph.node_indices().find(|&idx| { - graph.node_weight(idx) - .map(|node_info| node_info.task_id == task_id) - .unwrap_or(false) - }) - } - - /// このDAGに属するすべてのノードのインデックスを取得 pub fn get_all_node_indices(&self) -> Vec { let mut node = MCSNode::new(); let graph = self.graph.lock(&mut node); graph.node_indices().collect() } - /// このDAGに属するすべてのノードの情報を取得 pub fn get_all_node_infos(&self) -> Vec<(NodeIndex, NodeInfo)> { let mut node = MCSNode::new(); let graph = self.graph.lock(&mut node); @@ -234,31 +204,32 @@ impl Dag { graph.externals(Direction::Outgoing).collect() } - /// 指定されたノードインデックスがソースノードかどうかを判定 pub fn is_source_node(&self, node_index: NodeIndex) -> bool { let source_nodes = self.get_source_nodes(); source_nodes.contains(&node_index) } - /// 指定されたノードインデックスがシンクノードかどうかを判定 pub fn is_sink_node(&self, node_index: NodeIndex) -> bool { let sink_nodes = self.get_sink_nodes(); sink_nodes.contains(&node_index) } - /// このDAGのシンクノードの相対デッドラインを取得 pub fn get_sink_relative_deadline(&self) -> Option { - let sink_nodes = self.get_sink_nodes(); + let mut node = MCSNode::new(); + let graph = self.graph.lock(&mut node); + let sink_nodes: Vec = graph.externals(Direction::Outgoing).collect(); + if let Some(sink_node_index) = sink_nodes.first() { - self.get_node_info(*sink_node_index, |info| info.get_relative_deadline())? + graph.node_weight(*sink_node_index)?.relative_deadline } else { None } } - /// 指定されたノードの相対デッドラインを取得 pub fn get_node_relative_deadline(&self, node_idx: NodeIndex) -> Option { - self.get_node_info(node_idx, |info| info.get_relative_deadline())? + let mut node = MCSNode::new(); + let graph = self.graph.lock(&mut node); + graph.node_weight(node_idx)?.relative_deadline } fn set_relative_deadline(&self, node_idx: NodeIndex, deadline: Duration) { @@ -509,9 +480,6 @@ impl Dag { } } - // DAG絶対デッドライン管理メソッド - - // DAGの絶対デッドラインを設定 #[inline(always)] pub fn set_absolute_deadline(&self, deadline: u64) { let mut node = MCSNode::new(); @@ -519,7 +487,6 @@ impl Dag { *absolute_deadline = Some(deadline); } - // DAGの絶対デッドラインを取得 #[inline(always)] pub fn get_absolute_deadline(&self) -> Option { let mut node = MCSNode::new(); @@ -527,13 +494,6 @@ impl Dag { *absolute_deadline } - // DAGの絶対デッドラインをクリア：多分いらない - // #[inline(always)] - // pub fn clear_absolute_deadline(&self) { - // let mut node = MCSNode::new(); - // let mut absolute_deadline = self.absolute_deadline.lock(&mut node); - // *absolute_deadline = None; - // } } struct PendingTask { @@ -561,22 +521,9 @@ struct NodeInfo { relative_deadline: Option, } -impl NodeInfo { - /// ノードの相対デッドラインを取得 - pub fn get_relative_deadline(&self) -> Option { - self.relative_deadline - } -} - - - - - pub fn to_node_index(index: u32) -> NodeIndex { NodeIndex::new(index as usize) } - - struct EdgeInfo { topic_name: Cow<'static, str>, } @@ -640,38 +587,11 @@ pub fn get_dag(id: u32) -> Option> { dags.id_to_dag.get(&id).cloned() } -/// 指定されたDAG IDとノードインデックスからノードのDAG IDを取得 -// pub fn get_node_dag_id(dag_id: u32, node_idx: NodeIndex) -> Option { -// get_dag(dag_id)?.get_node_dag_id(node_idx) -// } - -/// 指定されたDAG IDとノードインデックスからノード情報を取得 -// pub fn get_node_info(dag_id: u32, node_idx: NodeIndex) -> Option<&NodeInfo> { -// get_dag(dag_id)?.get_node_info(node_idx) -// } - -/// 指定されたtask_idを持つノードを全DAGから検索 -pub fn find_node_by_task_id_global(task_id: u32) -> Option<(u32, NodeIndex)> { - let mut node = MCSNode::new(); - let dags = DAGS.lock(&mut node); - - for (dag_id, dag) in dags.id_to_dag.iter() { - if let Some(node_idx) = dag.find_node_by_task_id(task_id) { - return Some((*dag_id, node_idx)); - } - } - None -} - - - -/// DAG IDから絶対デッドラインを取得 #[inline(always)] pub fn get_dag_absolute_deadline(dag_id: u32) -> Option { get_dag(dag_id)?.get_absolute_deadline() } -/// DAG IDから絶対デッドラインを設定 #[inline(always)] pub fn set_dag_absolute_deadline(dag_id: u32, deadline: u64) -> bool { if let Some(dag) = get_dag(dag_id) { @@ -682,8 +602,6 @@ pub fn set_dag_absolute_deadline(dag_id: u32, deadline: u64) -> bool { } } - - pub async fn finish_create_dags(dags: &[Arc]) -> Result<(), Vec> { match validate_all_rules(dags) { Ok(()) => { @@ -967,11 +885,7 @@ async fn spawn_dag(dag: &Arc) { let mut graph = dag.graph.lock(&mut node); if let Some(node_info) = graph.node_weight_mut(task.node_idx) { node_info.task_id = task_id; - //ここでdag_idを設定 - // node_info.dag_id = dag_id; } - - // タスクのDAG情報を設定上で設定しているのでここはいらなさそう task::set_dag_info_by_task_id(task_id, dag_id, task.node_idx.index() as u32); } @@ -988,11 +902,7 @@ async fn spawn_dag(dag: &Arc) { let mut graph = dag.graph.lock(&mut node); if let Some(node_info) = graph.node_weight_mut(source_pending_task.node_idx) { node_info.task_id = task_id; - //ここでdag_idを設定 - // node_info.dag_id = dag_id; } - - // ソースタスクのDAG情報を設定上で設定しているのでここはいらなさそう task::set_dag_info_by_task_id(task_id, dag_id, source_pending_task.node_idx.index() as u32); } diff --git a/awkernel_async_lib/src/scheduler.rs b/awkernel_async_lib/src/scheduler.rs index c38238a9e..719a83aa0 100644 --- a/awkernel_async_lib/src/scheduler.rs +++ b/awkernel_async_lib/src/scheduler.rs @@ -73,6 +73,7 @@ pub fn move_preemption_pending(cpu_id: usize) -> Option>> { #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum SchedulerType { GEDF(u64), // relative deadline + GEDFNoArg, // GEDF without argument, internally uses GEDF(0) PrioritizedFIFO(u8), PrioritizedRR(u8), Panicked, @@ -83,6 +84,7 @@ impl SchedulerType { matches!( (self, other), (SchedulerType::GEDF(_), SchedulerType::GEDF(_)) + | (SchedulerType::GEDFNoArg, SchedulerType::GEDFNoArg) | ( SchedulerType::PrioritizedFIFO(_), SchedulerType::PrioritizedFIFO(_) @@ -151,6 +153,7 @@ pub(crate) fn get_scheduler(sched_type: SchedulerType) -> &'static dyn Scheduler SchedulerType::PrioritizedFIFO(_) => &prioritized_fifo::SCHEDULER, SchedulerType::PrioritizedRR(_) => &prioritized_rr::SCHEDULER, SchedulerType::GEDF(_) => &gedf::SCHEDULER, + SchedulerType::GEDFNoArg => &gedf::SCHEDULER, // GEDFNoArg is internally GEDF(0) SchedulerType::Panicked => &panicked::SCHEDULER, } } diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index d732f4d10..4b792ccc9 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -72,62 +72,47 @@ impl Scheduler for GEDFScheduler { let (wake_time, absolute_deadline) = { let mut node_inner = MCSNode::new(); let mut info = task.info.lock(&mut node_inner); - match info.scheduler_type { + match info.scheduler_type { SchedulerType::GEDF(relative_deadline) => { let wake_time = awkernel_lib::delay::uptime(); let absolute_deadline ; - // DAGに所属している場合 if let Some((dag_id, node_index)) = get_dag_info_by_task_id(task.id) { - // DAGの絶対デッドラインを取得 if get_dag_absolute_deadline(dag_id).is_none() { - // DAGの絶対デッドラインが設定されていない場合（1周期目） - // DAGを取得してsinkノードの相対デッドラインを取得 if let Some(dag) = get_dag(dag_id) { let sink_relative_deadline = dag.get_sink_relative_deadline(); - // sink_nodeの相対デッドラインが設定されている場合はそれを使用、 - // そうでなければスケジューラータイプから取得→後で消去 let relative_deadline_ms = if let Some(deadline) = sink_relative_deadline { deadline.as_millis() as u64 } else { relative_deadline }; - // 絶対デッドラインを計算してDAGに設定 absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, absolute_deadline); } else { - // DAGが見つからない場合（エラーケース） unreachable!(); } } else { - // DAGの絶対デッドラインが既に設定されている場合（2周期以降）、ソースノードかどうか判定 if let Some(dag) = get_dag(dag_id){ - // u32-->nodeindex + // Use `to_node_index` to convert the u32 type to NodeIndex + // for use with the method that determines whether it is a source node. let current_node_index = to_node_index(node_index); let is_source_node = dag.is_source_node(current_node_index); - //ソースノードの場合：sink node の相対デッドラインを取得 + wake time = 絶対デッドラインを計算し、DAGにset、source node自身もその絶対デッドラインを優先度として使用 - //それ以外の場合：DAGに絶対デッドラインがあるはずなのでそれを取得して優先度として使用する if is_source_node { let sink_relative_deadline = dag.get_sink_relative_deadline(); - // sink_nodeの相対デッドラインが設定されている場合はそれを使用、 - // そうでなければスケジューラータイプから取得→後で消去 let relative_deadline_ms = if let Some(deadline) = sink_relative_deadline { deadline.as_millis() as u64 } else { relative_deadline }; - // 絶対デッドラインを計算してDAGに設定 absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, absolute_deadline); } else { absolute_deadline = get_dag_absolute_deadline(dag_id).unwrap(); } } else { - // DAGが見つからない場合（エラーケース） unreachable!(); } } } else { - // DAGに所属していない単一タスクの場合 absolute_deadline = wake_time + relative_deadline; } @@ -137,6 +122,50 @@ impl Scheduler for GEDFScheduler { (wake_time, absolute_deadline) } + SchedulerType::GEDFNoArg => { + let wake_time = awkernel_lib::delay::uptime(); + let absolute_deadline ; + let (dag_id, node_index) = get_dag_info_by_task_id(task.id).unwrap_or_else(|| { + panic!("GEDFNoArg scheduler: Task {} is not associated with any DAG", task.id); + }); + if get_dag_absolute_deadline(dag_id).is_none() { + let dag = get_dag(dag_id).unwrap_or_else(|| { + panic!("GEDFNoArg scheduler: DAG {} not found for task {}", dag_id, task.id); + }); + let relative_deadline_ms = dag.get_sink_relative_deadline() + .map(|deadline| deadline.as_millis() as u64) + .unwrap_or_else(|| { + panic!("GEDFNoArg scheduler: DAG {} has no sink relative deadline set", dag_id); + }); + absolute_deadline = wake_time + relative_deadline_ms; + set_dag_absolute_deadline(dag_id, absolute_deadline); + } else { + let dag = get_dag(dag_id).unwrap_or_else(|| { + panic!("GEDFNoArg scheduler: DAG {} not found for task {}", dag_id, task.id); + }); + // Use `to_node_index` to convert the u32 type to NodeIndex + // for use with the method that determines whether it is a source node. + let current_node_index = to_node_index(node_index); + let is_source_node = dag.is_source_node(current_node_index); + if is_source_node { + let relative_deadline_ms = dag.get_sink_relative_deadline() + .map(|deadline| deadline.as_millis() as u64) + .unwrap_or_else(|| { + panic!("GEDFNoArg scheduler: DAG {} has no sink relative deadline set", dag_id); + }); + absolute_deadline = wake_time + relative_deadline_ms; + set_dag_absolute_deadline(dag_id, absolute_deadline); + } else { + absolute_deadline = get_dag_absolute_deadline(dag_id).unwrap(); + } + } + + task.priority + .update_priority_info(self.priority, MAX_TASK_PRIORITY - absolute_deadline); + info.update_absolute_deadline(absolute_deadline); + + (wake_time, absolute_deadline) + } _ => unreachable!(), } }; diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 10f15ba70..df2d767b7 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -157,10 +157,8 @@ pub struct TaskInfo { need_sched: bool, pub(crate) need_preemption: bool, panicked: bool, - - // DAG関連の情報 - pub(crate) dag_id: Option, // 所属するDAGのID - pub(crate) node_index: Option, // DAG内のノードインデックス + pub(crate) dag_id: Option, + pub(crate) node_index: Option, #[cfg(not(feature = "no_preempt"))] thread: Option, @@ -224,28 +222,22 @@ impl TaskInfo { self.panicked } - // DAG関連のメソッド - - /// タスクが所属するDAGのIDを取得 #[inline(always)] pub fn get_dag_id(&self) -> Option { self.dag_id } - /// タスクがDAG内で占めるノードインデックスを取得 #[inline(always)] pub fn get_node_index(&self) -> Option { self.node_index } - /// タスクのDAG情報を設定 #[inline(always)] pub fn set_dag_info(&mut self, dag_id: u32, node_index: u32) { self.dag_id = Some(dag_id); self.node_index = Some(node_index); } - /// タスクのDAG情報を取得（タプル形式） #[inline(always)] pub fn get_dag_info(&self) -> Option<(u32, u32)> { match (self.dag_id, self.node_index) { @@ -306,8 +298,6 @@ impl Tasks { need_sched: false, need_preemption: false, panicked: false, - - // DAG関連の情報 dag_id: None, node_index: None, @@ -994,7 +984,6 @@ pub fn get_absolute_deadline_by_task_id(task_id: u32) -> Option { }) } -/// タスクIDからDAG情報を取得 #[inline(always)] pub fn get_dag_info_by_task_id(task_id: u32) -> Option<(u32, u32)> { let mut node = MCSNode::new(); @@ -1007,7 +996,6 @@ pub fn get_dag_info_by_task_id(task_id: u32) -> Option<(u32, u32)> { }) } -/// タスクのDAG情報を設定 #[inline(always)] pub fn set_dag_info_by_task_id(task_id: u32, dag_id: u32, node_index: u32) -> bool { let mut node = MCSNode::new(); From 339f669d5089a9c11fc883eda9994d745a6d2b39 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Fri, 29 Aug 2025 13:42:03 +0900 Subject: [PATCH 14/55] fix: remove unused methods Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 23 ----------------------- awkernel_async_lib/src/task.rs | 10 ---------- 2 files changed, 33 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 1653e73c2..3f435738d 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -180,18 +180,6 @@ impl Dag { self.id } - pub fn get_all_node_indices(&self) -> Vec { - let mut node = MCSNode::new(); - let graph = self.graph.lock(&mut node); - graph.node_indices().collect() - } - - pub fn get_all_node_infos(&self) -> Vec<(NodeIndex, NodeInfo)> { - let mut node = MCSNode::new(); - let graph = self.graph.lock(&mut node); - graph.node_references().map(|node_ref| (node_ref.id(), node_ref.weight().clone())).collect() - } - pub fn get_source_nodes(&self) -> Vec { let mut node = MCSNode::new(); let graph = self.graph.lock(&mut node); @@ -209,11 +197,6 @@ impl Dag { source_nodes.contains(&node_index) } - pub fn is_sink_node(&self, node_index: NodeIndex) -> bool { - let sink_nodes = self.get_sink_nodes(); - sink_nodes.contains(&node_index) - } - pub fn get_sink_relative_deadline(&self) -> Option { let mut node = MCSNode::new(); let graph = self.graph.lock(&mut node); @@ -226,12 +209,6 @@ impl Dag { } } - pub fn get_node_relative_deadline(&self, node_idx: NodeIndex) -> Option { - let mut node = MCSNode::new(); - let graph = self.graph.lock(&mut node); - graph.node_weight(node_idx)?.relative_deadline - } - fn set_relative_deadline(&self, node_idx: NodeIndex, deadline: Duration) { let mut node = MCSNode::new(); let mut graph = self.graph.lock(&mut node); diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index df2d767b7..e2955d7fb 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -222,16 +222,6 @@ impl TaskInfo { self.panicked } - #[inline(always)] - pub fn get_dag_id(&self) -> Option { - self.dag_id - } - - #[inline(always)] - pub fn get_node_index(&self) -> Option { - self.node_index - } - #[inline(always)] pub fn set_dag_info(&mut self, dag_id: u32, node_index: u32) { self.dag_id = Some(dag_id); From 5e47291179895a2add9a67a675ea1c0480e556e1 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Fri, 29 Aug 2025 17:18:34 +0900 Subject: [PATCH 15/55] fix: change PRIORITY_LIST & change dag.rs Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 5 ++--- awkernel_async_lib/src/scheduler.rs | 11 +++++++---- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 3f435738d..3d8772e8a 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -180,13 +180,13 @@ impl Dag { self.id } - pub fn get_source_nodes(&self) -> Vec { + fn get_source_nodes(&self) -> Vec { let mut node = MCSNode::new(); let graph = self.graph.lock(&mut node); graph.externals(Direction::Incoming).collect() } - pub fn get_sink_nodes(&self) -> Vec { + fn get_sink_nodes(&self) -> Vec { let mut node = MCSNode::new(); let graph = self.graph.lock(&mut node); graph.externals(Direction::Outgoing).collect() @@ -490,7 +490,6 @@ impl PendingTask { } } -#[derive(Clone)] struct NodeInfo { task_id: u32, subscribe_topic_names: Vec>, diff --git a/awkernel_async_lib/src/scheduler.rs b/awkernel_async_lib/src/scheduler.rs index 719a83aa0..f0af17649 100644 --- a/awkernel_async_lib/src/scheduler.rs +++ b/awkernel_async_lib/src/scheduler.rs @@ -85,6 +85,8 @@ impl SchedulerType { (self, other), (SchedulerType::GEDF(_), SchedulerType::GEDF(_)) | (SchedulerType::GEDFNoArg, SchedulerType::GEDFNoArg) + | (SchedulerType::GEDFNoArg, SchedulerType::GEDF(_)) + | (SchedulerType::GEDF(_), SchedulerType::GEDFNoArg) | ( SchedulerType::PrioritizedFIFO(_), SchedulerType::PrioritizedFIFO(_) @@ -111,11 +113,12 @@ impl SchedulerType { /// - Priority-based Round-Robin scheduler. /// - The lowest priority. /// - Panicked scheduler. -static PRIORITY_LIST: [SchedulerType; 4] = [ - SchedulerType::Panicked, - SchedulerType::PrioritizedRR(0), - SchedulerType::PrioritizedFIFO(0), +static PRIORITY_LIST: [SchedulerType; 5] = [ SchedulerType::GEDF(0), + SchedulerType::GEDFNoArg, + SchedulerType::PrioritizedFIFO(0), + SchedulerType::PrioritizedRR(0), + SchedulerType::Panicked, ]; pub(crate) trait Scheduler { From e7f21200c39b70d5e6c31d91ccd783b87f1dbc65 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sat, 30 Aug 2025 03:49:01 +0900 Subject: [PATCH 16/55] fix: change gedf.rs & task.rs Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 58 ++++++++++++++---------- awkernel_async_lib/src/task.rs | 16 +------ 2 files changed, 35 insertions(+), 39 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 4b792ccc9..8d4dc15dd 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -70,13 +70,17 @@ impl Scheduler for GEDFScheduler { let internal_data = data.get_or_insert_with(GEDFData::new); let (wake_time, absolute_deadline) = { + //If we do not perform get_dag_info_by_task_id here, it will cause a deadlock with info. + let dag_info = get_dag_info_by_task_id(task.id); let mut node_inner = MCSNode::new(); let mut info = task.info.lock(&mut node_inner); + match info.scheduler_type { SchedulerType::GEDF(relative_deadline) => { let wake_time = awkernel_lib::delay::uptime(); let absolute_deadline ; - if let Some((dag_id, node_index)) = get_dag_info_by_task_id(task.id) { + + if let Some((dag_id, node_index)) = dag_info { if get_dag_absolute_deadline(dag_id).is_none() { if let Some(dag) = get_dag(dag_id) { let sink_relative_deadline = dag.get_sink_relative_deadline(); @@ -113,6 +117,7 @@ impl Scheduler for GEDFScheduler { } } } else { + log::debug!("GEDF scheduler: Task {} DAG info not yet set, using provided relative_deadline: {}", task.id, relative_deadline); absolute_deadline = wake_time + relative_deadline; } @@ -125,29 +130,12 @@ impl Scheduler for GEDFScheduler { SchedulerType::GEDFNoArg => { let wake_time = awkernel_lib::delay::uptime(); let absolute_deadline ; - let (dag_id, node_index) = get_dag_info_by_task_id(task.id).unwrap_or_else(|| { - panic!("GEDFNoArg scheduler: Task {} is not associated with any DAG", task.id); - }); - if get_dag_absolute_deadline(dag_id).is_none() { - let dag = get_dag(dag_id).unwrap_or_else(|| { - panic!("GEDFNoArg scheduler: DAG {} not found for task {}", dag_id, task.id); - }); - let relative_deadline_ms = dag.get_sink_relative_deadline() - .map(|deadline| deadline.as_millis() as u64) - .unwrap_or_else(|| { - panic!("GEDFNoArg scheduler: DAG {} has no sink relative deadline set", dag_id); + + if let Some((dag_id, node_index)) = dag_info { + if get_dag_absolute_deadline(dag_id).is_none() { + let dag = get_dag(dag_id).unwrap_or_else(|| { + panic!("GEDFNoArg scheduler: DAG {} not found for task {}", dag_id, task.id); }); - absolute_deadline = wake_time + relative_deadline_ms; - set_dag_absolute_deadline(dag_id, absolute_deadline); - } else { - let dag = get_dag(dag_id).unwrap_or_else(|| { - panic!("GEDFNoArg scheduler: DAG {} not found for task {}", dag_id, task.id); - }); - // Use `to_node_index` to convert the u32 type to NodeIndex - // for use with the method that determines whether it is a source node. - let current_node_index = to_node_index(node_index); - let is_source_node = dag.is_source_node(current_node_index); - if is_source_node { let relative_deadline_ms = dag.get_sink_relative_deadline() .map(|deadline| deadline.as_millis() as u64) .unwrap_or_else(|| { @@ -156,8 +144,28 @@ impl Scheduler for GEDFScheduler { absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, absolute_deadline); } else { - absolute_deadline = get_dag_absolute_deadline(dag_id).unwrap(); - } + let dag = get_dag(dag_id).unwrap_or_else(|| { + panic!("GEDFNoArg scheduler: DAG {} not found for task {}", dag_id, task.id); + }); + // Use `to_node_index` to convert the u32 type to NodeIndex + // for use with the method that determines whether it is a source node. + let current_node_index = to_node_index(node_index); + let is_source_node = dag.is_source_node(current_node_index); + if is_source_node { + let relative_deadline_ms = dag.get_sink_relative_deadline() + .map(|deadline| deadline.as_millis() as u64) + .unwrap_or_else(|| { + panic!("GEDFNoArg scheduler: DAG {} has no sink relative deadline set", dag_id); + }); + absolute_deadline = wake_time + relative_deadline_ms; + set_dag_absolute_deadline(dag_id, absolute_deadline); + } else { + absolute_deadline = get_dag_absolute_deadline(dag_id).unwrap(); + } + } + } else { + log::debug!("GEDFNoArg scheduler: Task {} DAG info not yet set, using default deadline", task.id); + absolute_deadline = wake_time + 1000; } task.priority diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index e2955d7fb..be860e55b 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -962,28 +962,16 @@ pub fn get_scheduler_type_by_task_id(task_id: u32) -> Option { }) } -#[inline(always)] -pub fn get_absolute_deadline_by_task_id(task_id: u32) -> Option { - let mut node = MCSNode::new(); - let tasks = TASKS.lock(&mut node); - - tasks.id_to_task.get(&task_id).and_then(|task| { - let mut node = MCSNode::new(); - let info = task.info.lock(&mut node); - info.get_absolute_deadline() - }) -} - #[inline(always)] pub fn get_dag_info_by_task_id(task_id: u32) -> Option<(u32, u32)> { let mut node = MCSNode::new(); let tasks = TASKS.lock(&mut node); - tasks.id_to_task.get(&task_id).and_then(|task| { + tasks.id_to_task.get(&task_id).map(|task| { let mut node = MCSNode::new(); let info = task.info.lock(&mut node); info.get_dag_info() - }) + })? } #[inline(always)] From 7c65150fb3094138a2229126c146c36a6284e02d Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 31 Aug 2025 02:52:13 +0900 Subject: [PATCH 17/55] fix: avoid deadlock for GEDFNoArg Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 10 ++++++++-- awkernel_async_lib/src/scheduler/gedf.rs | 8 ++++---- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 3d8772e8a..b8c46c89d 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -862,7 +862,10 @@ async fn spawn_dag(dag: &Arc) { if let Some(node_info) = graph.node_weight_mut(task.node_idx) { node_info.task_id = task_id; } - task::set_dag_info_by_task_id(task_id, dag_id, task.node_idx.index() as u32); + { + log::debug!("spawn_dag: setting DAG info for task {}", task_id); + task::set_dag_info_by_task_id(task_id, dag_id, task.node_idx.index() as u32); + } } // To prevent message drops, source reactor is spawned after all subsequent reactors have been spawned. @@ -879,7 +882,10 @@ async fn spawn_dag(dag: &Arc) { if let Some(node_info) = graph.node_weight_mut(source_pending_task.node_idx) { node_info.task_id = task_id; } - task::set_dag_info_by_task_id(task_id, dag_id, source_pending_task.node_idx.index() as u32); + { + log::debug!("spawn_dag: setting DAG info for source task {}", task_id); + task::set_dag_info_by_task_id(task_id, dag_id, source_pending_task.node_idx.index() as u32); + } } async fn spawn_reactor( diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 8d4dc15dd..0813f2e26 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -70,11 +70,9 @@ impl Scheduler for GEDFScheduler { let internal_data = data.get_or_insert_with(GEDFData::new); let (wake_time, absolute_deadline) = { - //If we do not perform get_dag_info_by_task_id here, it will cause a deadlock with info. - let dag_info = get_dag_info_by_task_id(task.id); 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(); @@ -130,6 +128,7 @@ impl Scheduler for GEDFScheduler { SchedulerType::GEDFNoArg => { let wake_time = awkernel_lib::delay::uptime(); let absolute_deadline ; + log::debug!("GEDFNoArg scheduler: dag_info={:?}", dag_info); if let Some((dag_id, node_index)) = dag_info { if get_dag_absolute_deadline(dag_id).is_none() { @@ -165,8 +164,9 @@ impl Scheduler for GEDFScheduler { } } else { log::debug!("GEDFNoArg scheduler: Task {} DAG info not yet set, using default deadline", task.id); - absolute_deadline = wake_time + 1000; + absolute_deadline = wake_time + 1000; // Default 1 second deadline } + task.priority .update_priority_info(self.priority, MAX_TASK_PRIORITY - absolute_deadline); From a840b4c9040d20a03b95e17342bca31904f16dac Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Fri, 5 Sep 2025 06:17:00 +0900 Subject: [PATCH 18/55] fix: change spawn logic Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 38 ++++++++++------ awkernel_async_lib/src/scheduler/gedf.rs | 3 +- awkernel_async_lib/src/task.rs | 55 ++++++++++++++++++++++-- 3 files changed, 79 insertions(+), 17 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index de29b65ca..d487c398f 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -303,6 +303,10 @@ impl Dag { self.check_subscribe_mismatch::(&subscribe_topic_names, node_idx); self.check_publish_mismatch::(&publish_topic_names, node_idx); + // 必要な値を事前にコピー + let dag_id = self.id; + let node_index = node_idx.index() as u32; + let mut node = MCSNode::new(); let mut pending_tasks = PENDING_TASKS.lock(&mut node); pending_tasks @@ -316,6 +320,8 @@ impl Dag { subscribe_topic_names, publish_topic_names, sched_type, + dag_id, + node_index, ) .await }) @@ -349,6 +355,9 @@ impl Dag { } }; + // 必要な値を事前にコピー + let dag_id = self.id; + let node_index = node_idx.index() as u32; let mut node = MCSNode::new(); let mut source_pending_tasks = SOURCE_PENDING_TASKS.lock(&mut node); source_pending_tasks.insert( @@ -362,6 +371,8 @@ impl Dag { sched_type, period, measure_f, + dag_id, + node_index, ) .await }) @@ -403,6 +414,9 @@ impl Dag { } }; + // 必要な値を事前にコピー + let dag_id = self.id; + let node_index = node_idx.index() as u32; let mut node = MCSNode::new(); let mut pending_tasks = PENDING_TASKS.lock(&mut node); pending_tasks @@ -415,6 +429,8 @@ impl Dag { measure_f, subscribe_topic_names, sched_type, + dag_id, + node_index, ) .await }) @@ -862,10 +878,6 @@ async fn spawn_dag(dag: &Arc) { if let Some(node_info) = graph.node_weight_mut(task.node_idx) { node_info.task_id = task_id; } - { - log::debug!("spawn_dag: setting DAG info for task {}", task_id); - task::set_dag_info_by_task_id(task_id, dag_id, task.node_idx.index() as u32); - } } // To prevent message drops, source reactor is spawned after all subsequent reactors have been spawned. @@ -882,10 +894,6 @@ async fn spawn_dag(dag: &Arc) { if let Some(node_info) = graph.node_weight_mut(source_pending_task.node_idx) { node_info.task_id = task_id; } - { - log::debug!("spawn_dag: setting DAG info for source task {}", task_id); - task::set_dag_info_by_task_id(task_id, dag_id, source_pending_task.node_idx.index() as u32); - } } async fn spawn_reactor( @@ -894,6 +902,8 @@ async fn spawn_reactor( subscribe_topic_names: Vec>, publish_topic_names: Vec>, sched_type: SchedulerType, + dag_id: u32, // DAG IDを追加 + node_index: u32, // ノードインデックスを追加 ) -> u32 where F: Fn( @@ -923,7 +933,7 @@ where } }; - crate::task::spawn(reactor_name, future, sched_type) + crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_id, node_index) } async fn spawn_periodic_reactor( @@ -933,6 +943,8 @@ async fn spawn_periodic_reactor( sched_type: SchedulerType, period: Duration, _release_measure: Option, + dag_id: u32, // DAG IDを追加 + node_index: u32, // ノードインデックスを追加 ) -> u32 where F: Fn() -> ::Item + Send + 'static, @@ -970,7 +982,7 @@ where } }; - let task_id = crate::task::spawn(reactor_name, future, sched_type); + let task_id = crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_id, node_index); #[cfg(feature = "perf")] release_measure(); @@ -983,6 +995,8 @@ async fn spawn_sink_reactor( f: F, subscribe_topic_names: Vec>, sched_type: SchedulerType, + dag_id: u32, // DAG IDを追加 + node_index: u32, // ノードインデックスを追加 ) -> u32 where F: Fn(::Item) + Send + 'static, @@ -994,11 +1008,11 @@ where Args::create_subscribers(subscribe_topic_names, Attribute::default()); loop { - let args: <::Subscribers as MultipleReceiver>::Item = + let args: ::Item = subscribers.recv_all().await; f(args); } }; - crate::task::spawn(reactor_name, future, sched_type) + crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_id, node_index) } diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 0813f2e26..04440de8c 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -163,8 +163,7 @@ impl Scheduler for GEDFScheduler { } } } else { - log::debug!("GEDFNoArg scheduler: Task {} DAG info not yet set, using default deadline", task.id); - absolute_deadline = wake_time + 1000; // Default 1 second deadline + panic!("GEDFNoArg scheduler: Task {} DAG info not yet set, using default deadline", task.id); } diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index be860e55b..828e15a33 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -270,6 +270,7 @@ impl Tasks { future: Fuse>, scheduler: &'static dyn Scheduler, scheduler_type: SchedulerType, + dag_info: Option<(u32, u32)>, ) -> u32 { let mut id = self.candidate_id; loop { @@ -288,8 +289,8 @@ impl Tasks { need_sched: false, need_preemption: false, panicked: false, - dag_id: None, - node_index: None, + dag_id: dag_info.map(|(d, n)| d), + node_index: dag_info.map(|(_, n)| n), #[cfg(not(feature = "no_preempt"))] thread: None, @@ -370,7 +371,55 @@ pub fn spawn( let mut node = MCSNode::new(); let mut tasks = TASKS.lock(&mut node); - let id = tasks.spawn(name, future.fuse(), scheduler, sched_type); + let id = tasks.spawn(name, future.fuse(), scheduler, sched_type, None); + let task = tasks.id_to_task.get(&id).cloned(); + drop(tasks); + + if let Some(task) = task { + task.wake(); + } + + id +} + +/// Spawn a detached task with DAG information. +/// This function is similar to `spawn` but automatically sets DAG information +/// for the task, which is useful for DAG-based schedulers like GEDFNoArg. +/// +/// # Example +/// +/// ``` +/// use awkernel_async_lib::{scheduler::SchedulerType, task}; +/// let task_id = task::spawn_with_dag_info( +/// "dag task".into(), +/// async { Ok(()) }, +/// SchedulerType::GEDFNoArg, +/// 1, // dag_id +/// 0 // node_index +/// ); +/// ``` +pub fn spawn_with_dag_info( + name: Cow<'static, str>, + future: impl Future + 'static + Send, + sched_type: SchedulerType, + dag_id: u32, + node_index: u32, +) -> u32 { + if let SchedulerType::PrioritizedFIFO(p) | SchedulerType::PrioritizedRR(p) = sched_type { + if p > HIGHEST_PRIORITY { + log::warn!( + "Task priority should be between 0 and {HIGHEST_PRIORITY}. It is addressed as {HIGHEST_PRIORITY}." + ); + } + } + + let future = future.boxed(); + + let scheduler = get_scheduler(sched_type); + + let mut node = MCSNode::new(); + let mut tasks = TASKS.lock(&mut node); + let id = tasks.spawn(name, future.fuse(), scheduler, sched_type, Some((dag_id, node_index))); let task = tasks.id_to_task.get(&id).cloned(); drop(tasks); From 7d2b6f56f3151a5a9cc308208c5df2a8a52fc1cd Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sat, 6 Sep 2025 21:02:26 +0900 Subject: [PATCH 19/55] fix: delete GEDFNoArg Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 21 +++---- awkernel_async_lib/src/scheduler.rs | 8 +-- awkernel_async_lib/src/scheduler/gedf.rs | 70 +++--------------------- awkernel_async_lib/src/task.rs | 4 +- 4 files changed, 21 insertions(+), 82 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index d487c398f..1d1ea6169 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -53,7 +53,6 @@ mod visit; #[cfg(feature = "perf")] mod performance; -use crate::task; use crate::{ dag::{ graph::{ @@ -303,7 +302,7 @@ impl Dag { self.check_subscribe_mismatch::(&subscribe_topic_names, node_idx); self.check_publish_mismatch::(&publish_topic_names, node_idx); - // 必要な値を事前にコピー + // To prevent errors caused by ownership moves let dag_id = self.id; let node_index = node_idx.index() as u32; @@ -355,9 +354,10 @@ impl Dag { } }; - // 必要な値を事前にコピー + // To prevent errors caused by ownership moves let dag_id = self.id; let node_index = node_idx.index() as u32; + let mut node = MCSNode::new(); let mut source_pending_tasks = SOURCE_PENDING_TASKS.lock(&mut node); source_pending_tasks.insert( @@ -414,9 +414,10 @@ impl Dag { } }; - // 必要な値を事前にコピー + // To prevent errors caused by ownership moves let dag_id = self.id; let node_index = node_idx.index() as u32; + let mut node = MCSNode::new(); let mut pending_tasks = PENDING_TASKS.lock(&mut node); pending_tasks @@ -902,8 +903,8 @@ async fn spawn_reactor( subscribe_topic_names: Vec>, publish_topic_names: Vec>, sched_type: SchedulerType, - dag_id: u32, // DAG IDを追加 - node_index: u32, // ノードインデックスを追加 + dag_id: u32, + node_index: u32, ) -> u32 where F: Fn( @@ -943,8 +944,8 @@ async fn spawn_periodic_reactor( sched_type: SchedulerType, period: Duration, _release_measure: Option, - dag_id: u32, // DAG IDを追加 - node_index: u32, // ノードインデックスを追加 + dag_id: u32, + node_index: u32, ) -> u32 where F: Fn() -> ::Item + Send + 'static, @@ -995,8 +996,8 @@ async fn spawn_sink_reactor( f: F, subscribe_topic_names: Vec>, sched_type: SchedulerType, - dag_id: u32, // DAG IDを追加 - node_index: u32, // ノードインデックスを追加 + dag_id: u32, + node_index: u32, ) -> u32 where F: Fn(::Item) + Send + 'static, diff --git a/awkernel_async_lib/src/scheduler.rs b/awkernel_async_lib/src/scheduler.rs index b89a5f7ef..b85f8b50a 100644 --- a/awkernel_async_lib/src/scheduler.rs +++ b/awkernel_async_lib/src/scheduler.rs @@ -73,7 +73,6 @@ pub fn move_preemption_pending(cpu_id: usize) -> Option>> { #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum SchedulerType { GEDF(u64), // relative deadline - GEDFNoArg, // GEDF without argument, internally uses GEDF(0) PrioritizedFIFO(u8), PrioritizedRR(u8), Panicked, @@ -84,9 +83,6 @@ impl SchedulerType { matches!( (self, other), (SchedulerType::GEDF(_), SchedulerType::GEDF(_)) - | (SchedulerType::GEDFNoArg, SchedulerType::GEDFNoArg) - | (SchedulerType::GEDFNoArg, SchedulerType::GEDF(_)) - | (SchedulerType::GEDF(_), SchedulerType::GEDFNoArg) | ( SchedulerType::PrioritizedFIFO(_), SchedulerType::PrioritizedFIFO(_) @@ -113,9 +109,8 @@ impl SchedulerType { /// - Priority-based Round-Robin scheduler. /// - The lowest priority. /// - Panicked scheduler. -static PRIORITY_LIST: [SchedulerType; 5] = [ +static PRIORITY_LIST: [SchedulerType; 4] = [ SchedulerType::GEDF(0), - SchedulerType::GEDFNoArg, SchedulerType::PrioritizedFIFO(0), SchedulerType::PrioritizedRR(0), SchedulerType::Panicked, @@ -156,7 +151,6 @@ pub(crate) fn get_scheduler(sched_type: SchedulerType) -> &'static dyn Scheduler SchedulerType::PrioritizedFIFO(_) => &prioritized_fifo::SCHEDULER, SchedulerType::PrioritizedRR(_) => &prioritized_rr::SCHEDULER, SchedulerType::GEDF(_) => &gedf::SCHEDULER, - SchedulerType::GEDFNoArg => &gedf::SCHEDULER, // GEDFNoArg is internally GEDF(0) SchedulerType::Panicked => &panicked::SCHEDULER, } } diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 04440de8c..854caed8e 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -7,7 +7,7 @@ use crate::{ scheduler::{get_priority, peek_preemption_pending, push_preemption_pending}, task::{ get_task, get_tasks_running, set_current_task, set_need_preemption, State, - MAX_TASK_PRIORITY, get_dag_info_by_task_id + MAX_TASK_PRIORITY }, dag::{get_dag_absolute_deadline, set_dag_absolute_deadline, get_dag, to_node_index}, }; @@ -80,72 +80,16 @@ impl Scheduler for GEDFScheduler { if let Some((dag_id, node_index)) = dag_info { if get_dag_absolute_deadline(dag_id).is_none() { - if let Some(dag) = get_dag(dag_id) { - let sink_relative_deadline = dag.get_sink_relative_deadline(); - let relative_deadline_ms = if let Some(deadline) = sink_relative_deadline { - deadline.as_millis() as u64 - } else { - relative_deadline - }; - absolute_deadline = wake_time + relative_deadline_ms; - set_dag_absolute_deadline(dag_id, absolute_deadline); - } else { - unreachable!(); - } - } else { - if let Some(dag) = get_dag(dag_id){ - // Use `to_node_index` to convert the u32 type to NodeIndex - // for use with the method that determines whether it is a source node. - let current_node_index = to_node_index(node_index); - let is_source_node = dag.is_source_node(current_node_index); - if is_source_node { - let sink_relative_deadline = dag.get_sink_relative_deadline(); - let relative_deadline_ms = if let Some(deadline) = sink_relative_deadline { - deadline.as_millis() as u64 - } else { - relative_deadline - }; - absolute_deadline = wake_time + relative_deadline_ms; - set_dag_absolute_deadline(dag_id, absolute_deadline); - } else { - absolute_deadline = get_dag_absolute_deadline(dag_id).unwrap(); - } - } else { - unreachable!(); - } - } - } else { - log::debug!("GEDF scheduler: Task {} DAG info not yet set, using provided relative_deadline: {}", task.id, relative_deadline); - absolute_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) - } - SchedulerType::GEDFNoArg => { - let wake_time = awkernel_lib::delay::uptime(); - let absolute_deadline ; - log::debug!("GEDFNoArg scheduler: dag_info={:?}", dag_info); - - if let Some((dag_id, node_index)) = dag_info { - if get_dag_absolute_deadline(dag_id).is_none() { - let dag = get_dag(dag_id).unwrap_or_else(|| { - panic!("GEDFNoArg scheduler: DAG {} not found for task {}", dag_id, task.id); - }); + let dag = get_dag(dag_id).unwrap_or_else(|| { unreachable!(); }); let relative_deadline_ms = dag.get_sink_relative_deadline() .map(|deadline| deadline.as_millis() as u64) .unwrap_or_else(|| { - panic!("GEDFNoArg scheduler: DAG {} has no sink relative deadline set", dag_id); + panic!("GEDF scheduler: DAG {} has no sink relative deadline set", dag_id); }); absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, absolute_deadline); } else { - let dag = get_dag(dag_id).unwrap_or_else(|| { - panic!("GEDFNoArg scheduler: DAG {} not found for task {}", dag_id, task.id); - }); + let dag = get_dag(dag_id).unwrap_or_else(|| { unreachable!(); }); // Use `to_node_index` to convert the u32 type to NodeIndex // for use with the method that determines whether it is a source node. let current_node_index = to_node_index(node_index); @@ -154,7 +98,7 @@ impl Scheduler for GEDFScheduler { let relative_deadline_ms = dag.get_sink_relative_deadline() .map(|deadline| deadline.as_millis() as u64) .unwrap_or_else(|| { - panic!("GEDFNoArg scheduler: DAG {} has no sink relative deadline set", dag_id); + panic!("GEDF scheduler: DAG {} has no sink relative deadline set", dag_id); }); absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, absolute_deadline); @@ -163,9 +107,9 @@ impl Scheduler for GEDFScheduler { } } } else { - panic!("GEDFNoArg scheduler: Task {} DAG info not yet set, using default deadline", task.id); + log::debug!("GEDF scheduler: Task {} DAG info not yet set, using provided relative_deadline: {}", task.id, relative_deadline); + absolute_deadline = wake_time + relative_deadline; } - task.priority .update_priority_info(self.priority, MAX_TASK_PRIORITY - absolute_deadline); diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 828e15a33..181d553d0 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -289,7 +289,7 @@ impl Tasks { need_sched: false, need_preemption: false, panicked: false, - dag_id: dag_info.map(|(d, n)| d), + dag_id: dag_info.map(|(d, _)| d), node_index: dag_info.map(|(_, n)| n), #[cfg(not(feature = "no_preempt"))] @@ -384,7 +384,7 @@ pub fn spawn( /// Spawn a detached task with DAG information. /// This function is similar to `spawn` but automatically sets DAG information -/// for the task, which is useful for DAG-based schedulers like GEDFNoArg. +/// for the task, which is useful for DAG-based schedulers like GEDF. /// /// # Example /// From 6ef5a8e77bfe5d323e937f008616ec2757465c98 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sat, 6 Sep 2025 22:04:49 +0900 Subject: [PATCH 20/55] fix: check cargo fmt Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 23 ++++++++-------- awkernel_async_lib/src/scheduler/gedf.rs | 34 +++++++++++++++--------- awkernel_async_lib/src/task.rs | 14 +++++++--- 3 files changed, 42 insertions(+), 29 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 1d1ea6169..e9b50ce85 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -195,12 +195,12 @@ impl Dag { let source_nodes = self.get_source_nodes(); source_nodes.contains(&node_index) } - + pub fn get_sink_relative_deadline(&self) -> Option { let mut node = MCSNode::new(); let graph = self.graph.lock(&mut node); let sink_nodes: Vec = graph.externals(Direction::Outgoing).collect(); - + if let Some(sink_node_index) = sink_nodes.first() { graph.node_weight(*sink_node_index)?.relative_deadline } else { @@ -487,7 +487,6 @@ impl Dag { let absolute_deadline = self.absolute_deadline.lock(&mut node); *absolute_deadline } - } struct PendingTask { @@ -903,8 +902,8 @@ async fn spawn_reactor( subscribe_topic_names: Vec>, publish_topic_names: Vec>, sched_type: SchedulerType, - dag_id: u32, - node_index: u32, + dag_id: u32, + node_index: u32, ) -> u32 where F: Fn( @@ -944,8 +943,8 @@ async fn spawn_periodic_reactor( sched_type: SchedulerType, period: Duration, _release_measure: Option, - dag_id: u32, - node_index: u32, + dag_id: u32, + node_index: u32, ) -> u32 where F: Fn() -> ::Item + Send + 'static, @@ -983,7 +982,8 @@ where } }; - let task_id = crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_id, node_index); + let task_id = + crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_id, node_index); #[cfg(feature = "perf")] release_measure(); @@ -996,8 +996,8 @@ async fn spawn_sink_reactor( f: F, subscribe_topic_names: Vec>, sched_type: SchedulerType, - dag_id: u32, - node_index: u32, + dag_id: u32, + node_index: u32, ) -> u32 where F: Fn(::Item) + Send + 'static, @@ -1009,8 +1009,7 @@ where Args::create_subscribers(subscribe_topic_names, Attribute::default()); loop { - let args: ::Item = - subscribers.recv_all().await; + let args: ::Item = subscribers.recv_all().await; f(args); } }; diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 854caed8e..e37eeca20 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -4,12 +4,12 @@ use core::cmp::max; use super::{Scheduler, SchedulerType, Task}; use crate::{ + dag::{get_dag, get_dag_absolute_deadline, set_dag_absolute_deadline, to_node_index}, scheduler::{get_priority, peek_preemption_pending, push_preemption_pending}, task::{ get_task, get_tasks_running, set_current_task, set_need_preemption, State, - MAX_TASK_PRIORITY + MAX_TASK_PRIORITY, }, - dag::{get_dag_absolute_deadline, set_dag_absolute_deadline, get_dag, to_node_index}, }; use alloc::{collections::BinaryHeap, sync::Arc, vec::Vec}; use awkernel_lib::sync::mutex::{MCSNode, Mutex}; @@ -73,24 +73,32 @@ impl Scheduler for GEDFScheduler { 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 { + match info.scheduler_type { SchedulerType::GEDF(relative_deadline) => { let wake_time = awkernel_lib::delay::uptime(); - let absolute_deadline ; - + let absolute_deadline; + if let Some((dag_id, node_index)) = dag_info { if get_dag_absolute_deadline(dag_id).is_none() { - let dag = get_dag(dag_id).unwrap_or_else(|| { unreachable!(); }); - let relative_deadline_ms = dag.get_sink_relative_deadline() + let dag = get_dag(dag_id).unwrap_or_else(|| { + unreachable!(); + }); + let relative_deadline_ms = dag + .get_sink_relative_deadline() .map(|deadline| deadline.as_millis() as u64) .unwrap_or_else(|| { - panic!("GEDF scheduler: DAG {} has no sink relative deadline set", dag_id); + panic!( + "GEDF scheduler: DAG {} has no sink relative deadline set", + dag_id + ); }); absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, absolute_deadline); } else { - let dag = get_dag(dag_id).unwrap_or_else(|| { unreachable!(); }); - // Use `to_node_index` to convert the u32 type to NodeIndex + let dag = get_dag(dag_id).unwrap_or_else(|| { + unreachable!(); + }); + // Use `to_node_index` to convert the u32 type to NodeIndex // for use with the method that determines whether it is a source node. let current_node_index = to_node_index(node_index); let is_source_node = dag.is_source_node(current_node_index); @@ -104,17 +112,17 @@ impl Scheduler for GEDFScheduler { set_dag_absolute_deadline(dag_id, absolute_deadline); } else { absolute_deadline = get_dag_absolute_deadline(dag_id).unwrap(); - } + } } } else { log::debug!("GEDF scheduler: Task {} DAG info not yet set, using provided relative_deadline: {}", task.id, relative_deadline); absolute_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!(), diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 181d553d0..7ed92aa56 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -157,7 +157,7 @@ pub struct TaskInfo { need_sched: bool, pub(crate) need_preemption: bool, panicked: bool, - pub(crate) dag_id: Option, + pub(crate) dag_id: Option, pub(crate) node_index: Option, #[cfg(not(feature = "no_preempt"))] @@ -391,8 +391,8 @@ pub fn spawn( /// ``` /// use awkernel_async_lib::{scheduler::SchedulerType, task}; /// let task_id = task::spawn_with_dag_info( -/// "dag task".into(), -/// async { Ok(()) }, +/// "dag task".into(), +/// async { Ok(()) }, /// SchedulerType::GEDFNoArg, /// 1, // dag_id /// 0 // node_index @@ -419,7 +419,13 @@ pub fn spawn_with_dag_info( let mut node = MCSNode::new(); let mut tasks = TASKS.lock(&mut node); - let id = tasks.spawn(name, future.fuse(), scheduler, sched_type, Some((dag_id, node_index))); + let id = tasks.spawn( + name, + future.fuse(), + scheduler, + sched_type, + Some((dag_id, node_index)), + ); let task = tasks.id_to_task.get(&id).cloned(); drop(tasks); From fef8c1136fb06c1258da61a65361c1895351dfa5 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sat, 6 Sep 2025 22:32:52 +0900 Subject: [PATCH 21/55] fix: adjusting the number of arguments Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 24 +++++++++--------------- awkernel_async_lib/src/task.rs | 5 ++--- 2 files changed, 11 insertions(+), 18 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index e9b50ce85..529a84a0c 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -319,8 +319,7 @@ impl Dag { subscribe_topic_names, publish_topic_names, sched_type, - dag_id, - node_index, + Some((dag_id, node_index)), ) .await }) @@ -371,8 +370,7 @@ impl Dag { sched_type, period, measure_f, - dag_id, - node_index, + Some((dag_id, node_index)), ) .await }) @@ -430,8 +428,7 @@ impl Dag { measure_f, subscribe_topic_names, sched_type, - dag_id, - node_index, + Some((dag_id, node_index)), ) .await }) @@ -902,8 +899,7 @@ async fn spawn_reactor( subscribe_topic_names: Vec>, publish_topic_names: Vec>, sched_type: SchedulerType, - dag_id: u32, - node_index: u32, + dag_info: Option<(u32, u32)>, ) -> u32 where F: Fn( @@ -933,7 +929,7 @@ where } }; - crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_id, node_index) + crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_info) } async fn spawn_periodic_reactor( @@ -943,8 +939,7 @@ async fn spawn_periodic_reactor( sched_type: SchedulerType, period: Duration, _release_measure: Option, - dag_id: u32, - node_index: u32, + dag_info: Option<(u32, u32)>, ) -> u32 where F: Fn() -> ::Item + Send + 'static, @@ -983,7 +978,7 @@ where }; let task_id = - crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_id, node_index); + crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_info); #[cfg(feature = "perf")] release_measure(); @@ -996,8 +991,7 @@ async fn spawn_sink_reactor( f: F, subscribe_topic_names: Vec>, sched_type: SchedulerType, - dag_id: u32, - node_index: u32, + dag_info: Option<(u32, u32)>, ) -> u32 where F: Fn(::Item) + Send + 'static, @@ -1014,5 +1008,5 @@ where } }; - crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_id, node_index) + crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_info) } diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 7ed92aa56..63bec9321 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -402,8 +402,7 @@ pub fn spawn_with_dag_info( name: Cow<'static, str>, future: impl Future + 'static + Send, sched_type: SchedulerType, - dag_id: u32, - node_index: u32, + dag_info: Option<(u32, u32)>, ) -> u32 { if let SchedulerType::PrioritizedFIFO(p) | SchedulerType::PrioritizedRR(p) = sched_type { if p > HIGHEST_PRIORITY { @@ -424,7 +423,7 @@ pub fn spawn_with_dag_info( future.fuse(), scheduler, sched_type, - Some((dag_id, node_index)), + dag_info, ); let task = tasks.id_to_task.get(&id).cloned(); drop(tasks); From f4f50aaedf6972993710f2fb23bfbb06b5729080 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sat, 6 Sep 2025 22:35:19 +0900 Subject: [PATCH 22/55] fix: check cargo fmt 2 Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 3 +-- awkernel_async_lib/src/task.rs | 8 +------- 2 files changed, 2 insertions(+), 9 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 529a84a0c..231938b6c 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -977,8 +977,7 @@ where } }; - let task_id = - crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_info); + let task_id = crate::task::spawn_with_dag_info(reactor_name, future, sched_type, dag_info); #[cfg(feature = "perf")] release_measure(); diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 63bec9321..989d523ac 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -418,13 +418,7 @@ pub fn spawn_with_dag_info( let mut node = MCSNode::new(); let mut tasks = TASKS.lock(&mut node); - let id = tasks.spawn( - name, - future.fuse(), - scheduler, - sched_type, - dag_info, - ); + let id = tasks.spawn(name, future.fuse(), scheduler, sched_type, dag_info); let task = tasks.id_to_task.get(&id).cloned(); drop(tasks); From 506a019adc98cdde322903f7877443db2c78e2be Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sat, 6 Sep 2025 22:47:52 +0900 Subject: [PATCH 23/55] fix: improper variable usage in panic! macros Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index e37eeca20..7311463e3 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -88,9 +88,7 @@ impl Scheduler for GEDFScheduler { .map(|deadline| deadline.as_millis() as u64) .unwrap_or_else(|| { panic!( - "GEDF scheduler: DAG {} has no sink relative deadline set", - dag_id - ); + "GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); }); absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, absolute_deadline); @@ -106,7 +104,7 @@ impl Scheduler for GEDFScheduler { let relative_deadline_ms = dag.get_sink_relative_deadline() .map(|deadline| deadline.as_millis() as u64) .unwrap_or_else(|| { - panic!("GEDF scheduler: DAG {} has no sink relative deadline set", dag_id); + panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); }); absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, absolute_deadline); From 4282cbe8b9205810472e10df95e6e0a9f3649d0b Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sat, 6 Sep 2025 23:00:27 +0900 Subject: [PATCH 24/55] fix: check doctest Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 3 +-- awkernel_async_lib/src/task.rs | 5 ++--- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 7311463e3..b09f3e03d 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -87,8 +87,7 @@ impl Scheduler for GEDFScheduler { .get_sink_relative_deadline() .map(|deadline| deadline.as_millis() as u64) .unwrap_or_else(|| { - panic!( - "GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); + panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); }); absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, absolute_deadline); diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 989d523ac..dc5e5e704 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -393,9 +393,8 @@ pub fn spawn( /// let task_id = task::spawn_with_dag_info( /// "dag task".into(), /// async { Ok(()) }, -/// SchedulerType::GEDFNoArg, -/// 1, // dag_id -/// 0 // node_index +/// SchedulerType::GEDF(0), +/// Some((1, 0)) // dag_info as Option<(u32, u32)> /// ); /// ``` pub fn spawn_with_dag_info( From f1b308245751418b17e1b3f744d19f4c93404c2c Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sat, 6 Sep 2025 23:13:17 +0900 Subject: [PATCH 25/55] fix: check doctest 2 Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index b09f3e03d..9997eaadd 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -80,9 +80,8 @@ impl Scheduler for GEDFScheduler { if let Some((dag_id, node_index)) = dag_info { if get_dag_absolute_deadline(dag_id).is_none() { - let dag = get_dag(dag_id).unwrap_or_else(|| { - unreachable!(); - }); + let dag = + get_dag(dag_id).expect("GEDF scheduler: DAG {dag_id} not found"); let relative_deadline_ms = dag .get_sink_relative_deadline() .map(|deadline| deadline.as_millis() as u64) @@ -92,9 +91,8 @@ impl Scheduler for GEDFScheduler { absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, absolute_deadline); } else { - let dag = get_dag(dag_id).unwrap_or_else(|| { - unreachable!(); - }); + let dag = + get_dag(dag_id).expect("GEDF scheduler: DAG {dag_id} not found"); // Use `to_node_index` to convert the u32 type to NodeIndex // for use with the method that determines whether it is a source node. let current_node_index = to_node_index(node_index); From 0c2a69d43b8b524faa3cab205bd7d8ecbce7ccdc Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sat, 6 Sep 2025 23:56:51 +0900 Subject: [PATCH 26/55] fix: check doctest 3 Signed-off-by: nokosaaan --- awkernel_async_lib/src/task.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index dc5e5e704..91cb67da5 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -389,7 +389,8 @@ pub fn spawn( /// # Example /// /// ``` -/// use awkernel_async_lib::{scheduler::SchedulerType, task}; +/// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::create_dag}; +/// let dag = create_dag(); /// let task_id = task::spawn_with_dag_info( /// "dag task".into(), /// async { Ok(()) }, From a8b4d72b4d6ef70e4d3e05a8b3e8820ef30bb899 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 00:12:38 +0900 Subject: [PATCH 27/55] fix: check doctest 4 Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 21 +++++++++++++++++++++ awkernel_async_lib/src/task.rs | 2 ++ 2 files changed, 23 insertions(+) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 231938b6c..fbddaeb02 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -214,6 +214,27 @@ impl Dag { graph.node_weight_mut(node_idx).unwrap().relative_deadline = Some(deadline); } + pub fn set_sink_relative_deadline(&self, deadline: Duration) { + let mut node = MCSNode::new(); + let mut graph = self.graph.lock(&mut node); + + let sink_nodes: Vec = graph.externals(Direction::Outgoing).collect(); + + if sink_nodes.len() != 1 { + panic!( + "DAG {} must have exactly one sink node, but found {}", + self.id, + sink_nodes.len() + ); + } + + let sink_node_index = sink_nodes[0]; + let sink_node = graph + .node_weight_mut(sink_node_index) + .expect("Sink node not found"); + sink_node.relative_deadline = Some(deadline); + } + fn add_node_with_topic_edges( &self, subscribe_topic_names: &[Cow<'static, str>], diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 91cb67da5..7a94363c8 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -390,7 +390,9 @@ pub fn spawn( /// /// ``` /// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::create_dag}; +/// use core::time::Duration; /// let dag = create_dag(); +/// dag.set_sink_relative_deadline(Duration::from_secs(1)); /// let task_id = task::spawn_with_dag_info( /// "dag task".into(), /// async { Ok(()) }, From ef3f003f6440b56236a892ad58e0e60681ebd379 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 00:22:04 +0900 Subject: [PATCH 28/55] fix: check doctest 5 Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 21 --------------------- awkernel_async_lib/src/task.rs | 8 +++++++- 2 files changed, 7 insertions(+), 22 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index fbddaeb02..231938b6c 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -214,27 +214,6 @@ impl Dag { graph.node_weight_mut(node_idx).unwrap().relative_deadline = Some(deadline); } - pub fn set_sink_relative_deadline(&self, deadline: Duration) { - let mut node = MCSNode::new(); - let mut graph = self.graph.lock(&mut node); - - let sink_nodes: Vec = graph.externals(Direction::Outgoing).collect(); - - if sink_nodes.len() != 1 { - panic!( - "DAG {} must have exactly one sink node, but found {}", - self.id, - sink_nodes.len() - ); - } - - let sink_node_index = sink_nodes[0]; - let sink_node = graph - .node_weight_mut(sink_node_index) - .expect("Sink node not found"); - sink_node.relative_deadline = Some(deadline); - } - fn add_node_with_topic_edges( &self, subscribe_topic_names: &[Cow<'static, str>], diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 7a94363c8..80ea40e0f 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -392,7 +392,13 @@ pub fn spawn( /// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::create_dag}; /// use core::time::Duration; /// let dag = create_dag(); -/// dag.set_sink_relative_deadline(Duration::from_secs(1)); +/// let node_idx = dag.add_node_with_topic_edges(&[], &[]); +/// let sink_nodes = dag.get_sink_nodes(); +/// if let Some(sink_node_index) = sink_nodes.first() { +/// dag.set_relative_deadline(*sink_node_index, Duration::from_millis(100)); +/// } else { +/// panic!("No sink node found in the DAG!"); +/// } /// let task_id = task::spawn_with_dag_info( /// "dag task".into(), /// async { Ok(()) }, From d8dc0ed9e0d13db3010ad62becc9a470ee9f3c01 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 00:46:42 +0900 Subject: [PATCH 29/55] fix: check doctest 6 Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 14 ++++++++++++++ awkernel_async_lib/src/task.rs | 11 +++-------- 2 files changed, 17 insertions(+), 8 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 231938b6c..73d22c341 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -484,6 +484,20 @@ impl Dag { let absolute_deadline = self.absolute_deadline.lock(&mut node); *absolute_deadline } + + // for test + pub fn add_node_with_topic_edges_public( + dag: &Arc, + subscribe_topic_names: &[Cow<'static, str>], + publish_topic_names: &[Cow<'static, str>], + ) -> NodeIndex { + add_node_with_topic_edges(dag, subscribe_topic_names, publish_topic_names) + } + + //for test + pub fn set_relative_deadline_public(dag: &Arc, node_idx: NodeIndex, deadline: Duration) { + set_relative_deadline(dag, node_idx, deadline) + } } struct PendingTask { diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 80ea40e0f..fd4017ee5 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -389,16 +389,11 @@ pub fn spawn( /// # Example /// /// ``` -/// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::create_dag}; +/// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::{create_dag, add_node_with_topic_edges_public, set_relative_deadline_public}}; /// use core::time::Duration; /// let dag = create_dag(); -/// let node_idx = dag.add_node_with_topic_edges(&[], &[]); -/// let sink_nodes = dag.get_sink_nodes(); -/// if let Some(sink_node_index) = sink_nodes.first() { -/// dag.set_relative_deadline(*sink_node_index, Duration::from_millis(100)); -/// } else { -/// panic!("No sink node found in the DAG!"); -/// } +/// let sink_node_idx = add_node_with_topic_edges_public(&dag, &[], &[]); +/// set_relative_deadline_public(&dag, sink_node_idx, deadline); /// let task_id = task::spawn_with_dag_info( /// "dag task".into(), /// async { Ok(()) }, From 3d45ffa54bd3c89306f82e6e80f456aba7505004 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 00:52:44 +0900 Subject: [PATCH 30/55] fix: check doctest 7 Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 73d22c341..4db6057d5 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -491,12 +491,12 @@ impl Dag { subscribe_topic_names: &[Cow<'static, str>], publish_topic_names: &[Cow<'static, str>], ) -> NodeIndex { - add_node_with_topic_edges(dag, subscribe_topic_names, publish_topic_names) + dag.add_node_with_topic_edges(subscribe_topic_names, publish_topic_names) } //for test pub fn set_relative_deadline_public(dag: &Arc, node_idx: NodeIndex, deadline: Duration) { - set_relative_deadline(dag, node_idx, deadline) + dag.set_relative_deadline(node_idx, deadline) } } From 038c4f9a04d2b0da7e3cf8cec0ba4fb9970ff847 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 01:07:41 +0900 Subject: [PATCH 31/55] fix: check doctest 8 Signed-off-by: nokosaaan --- awkernel_async_lib/src/task.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index fd4017ee5..261003de8 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -393,6 +393,7 @@ pub fn spawn( /// use core::time::Duration; /// let dag = create_dag(); /// let sink_node_idx = add_node_with_topic_edges_public(&dag, &[], &[]); +/// let deadline = Duration::from_millis(100); /// set_relative_deadline_public(&dag, sink_node_idx, deadline); /// let task_id = task::spawn_with_dag_info( /// "dag task".into(), From 3bbb845384d7ac22ac8b2dc730a03ccdaaf606d3 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 01:11:09 +0900 Subject: [PATCH 32/55] fix: check cargo fmt 3 Signed-off-by: nokosaaan --- awkernel_async_lib/src/task.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 261003de8..96fae4aa3 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -393,7 +393,7 @@ pub fn spawn( /// use core::time::Duration; /// let dag = create_dag(); /// let sink_node_idx = add_node_with_topic_edges_public(&dag, &[], &[]); -/// let deadline = Duration::from_millis(100); +/// let deadline = Duration::from_millis(100); /// set_relative_deadline_public(&dag, sink_node_idx, deadline); /// let task_id = task::spawn_with_dag_info( /// "dag task".into(), From 20169290b03bfcc7bb73c7e33007a72c03361475 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 01:25:01 +0900 Subject: [PATCH 33/55] fix: check doctest 9 Signed-off-by: nokosaaan --- awkernel_async_lib/src/task.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 96fae4aa3..ff3a6e8f1 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -389,8 +389,9 @@ pub fn spawn( /// # Example /// /// ``` -/// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::{create_dag, add_node_with_topic_edges_public, set_relative_deadline_public}}; +/// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::create_dag; /// use core::time::Duration; +/// use crate::dag::{add_node_with_topic_edges_public, set_relative_deadline_public} /// let dag = create_dag(); /// let sink_node_idx = add_node_with_topic_edges_public(&dag, &[], &[]); /// let deadline = Duration::from_millis(100); From daf56e98e7123f3b7e9c2e2cdd1aafd89a1a2929 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 01:31:56 +0900 Subject: [PATCH 34/55] fix: check doctest 10 Signed-off-by: nokosaaan --- awkernel_async_lib/src/task.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index ff3a6e8f1..720a78799 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -389,9 +389,9 @@ pub fn spawn( /// # Example /// /// ``` -/// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::create_dag; +/// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::create_dag}; /// use core::time::Duration; -/// use crate::dag::{add_node_with_topic_edges_public, set_relative_deadline_public} +/// use crate::dag::{add_node_with_topic_edges_public, set_relative_deadline_public}; /// let dag = create_dag(); /// let sink_node_idx = add_node_with_topic_edges_public(&dag, &[], &[]); /// let deadline = Duration::from_millis(100); From 7dd440db28952605944c693d0528341d7702ea2b Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 01:42:51 +0900 Subject: [PATCH 35/55] fix: check doctest 11 Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 28 ++++++++++++++-------------- awkernel_async_lib/src/task.rs | 3 +-- 2 files changed, 15 insertions(+), 16 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 4db6057d5..76be527d6 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -484,20 +484,6 @@ impl Dag { let absolute_deadline = self.absolute_deadline.lock(&mut node); *absolute_deadline } - - // for test - pub fn add_node_with_topic_edges_public( - dag: &Arc, - subscribe_topic_names: &[Cow<'static, str>], - publish_topic_names: &[Cow<'static, str>], - ) -> NodeIndex { - dag.add_node_with_topic_edges(subscribe_topic_names, publish_topic_names) - } - - //for test - pub fn set_relative_deadline_public(dag: &Arc, node_idx: NodeIndex, deadline: Duration) { - dag.set_relative_deadline(node_idx, deadline) - } } struct PendingTask { @@ -605,6 +591,20 @@ pub fn set_dag_absolute_deadline(dag_id: u32, deadline: u64) -> bool { } } +// for test +pub fn add_node_with_topic_edges_public( + dag: &Arc, + subscribe_topic_names: &[Cow<'static, str>], + publish_topic_names: &[Cow<'static, str>], +) -> NodeIndex { + dag.add_node_with_topic_edges(subscribe_topic_names, publish_topic_names) +} + +//for test +pub fn set_relative_deadline_public(dag: &Arc, node_idx: NodeIndex, deadline: Duration) { + dag.set_relative_deadline(node_idx, deadline) +} + pub async fn finish_create_dags(dags: &[Arc]) -> Result<(), Vec> { match validate_all_rules(dags) { Ok(()) => { diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 720a78799..64737fec2 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -389,9 +389,8 @@ pub fn spawn( /// # Example /// /// ``` -/// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::create_dag}; +/// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::*}; /// use core::time::Duration; -/// use crate::dag::{add_node_with_topic_edges_public, set_relative_deadline_public}; /// let dag = create_dag(); /// let sink_node_idx = add_node_with_topic_edges_public(&dag, &[], &[]); /// let deadline = Duration::from_millis(100); From 7ed605316dc15c44c8375ab9fe9b5117462856ae Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 01:50:22 +0900 Subject: [PATCH 36/55] fix: fix unnecessary imports Signed-off-by: nokosaaan --- awkernel_async_lib/src/task.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 64737fec2..96fae4aa3 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -389,7 +389,7 @@ pub fn spawn( /// # Example /// /// ``` -/// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::*}; +/// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::{create_dag, add_node_with_topic_edges_public, set_relative_deadline_public}}; /// use core::time::Duration; /// let dag = create_dag(); /// let sink_node_idx = add_node_with_topic_edges_public(&dag, &[], &[]); From 7f347d0187930f7446427273f6466578633c8196 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 02:03:42 +0900 Subject: [PATCH 37/55] fix: reset the LOG_ENABLE flag to its original state Signed-off-by: nokosaaan --- applications/tests/test_dag/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/applications/tests/test_dag/src/lib.rs b/applications/tests/test_dag/src/lib.rs index 9ec1646be..7e799f694 100644 --- a/applications/tests/test_dag/src/lib.rs +++ b/applications/tests/test_dag/src/lib.rs @@ -7,7 +7,7 @@ use awkernel_async_lib::scheduler::SchedulerType; use awkernel_lib::delay::wait_microsec; use core::time::Duration; -const LOG_ENABLE: bool = true; +const LOG_ENABLE: bool = false; pub async fn run() { wait_microsec(1000000); From d1641294017f4462af490674ccd44d0c2d8c79cd Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 02:52:58 +0900 Subject: [PATCH 38/55] fix: delete unnecessary functions Signed-off-by: nokosaaan --- awkernel_async_lib/src/task.rs | 27 --------------------------- 1 file changed, 27 deletions(-) diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 96fae4aa3..48a3400b1 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -1014,33 +1014,6 @@ pub fn get_scheduler_type_by_task_id(task_id: u32) -> Option { }) } -#[inline(always)] -pub fn get_dag_info_by_task_id(task_id: u32) -> Option<(u32, u32)> { - let mut node = MCSNode::new(); - let tasks = TASKS.lock(&mut node); - - tasks.id_to_task.get(&task_id).map(|task| { - let mut node = MCSNode::new(); - let info = task.info.lock(&mut node); - info.get_dag_info() - })? -} - -#[inline(always)] -pub fn set_dag_info_by_task_id(task_id: u32, dag_id: u32, node_index: u32) -> bool { - let mut node = MCSNode::new(); - let tasks = TASKS.lock(&mut node); - - if let Some(task) = tasks.id_to_task.get(&task_id) { - let mut node = MCSNode::new(); - let mut info = task.info.lock(&mut node); - info.set_dag_info(dag_id, node_index); - true - } else { - false - } -} - #[inline(always)] pub fn set_need_preemption(task_id: u32, cpu_id: usize) { let mut node = MCSNode::new(); From c45c4654bcb6d33c72f9a73330e9553740bf5c2b Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 03:00:44 +0900 Subject: [PATCH 39/55] fix: delete unnecessary functions 2 Signed-off-by: nokosaaan --- awkernel_async_lib/src/task.rs | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 48a3400b1..1b852d2eb 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -221,20 +221,6 @@ impl TaskInfo { pub fn panicked(&self) -> bool { self.panicked } - - #[inline(always)] - pub fn set_dag_info(&mut self, dag_id: u32, node_index: u32) { - self.dag_id = Some(dag_id); - self.node_index = Some(node_index); - } - - #[inline(always)] - pub fn get_dag_info(&self) -> Option<(u32, u32)> { - match (self.dag_id, self.node_index) { - (Some(dag_id), Some(node_index)) => Some((dag_id, node_index)), - _ => None, - } - } } /// State of task. From 1839e8f19380c67a87f41d4ab3115e58022a6f09 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Sun, 7 Sep 2025 03:04:31 +0900 Subject: [PATCH 40/55] fix: delete unnecessary functions 3 Signed-off-by: nokosaaan --- awkernel_async_lib/src/task.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 1b852d2eb..4bcb63b4d 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -221,6 +221,14 @@ impl TaskInfo { pub fn panicked(&self) -> bool { self.panicked } + + #[inline(always)] + pub fn get_dag_info(&self) -> Option<(u32, u32)> { + match (self.dag_id, self.node_index) { + (Some(dag_id), Some(node_index)) => Some((dag_id, node_index)), + _ => None, + } + } } /// State of task. From a513772e0801246bd63d0b9e9362d3954cc761f8 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Wed, 17 Sep 2025 11:42:18 +0900 Subject: [PATCH 41/55] fix: implement gedf Signed-off-by: nokosaaan --- applications/tests/test_dag/src/lib.rs | 12 ++--- awkernel_async_lib/src/dag.rs | 28 ++++------- awkernel_async_lib/src/scheduler/gedf.rs | 4 +- awkernel_async_lib/src/task.rs | 60 ++++++++++-------------- 4 files changed, 41 insertions(+), 63 deletions(-) diff --git a/applications/tests/test_dag/src/lib.rs b/applications/tests/test_dag/src/lib.rs index 7e799f694..e2562f508 100644 --- a/applications/tests/test_dag/src/lib.rs +++ b/applications/tests/test_dag/src/lib.rs @@ -7,7 +7,7 @@ use awkernel_async_lib::scheduler::SchedulerType; use awkernel_lib::delay::wait_microsec; use core::time::Duration; -const LOG_ENABLE: bool = false; +const LOG_ENABLE: bool = true; pub async fn run() { wait_microsec(1000000); @@ -30,7 +30,7 @@ pub async fn run() { (number,) }, vec![Cow::from("topic0")], - SchedulerType::PrioritizedFIFO(30), + SchedulerType::GEDF(0), period, ) .await; @@ -47,7 +47,7 @@ pub async fn run() { }, vec![Cow::from("topic0")], vec![Cow::from("topic1"), Cow::from("topic2")], - SchedulerType::PrioritizedFIFO(0), + SchedulerType::GEDF(0), ) .await; @@ -62,7 +62,7 @@ pub async fn run() { }, vec![Cow::from("topic1")], vec![Cow::from("topic3")], - SchedulerType::PrioritizedFIFO(0), + SchedulerType::GEDF(0), ) .await; @@ -77,7 +77,7 @@ pub async fn run() { }, vec![Cow::from("topic2")], vec![Cow::from("topic4")], - SchedulerType::PrioritizedFIFO(0), + SchedulerType::GEDF(0), ) .await; @@ -90,7 +90,7 @@ pub async fn run() { } }, vec![Cow::from("topic3"), Cow::from("topic4")], - SchedulerType::PrioritizedFIFO(0), + SchedulerType::GEDF(0), Duration::from_secs(1), ) .await; diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 76be527d6..b96d7eb03 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -54,6 +54,7 @@ mod visit; mod performance; use crate::{ + task::DagInfo, dag::{ graph::{ algo::{connected_components, is_cyclic_directed}, @@ -319,7 +320,7 @@ impl Dag { subscribe_topic_names, publish_topic_names, sched_type, - Some((dag_id, node_index)), + DagInfo { dag_id, node_index }, ) .await }) @@ -370,7 +371,7 @@ impl Dag { sched_type, period, measure_f, - Some((dag_id, node_index)), + DagInfo { dag_id, node_index } ) .await }) @@ -428,7 +429,7 @@ impl Dag { measure_f, subscribe_topic_names, sched_type, - Some((dag_id, node_index)), + DagInfo { dag_id, node_index }, ) .await }) @@ -513,6 +514,7 @@ struct NodeInfo { pub fn to_node_index(index: u32) -> NodeIndex { NodeIndex::new(index as usize) } + struct EdgeInfo { topic_name: Cow<'static, str>, } @@ -591,20 +593,6 @@ pub fn set_dag_absolute_deadline(dag_id: u32, deadline: u64) -> bool { } } -// for test -pub fn add_node_with_topic_edges_public( - dag: &Arc, - subscribe_topic_names: &[Cow<'static, str>], - publish_topic_names: &[Cow<'static, str>], -) -> NodeIndex { - dag.add_node_with_topic_edges(subscribe_topic_names, publish_topic_names) -} - -//for test -pub fn set_relative_deadline_public(dag: &Arc, node_idx: NodeIndex, deadline: Duration) { - dag.set_relative_deadline(node_idx, deadline) -} - pub async fn finish_create_dags(dags: &[Arc]) -> Result<(), Vec> { match validate_all_rules(dags) { Ok(()) => { @@ -913,7 +901,7 @@ async fn spawn_reactor( subscribe_topic_names: Vec>, publish_topic_names: Vec>, sched_type: SchedulerType, - dag_info: Option<(u32, u32)>, + dag_info: DagInfo, ) -> u32 where F: Fn( @@ -953,7 +941,7 @@ async fn spawn_periodic_reactor( sched_type: SchedulerType, period: Duration, _release_measure: Option, - dag_info: Option<(u32, u32)>, + dag_info: DagInfo, ) -> u32 where F: Fn() -> ::Item + Send + 'static, @@ -1004,7 +992,7 @@ async fn spawn_sink_reactor( f: F, subscribe_topic_names: Vec>, sched_type: SchedulerType, - dag_info: Option<(u32, u32)>, + dag_info: DagInfo, ) -> u32 where F: Fn(::Item) + Send + 'static, diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 9997eaadd..555bd3cab 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -78,7 +78,9 @@ impl Scheduler for GEDFScheduler { let wake_time = awkernel_lib::delay::uptime(); let absolute_deadline; - if let Some((dag_id, node_index)) = dag_info { + if let Some(dag_info) = dag_info { + let dag_id = dag_info.dag_id; + let node_index = dag_info.node_index; if get_dag_absolute_deadline(dag_id).is_none() { let dag = get_dag(dag_id).expect("GEDF scheduler: DAG {dag_id} not found"); diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 4bcb63b4d..64e7d52b5 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -157,8 +157,7 @@ pub struct TaskInfo { need_sched: bool, pub(crate) need_preemption: bool, panicked: bool, - pub(crate) dag_id: Option, - pub(crate) node_index: Option, + pub(crate) dag_info: Option, #[cfg(not(feature = "no_preempt"))] thread: Option, @@ -223,11 +222,8 @@ impl TaskInfo { } #[inline(always)] - pub fn get_dag_info(&self) -> Option<(u32, u32)> { - match (self.dag_id, self.node_index) { - (Some(dag_id), Some(node_index)) => Some((dag_id, node_index)), - _ => None, - } + pub fn get_dag_info(&self) -> Option { + self.dag_info.clone() } } @@ -250,6 +246,12 @@ struct Tasks { id_to_task: BTreeMap>, } +#[derive(Clone)] +pub struct DagInfo { + pub dag_id: u32, + pub node_index: u32, +} + impl Tasks { const fn new() -> Self { Self { @@ -264,7 +266,7 @@ impl Tasks { future: Fuse>, scheduler: &'static dyn Scheduler, scheduler_type: SchedulerType, - dag_info: Option<(u32, u32)>, + dag_info: Option, ) -> u32 { let mut id = self.candidate_id; loop { @@ -283,8 +285,7 @@ impl Tasks { need_sched: false, need_preemption: false, panicked: false, - dag_id: dag_info.map(|(d, _)| d), - node_index: dag_info.map(|(_, n)| n), + dag_info, #[cfg(not(feature = "no_preempt"))] thread: None, @@ -351,29 +352,7 @@ pub fn spawn( future: impl Future + 'static + Send, sched_type: SchedulerType, ) -> u32 { - if let SchedulerType::PrioritizedFIFO(p) | SchedulerType::PrioritizedRR(p) = sched_type { - if p > HIGHEST_PRIORITY { - log::warn!( - "Task priority should be between 0 and {HIGHEST_PRIORITY}. It is addressed as {HIGHEST_PRIORITY}." - ); - } - } - - let future = future.boxed(); - - let scheduler = get_scheduler(sched_type); - - let mut node = MCSNode::new(); - let mut tasks = TASKS.lock(&mut node); - let id = tasks.spawn(name, future.fuse(), scheduler, sched_type, None); - let task = tasks.id_to_task.get(&id).cloned(); - drop(tasks); - - if let Some(task) = task { - task.wake(); - } - - id + inner_spawn(name, future, sched_type, None) } /// Spawn a detached task with DAG information. @@ -382,7 +361,7 @@ pub fn spawn( /// /// # Example /// -/// ``` +/// ```ignore /// use awkernel_async_lib::{scheduler::SchedulerType, task, dag::{create_dag, add_node_with_topic_edges_public, set_relative_deadline_public}}; /// use core::time::Duration; /// let dag = create_dag(); @@ -393,14 +372,23 @@ pub fn spawn( /// "dag task".into(), /// async { Ok(()) }, /// SchedulerType::GEDF(0), -/// Some((1, 0)) // dag_info as Option<(u32, u32)> +/// DagInfo { dag_id: 1, node_index: 0 } /// ); /// ``` pub fn spawn_with_dag_info( name: Cow<'static, str>, future: impl Future + 'static + Send, sched_type: SchedulerType, - dag_info: Option<(u32, u32)>, + dag_info: DagInfo, +) -> u32 { + inner_spawn(name, future, sched_type, Some(dag_info)) +} + +pub fn inner_spawn( + name: Cow<'static, str>, + future: impl Future + 'static + Send, + sched_type: SchedulerType, + dag_info: Option, ) -> u32 { if let SchedulerType::PrioritizedFIFO(p) | SchedulerType::PrioritizedRR(p) = sched_type { if p > HIGHEST_PRIORITY { From 25a8f8e66917915d9ee9e6a4c34d52d53f159a43 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Wed, 17 Sep 2025 11:47:08 +0900 Subject: [PATCH 42/55] fix: check cargo fmt 4 Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index b96d7eb03..a02740c82 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -54,7 +54,6 @@ mod visit; mod performance; use crate::{ - task::DagInfo, dag::{ graph::{ algo::{connected_components, is_cyclic_directed}, @@ -64,6 +63,7 @@ use crate::{ visit::{EdgeRef, IntoNodeReferences, NodeRef}, }, scheduler::SchedulerType, + task::DagInfo, time_interval::interval, Attribute, MultipleReceiver, MultipleSender, VectorToPublishers, VectorToSubscribers, }; @@ -371,7 +371,7 @@ impl Dag { sched_type, period, measure_f, - DagInfo { dag_id, node_index } + DagInfo { dag_id, node_index }, ) .await }) From a5a61a9821584df375ff1122e0b8e1b9330d5cfa Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 18 Sep 2025 17:35:21 +0900 Subject: [PATCH 43/55] fix: refactored the nested sections using helper functions Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 78 ++++++++++++------------ 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 555bd3cab..8a00341a2 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -7,7 +7,7 @@ use crate::{ dag::{get_dag, get_dag_absolute_deadline, set_dag_absolute_deadline, to_node_index}, scheduler::{get_priority, peek_preemption_pending, push_preemption_pending}, task::{ - get_task, get_tasks_running, set_current_task, set_need_preemption, State, + get_task, get_tasks_running, set_current_task, set_need_preemption, DagInfo, State, MAX_TASK_PRIORITY, }, }; @@ -76,45 +76,11 @@ impl Scheduler for GEDFScheduler { match info.scheduler_type { SchedulerType::GEDF(relative_deadline) => { let wake_time = awkernel_lib::delay::uptime(); - let absolute_deadline; - - if let Some(dag_info) = dag_info { - let dag_id = dag_info.dag_id; - let node_index = dag_info.node_index; - if get_dag_absolute_deadline(dag_id).is_none() { - let dag = - get_dag(dag_id).expect("GEDF scheduler: DAG {dag_id} not found"); - let relative_deadline_ms = dag - .get_sink_relative_deadline() - .map(|deadline| deadline.as_millis() as u64) - .unwrap_or_else(|| { - panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); - }); - absolute_deadline = wake_time + relative_deadline_ms; - set_dag_absolute_deadline(dag_id, absolute_deadline); - } else { - let dag = - get_dag(dag_id).expect("GEDF scheduler: DAG {dag_id} not found"); - // Use `to_node_index` to convert the u32 type to NodeIndex - // for use with the method that determines whether it is a source node. - let current_node_index = to_node_index(node_index); - let is_source_node = dag.is_source_node(current_node_index); - if is_source_node { - let relative_deadline_ms = dag.get_sink_relative_deadline() - .map(|deadline| deadline.as_millis() as u64) - .unwrap_or_else(|| { - panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); - }); - absolute_deadline = wake_time + relative_deadline_ms; - set_dag_absolute_deadline(dag_id, absolute_deadline); - } else { - absolute_deadline = get_dag_absolute_deadline(dag_id).unwrap(); - } - } + let absolute_deadline = if let Some(ref dag_info) = dag_info { + calculate_and_update_dag_deadline(dag_info, wake_time) } else { - log::debug!("GEDF scheduler: Task {} DAG info not yet set, using provided relative_deadline: {}", task.id, relative_deadline); - absolute_deadline = wake_time + relative_deadline; - } + wake_time + relative_deadline + }; task.priority .update_priority_info(self.priority, MAX_TASK_PRIORITY - absolute_deadline); @@ -225,3 +191,37 @@ impl GEDFScheduler { false } } + +pub fn calculate_and_update_dag_deadline(dag_info: &DagInfo, wake_time: u64) -> u64 { + let dag_id = dag_info.dag_id; + let node_index = dag_info.node_index; + + if get_dag_absolute_deadline(dag_id).is_none() { + let dag = get_dag(dag_id).expect("GEDF scheduler: DAG {dag_id} not found"); + let relative_deadline_ms = dag + .get_sink_relative_deadline() + .map(|deadline| deadline.as_millis() as u64) + .unwrap_or_else(|| { + panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); + }); + let absolute_deadline = wake_time + relative_deadline_ms; + set_dag_absolute_deadline(dag_id, absolute_deadline); + absolute_deadline + } else { + let dag = get_dag(dag_id).expect("GEDF scheduler: DAG {dag_id} not found"); + let current_node_index = to_node_index(node_index); + if dag.is_source_node(current_node_index) { + let relative_deadline_ms = dag + .get_sink_relative_deadline() + .map(|deadline| deadline.as_millis() as u64) + .unwrap_or_else(|| { + panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); + }); + let absolute_deadline = wake_time + relative_deadline_ms; + set_dag_absolute_deadline(dag_id, absolute_deadline); + absolute_deadline + } else { + get_dag_absolute_deadline(dag_id).unwrap() + } + } +} From 46b7c0a0bd946ef258fa94142291c81fbd7a29cc Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 18 Sep 2025 18:05:54 +0900 Subject: [PATCH 44/55] fix: reduced nested structure using early return Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 40 ++++++++++++------------ 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 8a00341a2..e65d6f603 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -196,32 +196,32 @@ pub fn calculate_and_update_dag_deadline(dag_info: &DagInfo, wake_time: u64) -> let dag_id = dag_info.dag_id; let node_index = dag_info.node_index; - if get_dag_absolute_deadline(dag_id).is_none() { + if let Some(absolute_deadline) = get_dag_absolute_deadline(dag_id) { let dag = get_dag(dag_id).expect("GEDF scheduler: DAG {dag_id} not found"); + let current_node_index = to_node_index(node_index); + if !dag.is_source_node(current_node_index) { + return absolute_deadline; + } + let relative_deadline_ms = dag .get_sink_relative_deadline() .map(|deadline| deadline.as_millis() as u64) .unwrap_or_else(|| { panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); }); - let absolute_deadline = wake_time + relative_deadline_ms; - set_dag_absolute_deadline(dag_id, absolute_deadline); - absolute_deadline - } else { - let dag = get_dag(dag_id).expect("GEDF scheduler: DAG {dag_id} not found"); - let current_node_index = to_node_index(node_index); - if dag.is_source_node(current_node_index) { - let relative_deadline_ms = dag - .get_sink_relative_deadline() - .map(|deadline| deadline.as_millis() as u64) - .unwrap_or_else(|| { - panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); - }); - let absolute_deadline = wake_time + relative_deadline_ms; - set_dag_absolute_deadline(dag_id, absolute_deadline); - absolute_deadline - } else { - get_dag_absolute_deadline(dag_id).unwrap() - } + let dag_absolute_deadline = wake_time + relative_deadline_ms; + set_dag_absolute_deadline(dag_id, dag_absolute_deadline); + return dag_absolute_deadline; } + + let dag = get_dag(dag_id).expect("GEDF scheduler: DAG {dag_id} not found"); + let relative_deadline_ms = dag + .get_sink_relative_deadline() + .map(|deadline| deadline.as_millis() as u64) + .unwrap_or_else(|| { + panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); + }); + let dag_absolute_deadline = wake_time + relative_deadline_ms; + set_dag_absolute_deadline(dag_id, dag_absolute_deadline); + dag_absolute_deadline } From d8d48f71bea62bf614f2016866107ad2b3c58f12 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 25 Sep 2025 11:25:26 +0900 Subject: [PATCH 45/55] fix: adding a function and code optimization Signed-off-by: nokosaaan --- applications/tests/test_dag/src/lib.rs | 10 ++++----- awkernel_async_lib/src/dag.rs | 7 +++--- awkernel_async_lib/src/scheduler/gedf.rs | 28 +++++++++++------------- 3 files changed, 21 insertions(+), 24 deletions(-) diff --git a/applications/tests/test_dag/src/lib.rs b/applications/tests/test_dag/src/lib.rs index e2562f508..a7330457f 100644 --- a/applications/tests/test_dag/src/lib.rs +++ b/applications/tests/test_dag/src/lib.rs @@ -30,7 +30,7 @@ pub async fn run() { (number,) }, vec![Cow::from("topic0")], - SchedulerType::GEDF(0), + SchedulerType::GEDF(5), period, ) .await; @@ -47,7 +47,7 @@ pub async fn run() { }, vec![Cow::from("topic0")], vec![Cow::from("topic1"), Cow::from("topic2")], - SchedulerType::GEDF(0), + SchedulerType::GEDF(10), ) .await; @@ -62,7 +62,7 @@ pub async fn run() { }, vec![Cow::from("topic1")], vec![Cow::from("topic3")], - SchedulerType::GEDF(0), + SchedulerType::GEDF(10), ) .await; @@ -77,7 +77,7 @@ pub async fn run() { }, vec![Cow::from("topic2")], vec![Cow::from("topic4")], - SchedulerType::GEDF(0), + SchedulerType::GEDF(10), ) .await; @@ -90,7 +90,7 @@ pub async fn run() { } }, vec![Cow::from("topic3"), Cow::from("topic4")], - SchedulerType::GEDF(0), + SchedulerType::GEDF(10), Duration::from_secs(1), ) .await; diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index a02740c82..d43b688d2 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -197,13 +197,12 @@ impl Dag { source_nodes.contains(&node_index) } + // Returns the relative deadline of the sink node, if it exists. pub fn get_sink_relative_deadline(&self) -> Option { - let mut node = MCSNode::new(); - let graph = self.graph.lock(&mut node); - let sink_nodes: Vec = graph.externals(Direction::Outgoing).collect(); + let sink_nodes: Vec = self.get_sink_nodes(); if let Some(sink_node_index) = sink_nodes.first() { - graph.node_weight(*sink_node_index)?.relative_deadline + self.graph.lock(&mut MCSNode::new()).node_weight(*sink_node_index)?.relative_deadline } else { None } diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index e65d6f603..e7af2fb33 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -11,7 +11,7 @@ use crate::{ MAX_TASK_PRIORITY, }, }; -use alloc::{collections::BinaryHeap, sync::Arc, vec::Vec}; +use alloc::{collections::BinaryHeap, sync::Arc, vec::Vec, format}; use awkernel_lib::sync::mutex::{MCSNode, Mutex}; pub struct GEDFScheduler { @@ -192,35 +192,33 @@ impl GEDFScheduler { } } +fn get_dag_sink_relative_deadline_ms(dag_id: u32) -> u64 { + let dag = get_dag(dag_id).expect(&format!("GEDF scheduler: DAG {} not found", dag_id)); + dag.get_sink_relative_deadline() + .map(|deadline| deadline.as_millis() as u64) + .unwrap_or_else(|| { + panic!("GEDF scheduler: DAG {} has no sink relative deadline set", dag_id); + }) +} + pub fn calculate_and_update_dag_deadline(dag_info: &DagInfo, wake_time: u64) -> u64 { let dag_id = dag_info.dag_id; let node_index = dag_info.node_index; if let Some(absolute_deadline) = get_dag_absolute_deadline(dag_id) { - let dag = get_dag(dag_id).expect("GEDF scheduler: DAG {dag_id} not found"); + let dag = get_dag(dag_id).expect(&format!("GEDF scheduler: DAG {} not found", dag_id)); let current_node_index = to_node_index(node_index); if !dag.is_source_node(current_node_index) { return absolute_deadline; } - let relative_deadline_ms = dag - .get_sink_relative_deadline() - .map(|deadline| deadline.as_millis() as u64) - .unwrap_or_else(|| { - panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); - }); + let relative_deadline_ms = get_dag_sink_relative_deadline_ms(dag_id); let dag_absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, dag_absolute_deadline); return dag_absolute_deadline; } - let dag = get_dag(dag_id).expect("GEDF scheduler: DAG {dag_id} not found"); - let relative_deadline_ms = dag - .get_sink_relative_deadline() - .map(|deadline| deadline.as_millis() as u64) - .unwrap_or_else(|| { - panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set"); - }); + let relative_deadline_ms = get_dag_sink_relative_deadline_ms(dag_id); let dag_absolute_deadline = wake_time + relative_deadline_ms; set_dag_absolute_deadline(dag_id, dag_absolute_deadline); dag_absolute_deadline From 8cc80915542fc82a8495ba57ecc66b35cd7f3040 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 25 Sep 2025 11:27:54 +0900 Subject: [PATCH 46/55] fix: check cargo fmt 5 Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 5 ++++- awkernel_async_lib/src/scheduler/gedf.rs | 7 +++++-- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index d43b688d2..1b42c0938 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -202,7 +202,10 @@ impl Dag { let sink_nodes: Vec = self.get_sink_nodes(); if let Some(sink_node_index) = sink_nodes.first() { - self.graph.lock(&mut MCSNode::new()).node_weight(*sink_node_index)?.relative_deadline + self.graph + .lock(&mut MCSNode::new()) + .node_weight(*sink_node_index)? + .relative_deadline } else { None } diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index e7af2fb33..17838d205 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -11,7 +11,7 @@ use crate::{ MAX_TASK_PRIORITY, }, }; -use alloc::{collections::BinaryHeap, sync::Arc, vec::Vec, format}; +use alloc::{collections::BinaryHeap, format, sync::Arc, vec::Vec}; use awkernel_lib::sync::mutex::{MCSNode, Mutex}; pub struct GEDFScheduler { @@ -197,7 +197,10 @@ fn get_dag_sink_relative_deadline_ms(dag_id: u32) -> u64 { dag.get_sink_relative_deadline() .map(|deadline| deadline.as_millis() as u64) .unwrap_or_else(|| { - panic!("GEDF scheduler: DAG {} has no sink relative deadline set", dag_id); + panic!( + "GEDF scheduler: DAG {} has no sink relative deadline set", + dag_id + ); }) } From 02efdf2a02c80ede94960b2b1d72c0ff4cc8944c Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 25 Sep 2025 11:31:23 +0900 Subject: [PATCH 47/55] fix: add a comment in dag.rs Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 1b42c0938..51666dd48 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -197,7 +197,7 @@ impl Dag { source_nodes.contains(&node_index) } - // Returns the relative deadline of the sink node, if it exists. + // Returns the relative deadline of the first sink node, if it exists. pub fn get_sink_relative_deadline(&self) -> Option { let sink_nodes: Vec = self.get_sink_nodes(); From dc1771ef7bbcbfd4376f2ed729f488a825433925 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 25 Sep 2025 11:42:11 +0900 Subject: [PATCH 48/55] fix: format! error Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 17838d205..3d26efbf4 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -193,7 +193,7 @@ impl GEDFScheduler { } fn get_dag_sink_relative_deadline_ms(dag_id: u32) -> u64 { - let dag = get_dag(dag_id).expect(&format!("GEDF scheduler: DAG {} not found", dag_id)); + let dag = get_dag(dag_id).expect(&format!("GEDF scheduler: DAG {dag_id} not found")); dag.get_sink_relative_deadline() .map(|deadline| deadline.as_millis() as u64) .unwrap_or_else(|| { @@ -209,7 +209,7 @@ pub fn calculate_and_update_dag_deadline(dag_info: &DagInfo, wake_time: u64) -> let node_index = dag_info.node_index; if let Some(absolute_deadline) = get_dag_absolute_deadline(dag_id) { - let dag = get_dag(dag_id).expect(&format!("GEDF scheduler: DAG {} not found", dag_id)); + let dag = get_dag(dag_id).expect(&format!("GEDF scheduler: DAG {dag_id} not found")); let current_node_index = to_node_index(node_index); if !dag.is_source_node(current_node_index) { return absolute_deadline; From 7d654bb8934ac233a4aedc477b941d06d1120208 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 25 Sep 2025 11:48:29 +0900 Subject: [PATCH 49/55] fix: To resolve the build error, I used unwrap_or_else instead of expect. Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 3d26efbf4..efd2217c4 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -193,7 +193,7 @@ impl GEDFScheduler { } fn get_dag_sink_relative_deadline_ms(dag_id: u32) -> u64 { - let dag = get_dag(dag_id).expect(&format!("GEDF scheduler: DAG {dag_id} not found")); + let dag = get_dag(dag_id).unwrap_or_else(|| panic!("GEDF scheduler: DAG {dag_id} not found")); dag.get_sink_relative_deadline() .map(|deadline| deadline.as_millis() as u64) .unwrap_or_else(|| { @@ -209,7 +209,8 @@ pub fn calculate_and_update_dag_deadline(dag_info: &DagInfo, wake_time: u64) -> let node_index = dag_info.node_index; if let Some(absolute_deadline) = get_dag_absolute_deadline(dag_id) { - let dag = get_dag(dag_id).expect(&format!("GEDF scheduler: DAG {dag_id} not found")); + let dag = + get_dag(dag_id).unwrap_or_else(|| panic!("GEDF scheduler: DAG {dag_id} not found")); let current_node_index = to_node_index(node_index); if !dag.is_source_node(current_node_index) { return absolute_deadline; From 5334ba7da05b88d0bae20325298ce949e7947cf6 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 25 Sep 2025 12:04:00 +0900 Subject: [PATCH 50/55] fix: delete unnecessary import Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index efd2217c4..bdd274a72 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -11,7 +11,7 @@ use crate::{ MAX_TASK_PRIORITY, }, }; -use alloc::{collections::BinaryHeap, format, sync::Arc, vec::Vec}; +use alloc::{collections::BinaryHeap, sync::Arc, vec::Vec}; use awkernel_lib::sync::mutex::{MCSNode, Mutex}; pub struct GEDFScheduler { From 9ef5a1bf8836cfd63ef20ba310099dea384caa93 Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 25 Sep 2025 12:10:24 +0900 Subject: [PATCH 51/55] fix: delete semicolon Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index bdd274a72..1169ce3b7 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -200,7 +200,7 @@ fn get_dag_sink_relative_deadline_ms(dag_id: u32) -> u64 { panic!( "GEDF scheduler: DAG {} has no sink relative deadline set", dag_id - ); + ) }) } From 4c1d6290a74c417e1656f9a3ffcc96606b0d53df Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 25 Sep 2025 13:29:34 +0900 Subject: [PATCH 52/55] fix: panic! 2 Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 1169ce3b7..3b1805539 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -196,12 +196,7 @@ fn get_dag_sink_relative_deadline_ms(dag_id: u32) -> u64 { let dag = get_dag(dag_id).unwrap_or_else(|| panic!("GEDF scheduler: DAG {dag_id} not found")); dag.get_sink_relative_deadline() .map(|deadline| deadline.as_millis() as u64) - .unwrap_or_else(|| { - panic!( - "GEDF scheduler: DAG {} has no sink relative deadline set", - dag_id - ) - }) + .unwrap_or_else(|| panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set")) } pub fn calculate_and_update_dag_deadline(dag_info: &DagInfo, wake_time: u64) -> u64 { From 3e20931da064c0905bcaa56bc0b9dc2027ec259e Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 25 Sep 2025 18:18:36 +0900 Subject: [PATCH 53/55] fix: unify the name index to id Signed-off-by: nokosaaan --- awkernel_async_lib/src/dag.rs | 12 ++++++------ awkernel_async_lib/src/scheduler/gedf.rs | 4 ++-- awkernel_async_lib/src/task.rs | 4 ++-- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/awkernel_async_lib/src/dag.rs b/awkernel_async_lib/src/dag.rs index 51666dd48..fa150a48f 100644 --- a/awkernel_async_lib/src/dag.rs +++ b/awkernel_async_lib/src/dag.rs @@ -307,7 +307,7 @@ impl Dag { // To prevent errors caused by ownership moves let dag_id = self.id; - let node_index = node_idx.index() as u32; + let node_id = node_idx.index() as u32; let mut node = MCSNode::new(); let mut pending_tasks = PENDING_TASKS.lock(&mut node); @@ -322,7 +322,7 @@ impl Dag { subscribe_topic_names, publish_topic_names, sched_type, - DagInfo { dag_id, node_index }, + DagInfo { dag_id, node_id }, ) .await }) @@ -358,7 +358,7 @@ impl Dag { // To prevent errors caused by ownership moves let dag_id = self.id; - let node_index = node_idx.index() as u32; + let node_id = node_idx.index() as u32; let mut node = MCSNode::new(); let mut source_pending_tasks = SOURCE_PENDING_TASKS.lock(&mut node); @@ -373,7 +373,7 @@ impl Dag { sched_type, period, measure_f, - DagInfo { dag_id, node_index }, + DagInfo { dag_id, node_id }, ) .await }) @@ -417,7 +417,7 @@ impl Dag { // To prevent errors caused by ownership moves let dag_id = self.id; - let node_index = node_idx.index() as u32; + let node_id = node_idx.index() as u32; let mut node = MCSNode::new(); let mut pending_tasks = PENDING_TASKS.lock(&mut node); @@ -431,7 +431,7 @@ impl Dag { measure_f, subscribe_topic_names, sched_type, - DagInfo { dag_id, node_index }, + DagInfo { dag_id, node_id }, ) .await }) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 3b1805539..a39ccaaed 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -201,12 +201,12 @@ fn get_dag_sink_relative_deadline_ms(dag_id: u32) -> u64 { pub fn calculate_and_update_dag_deadline(dag_info: &DagInfo, wake_time: u64) -> u64 { let dag_id = dag_info.dag_id; - let node_index = dag_info.node_index; + let node_id = dag_info.node_id; if let Some(absolute_deadline) = get_dag_absolute_deadline(dag_id) { let dag = get_dag(dag_id).unwrap_or_else(|| panic!("GEDF scheduler: DAG {dag_id} not found")); - let current_node_index = to_node_index(node_index); + let current_node_index = to_node_index(node_id); if !dag.is_source_node(current_node_index) { return absolute_deadline; } diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 64e7d52b5..6e4ee4636 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -249,7 +249,7 @@ struct Tasks { #[derive(Clone)] pub struct DagInfo { pub dag_id: u32, - pub node_index: u32, + pub node_id: u32, } impl Tasks { @@ -372,7 +372,7 @@ pub fn spawn( /// "dag task".into(), /// async { Ok(()) }, /// SchedulerType::GEDF(0), -/// DagInfo { dag_id: 1, node_index: 0 } +/// DagInfo { dag_id: 1, node_id: 0 } /// ); /// ``` pub fn spawn_with_dag_info( From 1d650ea3e661d57bcc03b3db6eb8c32815d3b84b Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 25 Sep 2025 19:57:26 +0900 Subject: [PATCH 54/55] fix: consolidated the duplicate processing and add a comment Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index a39ccaaed..866006021 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -79,6 +79,8 @@ impl Scheduler for GEDFScheduler { let absolute_deadline = if let Some(ref dag_info) = dag_info { calculate_and_update_dag_deadline(dag_info, wake_time) } 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 }; @@ -199,6 +201,13 @@ fn get_dag_sink_relative_deadline_ms(dag_id: u32) -> u64 { .unwrap_or_else(|| panic!("GEDF scheduler: DAG {dag_id} has no sink relative deadline set")) } +fn calculate_and_set_dag_deadline(dag_id: u32, wake_time: u64) -> u64 { + let relative_deadline_ms = get_dag_sink_relative_deadline_ms(dag_id); + let dag_absolute_deadline = wake_time + relative_deadline_ms; + set_dag_absolute_deadline(dag_id, dag_absolute_deadline); + dag_absolute_deadline +} + pub fn calculate_and_update_dag_deadline(dag_info: &DagInfo, wake_time: u64) -> u64 { let dag_id = dag_info.dag_id; let node_id = dag_info.node_id; @@ -211,14 +220,10 @@ pub fn calculate_and_update_dag_deadline(dag_info: &DagInfo, wake_time: u64) -> return absolute_deadline; } - let relative_deadline_ms = get_dag_sink_relative_deadline_ms(dag_id); - let dag_absolute_deadline = wake_time + relative_deadline_ms; - set_dag_absolute_deadline(dag_id, dag_absolute_deadline); + let dag_absolute_deadline = calculate_and_set_dag_deadline(dag_id, wake_time); return dag_absolute_deadline; } - let relative_deadline_ms = get_dag_sink_relative_deadline_ms(dag_id); - let dag_absolute_deadline = wake_time + relative_deadline_ms; - set_dag_absolute_deadline(dag_id, dag_absolute_deadline); + let dag_absolute_deadline = calculate_and_set_dag_deadline(dag_id, wake_time); dag_absolute_deadline } From 76038e7aab3ddfaa39837cb3758c14b9f40cc2ad Mon Sep 17 00:00:00 2001 From: nokosaaan Date: Thu, 25 Sep 2025 20:04:35 +0900 Subject: [PATCH 55/55] fix: solve let binding Signed-off-by: nokosaaan --- awkernel_async_lib/src/scheduler/gedf.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/awkernel_async_lib/src/scheduler/gedf.rs b/awkernel_async_lib/src/scheduler/gedf.rs index 866006021..82bacdde2 100644 --- a/awkernel_async_lib/src/scheduler/gedf.rs +++ b/awkernel_async_lib/src/scheduler/gedf.rs @@ -220,10 +220,8 @@ pub fn calculate_and_update_dag_deadline(dag_info: &DagInfo, wake_time: u64) -> return absolute_deadline; } - let dag_absolute_deadline = calculate_and_set_dag_deadline(dag_id, wake_time); - return dag_absolute_deadline; + return calculate_and_set_dag_deadline(dag_id, wake_time); } - let dag_absolute_deadline = calculate_and_set_dag_deadline(dag_id, wake_time); - dag_absolute_deadline + calculate_and_set_dag_deadline(dag_id, wake_time) }