From c2f48a41db04a2e467de136c1083be0b34925b8f Mon Sep 17 00:00:00 2001 From: Zejun Zhao Date: Wed, 22 Jan 2025 11:48:10 +0800 Subject: [PATCH] Clean up the implementation of scheduling class --- kernel/src/sched/priority.rs | 18 ++++++------------ kernel/src/sched/sched_class/fair.rs | 4 ++-- kernel/src/sched/sched_class/idle.rs | 9 ++++++++- kernel/src/sched/sched_class/mod.rs | 16 ++++++---------- kernel/src/sched/sched_class/policy.rs | 11 +++++------ kernel/src/sched/sched_class/real_time.rs | 16 ++++++++++++---- kernel/src/sched/sched_class/stop.rs | 9 ++++++++- 7 files changed, 47 insertions(+), 36 deletions(-) diff --git a/kernel/src/sched/priority.rs b/kernel/src/sched/priority.rs index 35af35fcd..f7d2084e9 100644 --- a/kernel/src/sched/priority.rs +++ b/kernel/src/sched/priority.rs @@ -57,7 +57,7 @@ impl TryFrom for Nice { /// /// It is an integer in the range of [0, 139]. Here we follow the Linux /// priority mappings: the relation between [`Priority`] and [`Nice`] is -/// as such - prio = nice + 120 while the priority of [0, 100] are +/// as such - prio = nice + 120 while the priority of [0, 99] are /// reserved for real-time tasks. #[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)] pub struct Priority(PriorityRange); @@ -70,18 +70,12 @@ define_atomic_version_of_integer_like_type!(Priority, try_from = true, { }); impl Priority { + pub const MIN_NORMAL: Self = Self::new(PriorityRange::new(100)); + pub const fn new(range: PriorityRange) -> Self { Self(range) } - pub const fn default_real_time() -> Self { - Self::new(PriorityRange::new(50)) - } - - pub const fn idle() -> Self { - Self::new(PriorityRange::new(PriorityRange::MAX)) - } - pub const fn range(&self) -> &PriorityRange { &self.0 } @@ -92,14 +86,14 @@ impl Priority { } impl From for Priority { - fn from(value: Nice) -> Self { - Self::new(PriorityRange::new(value.range().get() as u8 + 120)) + fn from(nice: Nice) -> Self { + Self::new(PriorityRange::new((nice.range().get() as i16 + 120) as u8)) } } impl From for Nice { fn from(priority: Priority) -> Self { - Self::new(NiceRange::new((priority.range().get() - 100) as i8 - 20)) + Self::new(NiceRange::new(((priority.range().get() as i16 - 100) - 20) as i8)) } } diff --git a/kernel/src/sched/sched_class/fair.rs b/kernel/src/sched/sched_class/fair.rs index 1d7fce86b..b2d96e624 100644 --- a/kernel/src/sched/sched_class/fair.rs +++ b/kernel/src/sched/sched_class/fair.rs @@ -1,9 +1,9 @@ // SPDX-License-Identifier: MPL-2.0 -use alloc::{collections::binary_heap::BinaryHeap, sync::Arc}; +use alloc::{collections::BinaryHeap, sync::Arc}; use core::{ cmp::{self, Reverse}, - sync::atomic::{AtomicU64, Ordering::*}, + sync::atomic::{AtomicU64, Ordering::Relaxed}, }; use ostd::{ diff --git a/kernel/src/sched/sched_class/idle.rs b/kernel/src/sched/sched_class/idle.rs index c3ba668e6..fd7953fcf 100644 --- a/kernel/src/sched/sched_class/idle.rs +++ b/kernel/src/sched/sched_class/idle.rs @@ -1,6 +1,13 @@ // SPDX-License-Identifier: MPL-2.0 -use super::*; +use alloc::sync::Arc; + +use ostd::task::{ + scheduler::{EnqueueFlags, UpdateFlags}, + Task, +}; + +use super::{CurrentRuntime, SchedAttr, SchedClassRq}; /// The per-cpu run queue for the IDLE scheduling class. /// diff --git a/kernel/src/sched/sched_class/mod.rs b/kernel/src/sched/sched_class/mod.rs index 15d241212..2b5142ace 100644 --- a/kernel/src/sched/sched_class/mod.rs +++ b/kernel/src/sched/sched_class/mod.rs @@ -3,9 +3,10 @@ #![warn(unused)] use alloc::{boxed::Box, sync::Arc}; -use core::{fmt, sync::atomic::AtomicU64}; +use core::fmt; use ostd::{ + arch::read_tsc as sched_clock, cpu::{all_cpus, AtomicCpuSet, CpuId, PinCurrentCpu}, sync::SpinLock, task::{ @@ -18,6 +19,9 @@ use ostd::{ trap::disable_local, }; +use super::{priority::Nice, stats::SchedulerStats}; +use crate::thread::{AsThread, Thread}; + mod policy; mod time; @@ -26,15 +30,7 @@ mod idle; mod real_time; mod stop; -use ostd::arch::read_tsc as sched_clock; - -pub use self::policy::*; -use self::policy::{SchedPolicyKind, SchedPolicyState}; -use super::{ - priority::{Nice, RangedU8}, - stats::SchedulerStats, -}; -use crate::thread::{AsThread, Thread}; +use self::policy::{SchedPolicy, SchedPolicyKind, SchedPolicyState}; type SchedEntity = (Arc, Arc); diff --git a/kernel/src/sched/sched_class/policy.rs b/kernel/src/sched/sched_class/policy.rs index c34af605e..a696dae6b 100644 --- a/kernel/src/sched/sched_class/policy.rs +++ b/kernel/src/sched/sched_class/policy.rs @@ -6,8 +6,8 @@ use atomic_integer_wrapper::define_atomic_version_of_integer_like_type; use int_to_c_enum::TryFromInt; use ostd::sync::SpinLock; -pub use super::real_time::RealTimePolicy; -use crate::sched::priority::{Nice, Priority, RangedU8}; +pub use super::real_time::{RealTimePolicy, RtPrio}; +use crate::sched::priority::{Nice, Priority}; /// The User-chosen scheduling policy. /// @@ -35,13 +35,12 @@ pub(super) enum SchedPolicyKind { impl From for SchedPolicy { fn from(priority: Priority) -> Self { match priority.range().get() { - 0 => SchedPolicy::Stop, - rt @ 1..=99 => SchedPolicy::RealTime { - rt_prio: RangedU8::new(rt), + rt @ 0..=99 => SchedPolicy::RealTime { + rt_prio: RtPrio::new(rt as u8), rt_policy: Default::default(), }, 100..=139 => SchedPolicy::Fair(priority.into()), - _ => SchedPolicy::Idle, + _ => unreachable!(), } } } diff --git a/kernel/src/sched/sched_class/real_time.rs b/kernel/src/sched/sched_class/real_time.rs index c446485d1..2c062d2ce 100644 --- a/kernel/src/sched/sched_class/real_time.rs +++ b/kernel/src/sched/sched_class/real_time.rs @@ -1,17 +1,25 @@ // SPDX-License-Identifier: MPL-2.0 -use alloc::collections::vec_deque::VecDeque; +use alloc::{collections::VecDeque, sync::Arc}; use core::{ array, num::NonZero, - sync::atomic::{AtomicU8, Ordering::*}, + sync::atomic::{AtomicU64, AtomicU8, Ordering::Relaxed}, }; use bitvec::{bitarr, BitArr}; +use ostd::{ + cpu::CpuId, + task::{ + scheduler::{EnqueueFlags, UpdateFlags}, + Task, + }, +}; -use super::{time::base_slice_clocks, *}; +use super::{time::base_slice_clocks, CurrentRuntime, SchedAttr, SchedClassRq}; +use crate::{sched::priority::RangedU8, thread::AsThread}; -pub type RtPrio = RangedU8<1, 99>; +pub type RtPrio = RangedU8<0, 99>; #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub enum RealTimePolicy { diff --git a/kernel/src/sched/sched_class/stop.rs b/kernel/src/sched/sched_class/stop.rs index 62a2bbf7c..59b3d6cd6 100644 --- a/kernel/src/sched/sched_class/stop.rs +++ b/kernel/src/sched/sched_class/stop.rs @@ -1,6 +1,13 @@ // SPDX-License-Identifier: MPL-2.0 -use super::*; +use alloc::sync::Arc; + +use ostd::task::{ + scheduler::{EnqueueFlags, UpdateFlags}, + Task, +}; + +use super::{CurrentRuntime, SchedAttr, SchedClassRq}; /// The per-cpu run queue for the STOP scheduling class. ///