Merge pull request rustsbi#42 from YdrMaster/main

refactor: 使用 fast-trap 重构以提高性能

Author: luojia65

Cargo.lock

@@ -1,3 +1,3 @@
 [workspace]
-members = ["rustsbi-qemu", "test-kernel", "bench-kernel", "xtask"]
+members = ["rustsbi-qemu", "hsm-cell", "test-kernel", "bench-kernel", "xtask"]
 default-members = ["xtask"]

Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "hsm-cell"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+sbi-spec = "0.0.4"

hsm-cell/Cargo.toml

@@ -0,0 +1,154 @@
+//! 硬件线程状态和受状态保护的线程间共享数据。
+
+#![no_std]
+#![deny(warnings, missing_docs)]
+
+use core::{
+    cell::UnsafeCell,
+    hint::spin_loop,
+    sync::atomic::{AtomicUsize, Ordering},
+};
+use sbi_spec::hsm::*;
+
+/// 硬件线程状态和受状态保护的线程间共享数据。
+pub struct HsmCell<T> {
+    status: AtomicUsize,
+    val: UnsafeCell<Option<T>>,
+}
+
+/// 当前硬件线程的共享对象。
+pub struct LocalHsmCell<'a, T>(&'a HsmCell<T>);
+
+/// 任意硬件线程的共享对象。
+pub struct RemoteHsmCell<'a, T>(&'a HsmCell<T>);
+
+unsafe impl<T: Send> Sync for HsmCell<T> {}
+unsafe impl<T: Send> Send for HsmCell<T> {}
+
+const HART_STATE_START_PENDING_EXT: usize = usize::MAX;
+
+impl<T> HsmCell<T> {
+    /// 创建一个新的共享对象。
+    pub const fn new() -> Self {
+        Self {
+            status: AtomicUsize::new(HART_STATE_STOPPED),
+            val: UnsafeCell::new(None),
+        }
+    }
+
+    /// 从当前硬件线程的状态中获取线程间共享对象。
+    ///
+    /// # Safety
+    ///
+    /// 用户需要确保对象属于当前硬件线程。
+    #[inline]
+    pub unsafe fn local(&self) -> LocalHsmCell<'_, T> {
+        LocalHsmCell(self)
+    }
+
+    /// 取出共享对象。
+    #[inline]
+    pub fn remote(&self) -> RemoteHsmCell<'_, T> {
+        RemoteHsmCell(self)
+    }
+}
+
+impl<T> LocalHsmCell<'_, T> {
+    /// 从启动挂起状态的硬件线程取出共享数据，并将其状态设置为启动，如果成功返回取出的数据，否则返回当前状态。
+    #[inline]
+    pub fn start(&self) -> Result<T, usize> {
+        loop {
+            match self.0.status.compare_exchange(
+                HART_STATE_START_PENDING,
+                HART_STATE_STARTED,
+                Ordering::AcqRel,
+                Ordering::Relaxed,
+            ) {
+                Ok(_) => break Ok(unsafe { (*self.0.val.get()).take().unwrap() }),
+                Err(HART_STATE_START_PENDING_EXT) => spin_loop(),
+                Err(HART_STATE_SUSPENDED) => {
+                    self.0.status.store(HART_STATE_STARTED, Ordering::Relaxed);
+                    break Ok(unsafe { (*self.0.val.get()).take().unwrap() });
+                }
+                Err(s) => break Err(s),
+            }
+        }
+    }
+
+    /// 关闭。
+    #[inline]
+    pub fn stop_pending(&self) {
+        self.0
+            .status
+            .store(HART_STATE_STOP_PENDING, Ordering::Relaxed)
+    }
+
+    /// 关闭。
+    #[inline]
+    pub fn stop(&self) {
+        self.0.status.store(HART_STATE_STOPPED, Ordering::Release)
+    }
+
+    /// 关闭。
+    #[inline]
+    pub fn suspend_non_retentive(&self, t: T) {
+        unsafe { *self.0.val.get() = Some(t) };
+        self.0.status.store(HART_STATE_SUSPENDED, Ordering::Relaxed)
+    }
+
+    /// 关闭。
+    #[inline]
+    pub fn suspend(&self) {
+        self.0.status.store(HART_STATE_SUSPENDED, Ordering::Relaxed)
+    }
+
+    /// 关闭。
+    #[inline]
+    pub fn resume(&self) {
+        self.0.status.store(HART_STATE_STARTED, Ordering::Relaxed)
+    }
+}
+
+impl<T> RemoteHsmCell<'_, T> {
+    /// 向关闭状态的硬件线程传入共享数据，并将其状态设置为启动挂起，返回是否放入成功。
+    #[inline]
+    pub fn start(self, t: T) -> bool {
+        if self
+            .0
+            .status
+            .compare_exchange(
+                HART_STATE_STOPPED,
+                HART_STATE_START_PENDING_EXT,
+                Ordering::Acquire,
+                Ordering::Relaxed,
+            )
+            .is_ok()
+        {
+            unsafe { *self.0.val.get() = Some(t) };
+            self.0
+                .status
+                .store(HART_STATE_START_PENDING, Ordering::Release);
+            true
+        } else {
+            false
+        }
+    }
+
+    /// 取出当前状态。
+    #[inline]
+    pub fn sbi_get_status(&self) -> usize {
+        match self.0.status.load(Ordering::Relaxed) {
+            HART_STATE_START_PENDING_EXT => HART_STATE_START_PENDING,
+            normal => normal,
+        }
+    }
+
+    /// 判断这个 HART 能否接收 IPI。
+    #[inline]
+    pub fn allow_ipi(&self) -> bool {
+        matches!(
+            self.0.status.load(Ordering::Relaxed),
+            HART_STATE_STARTED | HART_STATE_SUSPENDED
+        )
+    }
+}

