From d2074afde6eaa8ea5af9d2912f924cc4353a60e3 Mon Sep 17 00:00:00 2001 From: Kanata9020 <270539432+Kanata9020@users.noreply.github.com> Date: Tue, 17 Nov 2026 16:28:07 +0900 Subject: [PATCH] feat(task): add per-task CPU frequency Add `task::spawn_with_freq()` to run a task at a given CPU frequency. A task without a frequency runs at the maximum, and an idle CPU runs at the minimum. The `dvfs` feature enables this. - Add `freq` to `TaskInfo`. - Add `awkernel_lib::dvfs::set_min_cpu_freq()`. - Add test_dvfs_task. --- applications/tests/test_dvfs_task/Cargo.toml | 15 +++ applications/tests/test_dvfs_task/src/lib.rs | 111 +++++++++++++++++++ awkernel_async_lib/Cargo.toml | 1 + awkernel_async_lib/src/task.rs | 86 +++++++++++++- awkernel_lib/src/dvfs.rs | 56 ++++++++++ kernel/Cargo.toml | 2 +- userland/Cargo.toml | 5 + userland/src/lib.rs | 3 + 8 files changed, 275 insertions(+), 4 deletions(-) create mode 100644 applications/tests/test_dvfs_task/Cargo.toml create mode 100644 applications/tests/test_dvfs_task/src/lib.rs diff --git a/applications/tests/test_dvfs_task/Cargo.toml b/applications/tests/test_dvfs_task/Cargo.toml new file mode 100644 index 000000000..797d49532 --- /dev/null +++ b/applications/tests/test_dvfs_task/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "test_dvfs_task" +version = "0.1.0" +edition = "2024" + +[dependencies] +log = "0.4" + +[dependencies.awkernel_async_lib] +path = "../../../awkernel_async_lib" +default-features = false + +[dependencies.awkernel_lib] +path = "../../../awkernel_lib" +default-features = false diff --git a/applications/tests/test_dvfs_task/src/lib.rs b/applications/tests/test_dvfs_task/src/lib.rs new file mode 100644 index 000000000..51083a929 --- /dev/null +++ b/applications/tests/test_dvfs_task/src/lib.rs @@ -0,0 +1,111 @@ +#![no_std] + +extern crate alloc; + +use core::{ + sync::atomic::{AtomicUsize, Ordering}, + time::Duration, +}; + +use awkernel_async_lib::{ + scheduler::SchedulerType, + task::{self, TaskResult}, +}; +use awkernel_lib::{ + cpu::{CpuSet, num_cpu}, + dvfs::{get_curr_cpu_freq, get_max_cpu_freq, get_min_cpu_freq}, + time::Instant, +}; + +const NUM_LOOP: usize = 100_000_000; +const NUM_ROUND: usize = 10; +const NUM_TASKS: usize = 3; + +/// Number of finished `busy_loop` tasks. +static FINISHED: AtomicUsize = AtomicUsize::new(0); + +pub async fn run() { + if num_cpu() < 7 { + log::error!("need at least 7 CPUs"); + return; + } + + let max = match get_max_cpu_freq() { + Ok(f) => f, + Err(e) => { + log::error!("get_max_cpu_freq failed: {e:?}"); + return; + } + }; + + task::spawn( + "dvfs_task_none".into(), + busy_loop(1, None), + SchedulerType::EDF(1_000_000, CpuSet::empty().with(2)), + ); + + task::spawn_with_freq( + "dvfs_task_half".into(), + busy_loop(2, Some(max / 2)), + SchedulerType::EDF(1_000_000, CpuSet::empty().with(4)), + max / 2, + ); + + task::spawn_with_freq( + "dvfs_task_max".into(), + busy_loop(3, Some(max)), + SchedulerType::EDF(1_000_000, CpuSet::empty().with(6)), + max, + ); + + // Wait for all tasks to finish. + while FINISHED.load(Ordering::Relaxed) < NUM_TASKS { + awkernel_async_lib::sleep(Duration::from_millis(100)).await; + } + + // Measure the frequency of each worker CPU, one by one. + // CPU#0 is the primary CPU and does not run tasks. + let min = get_min_cpu_freq(); + for core in 1..num_cpu() { + let handle = awkernel_async_lib::spawn( + "dvfs_task_measure".into(), + async move { + match get_curr_cpu_freq() { + Ok(f) => log::info!("after all tasks: CPU#{core} = {f} Hz (min = {min:?})"), + Err(e) => log::warn!("after all tasks: CPU#{core}: {e:?}"), + } + }, + SchedulerType::EDF(1_000_000, CpuSet::empty().with(core)), + ) + .await; + let _ = handle.join().await; + } +} + +async fn busy_loop(label: u32, expected: Option) -> TaskResult { + for _ in 0..NUM_ROUND { + // Measure while keeping interrupts (and thus preemption) disabled. + let int_guard = awkernel_lib::interrupt::InterruptGuard::new(); + let cpuid = awkernel_lib::cpu::cpu_id(); + let start = Instant::now(); + for _ in 0..NUM_LOOP { + core::hint::black_box(()); + } + let t = start.elapsed(); + let current = get_curr_cpu_freq(); + drop(int_guard); + + // Log outside the guard. + match current { + Ok(current) => log::info!( + "dvfs_task {label}: CPU#{cpuid}, current = {current}, expected = {expected:?}, time = {t:?}" + ), + Err(e) => log::warn!("dvfs_task {label}: get_curr_cpu_freq failed: {e:?}"), + } + + awkernel_async_lib::r#yield().await; + } + log::info!("dvfs_task {label} finished"); + FINISHED.fetch_add(1, Ordering::Relaxed); + Ok(()) +} diff --git a/awkernel_async_lib/Cargo.toml b/awkernel_async_lib/Cargo.toml index 323bc58d0..c0cd0cdcc 100644 --- a/awkernel_async_lib/Cargo.toml +++ b/awkernel_async_lib/Cargo.toml @@ -44,3 +44,4 @@ spinlock = ["awkernel_lib/spinlock"] clippy = [] perf = [] period-index-propagation = ["perf"] +dvfs = [] diff --git a/awkernel_async_lib/src/task.rs b/awkernel_async_lib/src/task.rs index 7ac806ba5..f585dec34 100644 --- a/awkernel_async_lib/src/task.rs +++ b/awkernel_async_lib/src/task.rs @@ -186,6 +186,9 @@ pub struct TaskInfo { panicked: bool, pub(crate) dag_info: Option, + #[cfg(feature = "dvfs")] + freq: Option, + #[cfg(not(feature = "no_preempt"))] thread: Option, } @@ -252,6 +255,18 @@ impl TaskInfo { pub fn get_dag_info(&self) -> Option { self.dag_info.clone() } + + #[inline(always)] + #[cfg(feature = "dvfs")] + pub fn update_freq(&mut self, freq: u64) { + self.freq = Some(freq); + } + + #[inline(always)] + #[cfg(feature = "dvfs")] + pub fn get_freq(&self) -> Option { + self.freq + } } /// State of task. @@ -294,6 +309,7 @@ impl Tasks { scheduler: &'static dyn Scheduler, mut scheduler_type: SchedulerType, dag_info: Option, + #[cfg(feature = "dvfs")] freq: Option, ) -> u32 { let mut id = self.candidate_id; loop { @@ -337,6 +353,9 @@ impl Tasks { panicked: false, dag_info, + #[cfg(feature = "dvfs")] + freq, + #[cfg(not(feature = "no_preempt"))] thread: None, }); @@ -403,7 +422,14 @@ pub fn spawn( future: impl Future + 'static + Send, sched_type: SchedulerType, ) -> u32 { - inner_spawn(name, future, sched_type, None) + inner_spawn( + name, + future, + sched_type, + None, + #[cfg(feature = "dvfs")] + None, + ) } /// Spawn a detached task with DAG information. @@ -433,7 +459,24 @@ pub fn spawn_with_dag_info( sched_type: SchedulerType, dag_info: DagInfo, ) -> u32 { - inner_spawn(name, future, sched_type, Some(dag_info)) + inner_spawn( + name, + future, + sched_type, + Some(dag_info), + #[cfg(feature = "dvfs")] + None, + ) +} + +#[cfg(feature = "dvfs")] +pub fn spawn_with_freq( + name: Cow<'static, str>, + future: impl Future + 'static + Send, + sched_type: SchedulerType, + freq: u64, +) -> u32 { + inner_spawn(name, future, sched_type, None, Some(freq)) } pub fn inner_spawn( @@ -441,6 +484,7 @@ pub fn inner_spawn( future: impl Future + 'static + Send, sched_type: SchedulerType, dag_info: Option, + #[cfg(feature = "dvfs")] freq: Option, ) -> u32 { if let SchedulerType::PrioritizedFIFO(p) | SchedulerType::PrioritizedRR(p) = sched_type { if p > HIGHEST_PRIORITY { @@ -456,7 +500,15 @@ pub fn inner_spawn( 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, + #[cfg(feature = "dvfs")] + freq, + ); let task = tasks.id_to_task.get(&id).cloned(); drop(tasks); @@ -1297,6 +1349,9 @@ pub fn run_main() { continue; } + #[cfg(feature = "dvfs")] + let freq; + { let mut node = MCSNode::new(); let mut info = task.info.lock(&mut node); @@ -1307,6 +1362,25 @@ pub fn run_main() { } info.update_last_executed(); + + #[cfg(feature = "dvfs")] + { + freq = info.freq; + } + } + + #[cfg(feature = "dvfs")] + match freq { + Some(f) => { + if let Err(e) = awkernel_lib::dvfs::set_cpu_freq_clamped(f) { + log::error!("CPU#{cpu_id}: failed to set the frequency to {f} Hz: {e}"); + } + } + None => { + if let Err(e) = awkernel_lib::dvfs::set_max_cpu_freq() { + log::error!("CPU#{cpu_id}: failed to set the frequency to max: {e}"); + } + } } // Use the primary memory allocator. @@ -1415,6 +1489,12 @@ pub fn run_main() { #[cfg(feature = "perf")] perf::start_idle(); + // No runnable task. Lower the frequency to the minimum while idle. + #[cfg(feature = "dvfs")] + if let Err(e) = awkernel_lib::dvfs::set_min_cpu_freq() { + log::error!("CPU#{cpu_id}: failed to set the frequency to min: {e}"); + } + awkernel_lib::cpu::sleep_cpu(None); } } diff --git a/awkernel_lib/src/dvfs.rs b/awkernel_lib/src/dvfs.rs index e1e5e8e38..6914d3d28 100644 --- a/awkernel_lib/src/dvfs.rs +++ b/awkernel_lib/src/dvfs.rs @@ -118,6 +118,9 @@ unsafe extern "Rust" { unsafe fn __awkernel_cpu_init(cpu_id: usize) -> Result<()>; unsafe fn __awkernel_set_cpu_freq(freq: u64) -> Result<()>; unsafe fn __awkernel_set_global_freq(freq: u64) -> Result<()>; + unsafe fn __awkernel_set_cpu_freq_clamped(freq: u64) -> Result<()>; + unsafe fn __awkernel_set_max_cpu_freq() -> Result<()>; + unsafe fn __awkernel_set_min_cpu_freq() -> Result<()>; unsafe fn __awkernel_get_max_cpu_freq() -> Result; unsafe fn __awkernel_get_min_cpu_freq() -> Result; unsafe fn __awkernel_get_curr_cpu_freq() -> Result; @@ -149,6 +152,24 @@ pub unsafe fn set_global_freq(freq: u64) -> Result<()> { unsafe { __awkernel_set_global_freq(freq) } } +/// Set the frequency of the current CPU in Hz, clamped to the min and max frequencies of the CPU. +#[inline(always)] +pub fn set_cpu_freq_clamped(freq: u64) -> Result<()> { + unsafe { __awkernel_set_cpu_freq_clamped(freq) } +} + +/// Set the frequency of the current CPU to its maximum. +#[inline(always)] +pub fn set_max_cpu_freq() -> Result<()> { + unsafe { __awkernel_set_max_cpu_freq() } +} + +/// Set the frequency of the current CPU to its minimum. +#[inline(always)] +pub fn set_min_cpu_freq() -> Result<()> { + unsafe { __awkernel_set_min_cpu_freq() } +} + /// Get the maximum frequency of the current CPU in Hz. #[inline(always)] pub fn get_max_cpu_freq() -> Result { @@ -185,6 +206,24 @@ unsafe extern "Rust" fn default_set_global_freq(freq: u64) -> Result<()> { crate::arch::ArchImpl::set_global_freq(freq) } +#[linkage = "weak"] +#[export_name = "__awkernel_set_cpu_freq_clamped"] +extern "Rust" fn default_set_cpu_freq_clamped(freq: u64) -> Result<()> { + crate::arch::ArchImpl::set_cpu_freq_clamped(freq) +} + +#[linkage = "weak"] +#[export_name = "__awkernel_set_max_cpu_freq"] +extern "Rust" fn default_set_max_cpu_freq() -> Result<()> { + crate::arch::ArchImpl::set_max_cpu_freq() +} + +#[linkage = "weak"] +#[export_name = "__awkernel_set_min_cpu_freq"] +extern "Rust" fn default_set_min_cpu_freq() -> Result<()> { + crate::arch::ArchImpl::set_min_cpu_freq() +} + #[linkage = "weak"] #[export_name = "__awkernel_get_max_cpu_freq"] extern "Rust" fn default_get_max_cpu_freq() -> Result { @@ -226,6 +265,23 @@ macro_rules! impl_dvfs { unsafe { <$ty as $crate::dvfs::Dvfs>::set_global_freq(freq) } } + #[export_name = "__awkernel_set_cpu_freq_clamped"] + extern "Rust" fn __awkernel_bsp_set_cpu_freq_clamped( + freq: u64, + ) -> $crate::dvfs::Result<()> { + <$ty as $crate::dvfs::Dvfs>::set_cpu_freq_clamped(freq) + } + + #[export_name = "__awkernel_set_max_cpu_freq"] + extern "Rust" fn __awkernel_bsp_set_max_cpu_freq() -> $crate::dvfs::Result<()> { + <$ty as $crate::dvfs::Dvfs>::set_max_cpu_freq() + } + + #[export_name = "__awkernel_set_min_cpu_freq"] + extern "Rust" fn __awkernel_bsp_set_min_cpu_freq() -> $crate::dvfs::Result<()> { + <$ty as $crate::dvfs::Dvfs>::set_min_cpu_freq() + } + #[export_name = "__awkernel_get_max_cpu_freq"] extern "Rust" fn __awkernel_bsp_get_max_cpu_freq() -> $crate::dvfs::Result { <$ty as $crate::dvfs::Dvfs>::get_max_cpu_freq() diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml index 0b11ba533..51bd8937b 100644 --- a/kernel/Cargo.toml +++ b/kernel/Cargo.toml @@ -142,4 +142,4 @@ aarch64_virt = [ ] spinlock = ["awkernel_lib/spinlock"] linux = [] -dvfs = [] +dvfs = ["awkernel_async_lib/dvfs"] diff --git a/userland/Cargo.toml b/userland/Cargo.toml index 98eb2af89..8c5d574fd 100644 --- a/userland/Cargo.toml +++ b/userland/Cargo.toml @@ -90,6 +90,10 @@ optional = true path = "../applications/tests/test_edf" optional = true +[dependencies.test_dvfs_task] +path = "../applications/tests/test_dvfs_task" +optional = true + [features] default = [] perf = ["awkernel/perf", "awkernel_services/perf"] @@ -129,3 +133,4 @@ test_dvfs = ["dep:test_dvfs", "awkernel/dvfs"] test_raspi_dvfs = ["dep:test_raspi_dvfs"] test_voluntary_preemption = ["dep:test_voluntary_preemption"] test_edf = ["dep:test_edf"] +test_dvfs_task = ["dep:test_dvfs_task", "awkernel/dvfs"] diff --git a/userland/src/lib.rs b/userland/src/lib.rs index a21a1450c..1b43acf94 100644 --- a/userland/src/lib.rs +++ b/userland/src/lib.rs @@ -59,5 +59,8 @@ pub async fn run() -> Result<(), Cow<'static, str>> { #[cfg(feature = "test_edf")] test_edf::run().await; // test for EDF scheduler + #[cfg(feature = "test_dvfs_task")] + test_dvfs_task::run().await; // test for per-task frequency + Ok(()) }