feat(kernel): migrate to HashMap

Author: GZTimeWalker

docs/labs/0x03/tasks.md

@@ -189,16 +189,22 @@ impl Processor {
 
 ```rust
 pub struct ProcessManager {
-    processes: RwLock<BTreeMap<ProcessId, Arc<Process>>>,
+    processes: RwLock<HashMap<ProcessId, Arc<Process>, ahash::RandomState>>,
     ready_queue: Mutex<VecDeque<ProcessId>>,
 }
 ```
 
 其中 `processes` 字段用于存储所有的进程，`ready_queue` 字段则用于存储就绪的进程队列。`ProcessManager` 结构体被设计为“不可变”的，也就是说，它由 `RwLock` 和 `Mutex` 来提供内部可变性。
 
+??? hint "`HashMap` 与 `ahash`"
+
+    在内核 `no_std` 环境下，可以使用 `hashbrown` 库提供的 `HashMap` 能力，它也是 Rust 标准库所使用的 HashMap 实现。
+
+    `ahash` 是一个专为 `HashMap` 设计的高性能哈希算法。在 `ProcessManager` 中，我们显式指定了 `ahash::RandomState` 作为哈希状态，以确保进程查找的高效性。
+
 就绪队列的操作（`push` 和 `pop`）是需要对 `VecDeque` 进行修改，所以是在 `Mutex` 的保护下进行的，并没有读写操作的区别。
 
-而进程列表只有 `insert` 操作需要对 `BTreeMap` 的可变引用，因此 `RwLock` 的保护下更加合适。
+而进程列表只有 `insert` 操作需要对 `HashMap` 的可变引用，因此 `RwLock` 的保护下更加合适。
 
 在 `ProcessManager` 的不可变约束下，就可以通过 `spin::Once` 来定义一个全局的 `ProcessManager`，并在 `init()` 函数中初始化它：
 
@@ -227,7 +233,7 @@ pub fn get_process_manager() -> &'static ProcessManager {
 
 ```rust
 pub fn new(init: Arc<Process>) -> Self {
-    let mut processes = BTreeMap::new();
+    let mut processes = HashMap::default();
     let ready_queue = VecDeque::new();
     let pid = init.pid();
 

docs/labs/0x05/tasks.md

@@ -363,11 +363,11 @@ entry!(main);
 ```rust
 pub struct ProcessManager {
     // ...
-    wait_queue: Mutex<BTreeMap<ProcessId, BTreeSet<ProcessId>>>,
+    wait_queue: Mutex<HashMap<ProcessId, BTreeSet<ProcessId>, ahash::RandomState>>,
 }
 ```
 
-其中，`BTreeMap` 的键值对应于被等待的进程 ID，`BTreeSet` 用于存储等待的进程 ID 的集合。
+其中，`HashMap` 的键值对应于被等待的进程 ID，`BTreeSet` 用于存储等待的进程 ID 的集合。
 
 ### 阻塞进程
 
@@ -422,12 +422,12 @@ pub fn wait_pid(&self, pid: ProcessId) {
 }
 ```
 
-!!! tip "使用 `BTreeMap` 的 `entry` 方法"
+!!! tip "使用 `HashMap` 的 `entry` 方法"
 
-    `BTreeMap` 的 `entry` 方法可以用于获取一个键对应的值的可变引用，并可以通过 `or_default` 或者 `or_insert` 来插入一个默认值。
+    `HashMap` 的 `entry` 方法可以用于获取一个键对应的值的可变引用，并可以通过 `or_default` 或者 `or_insert` 来插入一个默认值。
 
     ```rust
-    let mut map: BTreeMap<u32, BTreeSet<u32>> = BTreeMap::new();
+    let mut map: HashMap<u32, BTreeSet<u32>, ahash::RandomState> = HashMap::default();
     let entry = map.entry(42).or_default();
     entry.insert(2333);
     ```
@@ -697,7 +697,7 @@ pub enum SemaphoreResult {
 
 ```rust
 pub struct SemaphoreSet {
-    sems: BTreeMap<SemaphoreId, Mutex<Semaphore>>,
+    sems: HashMap<SemaphoreId, Mutex<Semaphore>, ahash::RandomState>
 }
 ```
 

src/0x02/Cargo.toml

@@ -18,6 +18,7 @@ debug = false
 arrayvec              = { version = "0.7", default-features = false }
 bit_field             = "0.10"
 bitflags              = "2.10"
+hashbrown             = "0.16"
 lazy_static           = { version = "1.4", features = ["spin_no_std"] }
 libm                  = "0.2"
 linked_list_allocator = "0.10"

src/0x03/crates/kernel/Cargo.toml

@@ -5,10 +5,12 @@ version.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+ahash                 = { workspace = true }
 bit_field             = { workspace = true }
 bitflags              = { workspace = true }
 boot                  = { workspace = true }
 crossbeam-queue       = { workspace = true }
+hashbrown             = { workspace = true }
 lazy_static           = { workspace = true }
 libm                  = { workspace = true }
 linked_list_allocator = { workspace = true }

src/0x03/crates/kernel/src/proc/data.rs

@@ -1,29 +1,26 @@
-use alloc::{collections::BTreeMap, sync::Arc};
+use hashbrown::HashMap;
 use spin::RwLock;
-use x86_64::structures::paging::{
-    page::{PageRange, PageRangeInclusive},
-    Page,
-};
 
 use super::*;
+use crate::resource::ResourceSet;
 
 #[derive(Debug, Clone)]
 pub struct ProcessData {
     // shared data
-    pub(super) env: Arc<RwLock<BTreeMap<String, String>>>,
+    pub(super) env: Arc<RwLock<HashMap<String, String, ahash::RandomState>>>,
 }
 
 impl Default for ProcessData {
     fn default() -> Self {
-        Self {
-            env: Arc::new(RwLock::new(BTreeMap::new())),
-        }
+        Self::new()
     }
 }
 
 impl ProcessData {
     pub fn new() -> Self {
-        Self::default()
+        Self {
+            env: Arc::new(RwLock::new(HashMap::default())),
+        }
     }
 
     pub fn env(&self, key: &str) -> Option<String> {

src/0x03/crates/kernel/src/proc/manager.rs

@@ -4,6 +4,7 @@ use crate::memory::{
     allocator::{ALLOCATOR, HEAP_SIZE},
     get_frame_alloc_for_sure, PAGE_SIZE,
 };
+use hashbrown::HashMap;
 use alloc::{collections::*, format};
 use spin::{Mutex, RwLock};
 
@@ -25,13 +26,13 @@ pub fn get_process_manager() -> &'static ProcessManager {
 }
 
 pub struct ProcessManager {
-    processes: RwLock<BTreeMap<ProcessId, Arc<Process>>>,
+    processes: RwLock<HashMap<ProcessId, Arc<Process>, ahash::RandomState>>,
     ready_queue: Mutex<VecDeque<ProcessId>>,
 }
 
 impl ProcessManager {
     pub fn new(init: Arc<Process>) -> Self {
-        let mut processes = BTreeMap::new();
+        let mut processes = HashMap::default();
         let ready_queue = VecDeque::new();
         let pid = init.pid();
 

src/0x03/crates/kernel/src/proc/pid.rs

@@ -1,6 +1,6 @@
 use core::sync::atomic::{AtomicU16, Ordering};
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ProcessId(pub u16);
 
 impl ProcessId {

src/0x03/crates/kernel/src/proc/process.rs

@@ -10,7 +10,7 @@ use x86_64::structures::paging::*;
 #[derive(Clone)]
 pub struct Process {
     pid: ProcessId,
-    inner: Arc<RwLock<ProcessInner>>,
+    inner: RwLock<ProcessInner>,
 }
 
 pub struct ProcessInner {
@@ -70,7 +70,7 @@ impl Process {
         // create process struct
         Arc::new(Self {
             pid,
-            inner: Arc::new(RwLock::new(inner)),
+            inner: RwLock::new(inner),
         })
     }
 
@@ -165,7 +165,7 @@ impl ProcessInner {
 }
 
 impl core::ops::Deref for Process {
-    type Target = Arc<RwLock<ProcessInner>>;
+    type Target = RwLock<ProcessInner>;
 
     fn deref(&self) -> &Self::Target {
         &self.inner

src/0x04/crates/kernel/src/utils/resource.rs

@@ -1,4 +1,5 @@
 use alloc::string::String;
+use hashbrown::HashMap;
 
 #[derive(Debug, Clone)]
 pub enum StdIO {
@@ -9,13 +10,13 @@ pub enum StdIO {
 
 #[derive(Debug)]
 pub struct ResourceSet {
-    pub handles: BTreeMap<u8, Mutex<Resource>>,
+    pub(crate) handles: HashMap<u8, Mutex<Resource>, ahash::RandomState>,
 }
 
 impl Default for ResourceSet {
     fn default() -> Self {
         let mut res = Self {
-            handles: BTreeMap::new(),
+            handles: HashMap::default(),
         };
 
         res.open(Resource::Console(StdIO::Stdin));

src/0x05/crates/kernel/src/proc/sync.rs

@@ -1,8 +1,11 @@
-use super::ProcessId;
 use alloc::collections::*;
+
+use hashbrown::HashMap;
 use spin::Mutex;
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
+use super::ProcessId;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct SemaphoreId(u32);
 
 impl SemaphoreId {
@@ -58,9 +61,17 @@ impl Semaphore {
     }
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct SemaphoreSet {
-    sems: BTreeMap<SemaphoreId, Mutex<Semaphore>>,
+    sems: HashMap<SemaphoreId, Mutex<Semaphore>, ahash::RandomState>,
+}
+
+impl Default for SemaphoreSet {
+    fn default() -> Self {
+        Self {
+            sems: HashMap::with_hasher(ahash::RandomState::new()),
+        }
+    }
 }
 
 impl SemaphoreSet {