hsm-cell/src/lib.rs

@@ -26,3 +26,8 @@ uart_16550 = "0.2"
 rcore-console = "0.0.0"
 dtb-walker = "=0.2.0-alpha.3"
 qemu-exit = "3.0"
+
+hsm-cell = { path = "../hsm-cell" }
+fast-trap = { git = "https://github.com/YdrMaster/fast-trap", rev = "ffb40e2", features = [
+    "riscv-m",
+] }

rustsbi-qemu/Cargo.toml

@@ -14,29 +14,25 @@ MEMORY {
     DRAM : ORIGIN = 0x80000000, LENGTH = 2M
 }
 SECTIONS {
-    .text : ALIGN(4) {
+    .text : {
         *(.text.entry)
         *(.text .text.*)
     } > DRAM
-    .rodata : ALIGN(8) {
-        srodata = .;
+    .rodata : {
         *(.rodata .rodata.*)
         *(.srodata .srodata.*)
-        . = ALIGN(8);
-        erodata = .;
     } > DRAM
-    .data : ALIGN(8) {
-        sdata = .;
+    .data : {
         *(.data .data.*)
         *(.sdata .sdata.*)
-        . = ALIGN(8);
-        edata = .;
     } > DRAM
-    .bss (NOLOAD) : ALIGN(8) {
+    .bss (NOLOAD) : {
         *(.bss.uninit)
+        . = ALIGN(8);
         sbss = .;
         *(.bss .bss.*)
         *(.sbss .sbss.*)
+        . = ALIGN(8);
         ebss = .;
     } > DRAM
     /DISCARD/ : {

rustsbi-qemu/build.rs

@@ -1,3 +1,6 @@
+#![allow(unused)]
+
+use crate::trap_stack::remote_hsm;
 use core::cell::UnsafeCell;
 use rustsbi::{spec::binary::SbiRet, HartMask, Ipi, Timer};
 
@@ -6,9 +9,8 @@ pub(crate) struct Clint;
 impl Ipi for Clint {
     #[inline]
     fn send_ipi(&self, hart_mask: HartMask) -> SbiRet {
-        let hsm = crate::HSM.wait();
         for i in 0..crate::NUM_HART_MAX {
-            if hart_mask.has_bit(i) && hsm.is_ipi_allowed(i) {
+            if hart_mask.has_bit(i) && remote_hsm(i).map_or(false, |hsm| hsm.allow_ipi()) {
                 msip::send(i);
             }
         }
@@ -33,7 +35,6 @@ pub(crate) fn init(base: usize) {
     unsafe { *BASE.get() = base };
 }
 
-#[allow(unused)]
 pub mod mtime {
     #[inline]
     pub fn read() -> u64 {