ch5 ok

afox666 · afox666 · commit 137881db0234 · 2025-05-02T16:10:12.000+08:00
diff --git a/os/src/config.rs b/os/src/config.rs
@@ -21,3 +21,6 @@ pub const TRAP_CONTEXT_BASE: usize = TRAMPOLINE - PAGE_SIZE;
 pub const CLOCK_FREQ: usize = 12500000;
 /// the physical memory end
 pub const MEMORY_END: usize = 0x88000000;
+
+/// BigStride
+pub const BIG_STRIDE: usize = 1000;
diff --git a/os/src/mm/memory_set.rs b/os/src/mm/memory_set.rs
@@ -304,10 +304,6 @@ impl MemorySet {
     /// find target area by start_va, then insert it to areas
     pub fn find_area_insert(&mut self, start_va: VirtAddr, end_va: VirtAddr, permission: MapPermission) -> bool {
         if let Some(_area) = self.areas.iter().find(|area| {
-            debug!("=============== insert ===============");
-            debug!("area start: {}, end: {}", area.vpn_range.get_start().0, area.vpn_range.get_end().0);
-            debug!("target area start: {}, end: {}", start_va.floor().0, end_va.ceil().0);
-            debug!("======================================");
             area.vpn_range.get_start() < end_va.ceil() && area.vpn_range.get_end() > start_va.floor()
         }) {
             debug!("!!! find area has been used !!!");
@@ -321,10 +317,6 @@ impl MemorySet {
     /// find target area by start_va, then remove it from areas
     pub fn find_area_remove(&mut self, start_va: VirtAddr, end_va: VirtAddr) -> bool {
         if let Some(index) = self.areas.iter().position(|area| {
-            debug!("=============== remove ===============");
-            debug!("area start: {}, end: {}", area.vpn_range.get_start().0, area.vpn_range.get_end().0);
-            debug!("target area start: {}, end: {}", start_va.floor().0, end_va.ceil().0);
-            debug!("======================================");
             area.vpn_range.get_start() == start_va.floor() && area.vpn_range.get_end() == end_va.ceil()
         }) {
             self.areas[index].unmap(&mut self.page_table);
diff --git a/os/src/syscall/process.rs b/os/src/syscall/process.rs
@@ -2,7 +2,7 @@
 use alloc::sync::Arc;
 
 use crate::{
-    loader::get_app_data_by_name, mm::{translated_physaddr, translated_refmut, translated_str, MapPermission, VirtAddr}, task::{add_task, current_task, current_user_token, exit_current_and_run_next, suspend_current_and_run_next}, timer::get_time_us
+    loader::get_app_data_by_name, mm::{translated_physaddr, translated_refmut, translated_str, MapPermission, VirtAddr}, task::{add_task, current_task, current_user_token, exit_current_and_run_next, suspend_current_and_run_next, TaskControlBlock}, timer::get_time_us
 };
 
 #[repr(C)]
@@ -73,6 +73,7 @@ pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize {
         .iter()
         .any(|p| pid == -1 || pid as usize == p.getpid())
     {
+        debug!("no such pid[{}]", pid);
         return -1;
         // ---- release current PCB
     }
@@ -90,8 +91,10 @@ pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize {
         let exit_code = child.inner_exclusive_access().exit_code;
         // ++++ release child PCB
         *translated_refmut(inner.memory_set.token(), exit_code_ptr) = exit_code;
+        debug!("found pid[{}]", found_pid);
         found_pid as isize
     } else {
+        // debug!("pid[{}] is running", pid);
         -2
     }
     // ---- release current PCB automatically
@@ -197,7 +200,18 @@ pub fn sys_spawn(_path: *const u8) -> isize {
         "kernel:pid[{}] sys_spawn NOT IMPLEMENTED",
         current_task().unwrap().pid.0
     );
-    -1
+    let token = current_user_token();
+    let path = translated_str(token, _path);
+    if let Some(data) = get_app_data_by_name(&path) {
+        let new_task: Arc<TaskControlBlock> = current_task().unwrap().spawn(data);
+        let pid = new_task.getpid() as isize;
+        add_task(new_task);
+        debug!("add task pid[{}]", pid);
+        return pid;
+    } else {
+        debug!("kernel: sys spawn error...");
+        return -1;
+    }
 }
 
 // YOUR JOB: Set task priority.
@@ -206,5 +220,9 @@ pub fn sys_set_priority(_prio: isize) -> isize {
         "kernel:pid[{}] sys_set_priority NOT IMPLEMENTED",
         current_task().unwrap().pid.0
     );
-    -1
+    if _prio < 2 {
+        return -1;
+    }
+    current_task().unwrap().set_priority(_prio as usize);
+    return _prio;
 }
diff --git a/os/src/task/manager.rs b/os/src/task/manager.rs
@@ -1,29 +1,41 @@
 //!Implementation of [`TaskManager`]
 use super::TaskControlBlock;
+use crate::config::BIG_STRIDE;
 use crate::sync::UPSafeCell;
-use alloc::collections::VecDeque;
 use alloc::sync::Arc;
+use alloc::vec::Vec;
 use lazy_static::*;
 ///A array of `TaskControlBlock` that is thread-safe
 pub struct TaskManager {
-    ready_queue: VecDeque<Arc<TaskControlBlock>>,
+    ready_queue: Vec<Arc<TaskControlBlock>>,
 }
 
 /// A simple FIFO scheduler.
 impl TaskManager {
     ///Creat an empty TaskManager
     pub fn new() -> Self {
         Self {
-            ready_queue: VecDeque::new(),
+            ready_queue: Vec::new(),
         }
     }
     /// Add process back to ready queue
     pub fn add(&mut self, task: Arc<TaskControlBlock>) {
-        self.ready_queue.push_back(task);
+        self.ready_queue.push(task);
     }
     /// Take a process out of the ready queue
     pub fn fetch(&mut self) -> Option<Arc<TaskControlBlock>> {
-        self.ready_queue.pop_front()
+        let mut min_stride_idx = 0;
+        let mut min_stride = BIG_STRIDE;
+        for (idx, task) in self.ready_queue.iter().enumerate() {
+            let stride = task.inner_exclusive_access().stride as usize;
+            if stride < min_stride {
+                min_stride_idx = idx;
+                min_stride = stride;
+            }
+        }
+        let ret = self.ready_queue[min_stride_idx].clone();
+        self.ready_queue.remove(min_stride_idx);
+        return Some(ret);
     }
 }
 
diff --git a/os/src/task/mod.rs b/os/src/task/mod.rs
@@ -48,6 +48,7 @@ pub fn suspend_current_and_run_next() {
     drop(task_inner);
     // ---- release current PCB
 
+    task.update_stride();
     // push back to ready queue.
     add_task(task);
     // jump to scheduling cycle
diff --git a/os/src/task/task.rs b/os/src/task/task.rs
@@ -2,7 +2,7 @@
 use super::TaskContext;
 use super::{kstack_alloc, pid_alloc, KernelStack, PidHandle};
 use crate::mm::{MapPermission, MemorySet, PhysPageNum, VirtAddr, KERNEL_SPACE};
-use crate::config::TRAP_CONTEXT_BASE;
+use crate::config::{BIG_STRIDE, TRAP_CONTEXT_BASE};
 use crate::sync::UPSafeCell;
 use crate::trap::{trap_handler, TrapContext};
 use alloc::sync::{Arc, Weak};
@@ -68,6 +68,12 @@ pub struct TaskControlBlockInner {
 
     /// Program break
     pub program_brk: usize,
+
+    /// Stride
+    pub stride: u8,
+
+    /// Priority
+    pub priority: usize
 }
 
 impl TaskControlBlockInner {
@@ -118,6 +124,8 @@ impl TaskControlBlock {
                     exit_code: 0,
                     heap_bottom: user_sp,
                     program_brk: user_sp,
+                    stride: 0,
+                    priority: 16
                 })
             },
         };
@@ -191,6 +199,8 @@ impl TaskControlBlock {
                     exit_code: 0,
                     heap_bottom: parent_inner.heap_bottom,
                     program_brk: parent_inner.program_brk,
+                    stride: parent_inner.stride,
+                    priority: parent_inner.priority
                 })
             },
         });
@@ -206,6 +216,14 @@ impl TaskControlBlock {
         // ---- release parent PCB
     }
 
+    /// parent process spawn child process
+    pub fn spawn(self: &Arc<Self>, elf_data: &[u8]) -> Arc<Self> {
+        let new_tcb = Arc::new(TaskControlBlock::new(elf_data));
+        new_tcb.inner_exclusive_access().parent = Some(Arc::downgrade(self));
+        self.inner_exclusive_access().children.push(new_tcb.clone());
+        new_tcb
+    }
+
     /// get pid of process
     pub fn getpid(&self) -> usize {
         self.pid.0
@@ -244,6 +262,18 @@ impl TaskControlBlock {
     pub fn find_area_remove(&self, start_va: VirtAddr, end_va: VirtAddr) -> bool {
         self.inner_exclusive_access().memory_set.find_area_remove(start_va, end_va)
     }
+
+    /// Set priority
+    pub fn set_priority(&self, prio: usize) {
+        self.inner_exclusive_access().priority = prio;
+    }
+
+    /// Update stride
+    pub fn update_stride(&self) {
+        let mut inner = self.inner_exclusive_access();
+        let pass = BIG_STRIDE / inner.priority;
+        inner.stride += pass as u8;
+    }
 }
 
 #[derive(Copy, Clone, PartialEq)]
diff --git a/reports/lab3.md b/reports/lab3.md
@@ -0,0 +1,65 @@
+### 总结实现的功能
+1. 由于获取当前进程的接口在本章发生了改变，因此修改了ch4中的mmap相关代码。
+2. 完成了`sys_spawn`系统调用的实现，通过调用`TaskControlBlock::new`方法直接新建一个进程，然后将新进程的`parent`设置为当前进程，向当前进程的`child`列表增加新进程的指针，最后通过`add_task()`方法将新进程加入到进程调度的队列中。
+3. 实现stride调度算法：
+    - 在`TaskControlBlockInner`结构中加入新的成员`stride`和`priority`，新增了两个方法`set_priority()`（设置优先级），`update_stride()`(自动更新stride变量的值)，在`suspend_current_and_run_next()`方法将当前任务状态更改时，调用`update_stride()`方法更新进程的stride值即可实现stride调度算法。
+    - 修改`TaskManager.ready_queue`的类型为`Vec`，对应的`fetch()`方法将遍历`ready_queue`找到stride值最小的进程返回，同时将该进程从`ready_queue`中移除
+
+### 问答题
+#### stride 算法深入
+stride 算法原理非常简单，但是有一个比较大的问题。例如两个 pass = 10 的进程，使用 8bit 无符号整形储存 stride， p1.stride = 255, p2.stride = 250，在 p2 执行一个时间片后，理论上下一次应该 p1 执行。  
+
+**实际情况是轮到 p1 执行吗？为什么？**  
+*不是，由于使用 8bit 无符号整形储存 stride，因此p2在执行完一个时间片后，p2.stride = 250 + 10 = 260，此时会产生溢出，最后p2.stride = 4, 此时p2.stride < p1.stride,因此实际情况是p2会继续执行（不产生溢出异常的情况下）*
+
+我们之前要求进程优先级 >= 2 其实就是为了解决这个问题。可以证明， 在不考虑溢出的情况下 , 在进程优先级全部 >= 2 的情况下，如果严格按照算法执行，那么 STRIDE_MAX – STRIDE_MIN <= BigStride / 2。
+
+为什么？尝试简单说明（不要求严格证明）。  
+已知 `P.pass = BigStride / P.prio`,且 `P.prio >= 2`的情况下，  
+可得`P.pass <= (BigStride / 2)`，  
+为了让算法中程序运行的次数大致与其优先级呈正比，那么
+`STRIDE_MAX – STRIDE_MIN <= MAX(P.pass)`，也就是`STRIDE_MAX – STRIDE_MIN <= BigStride / 2`
+
+
+已知以上结论，考虑溢出的情况下，可以为 Stride 设计特别的比较器，让 BinaryHeap<Stride> 的 pop 方法能返回真正最小的 Stride。补全下列代码中的 partial_cmp 函数，假设两个 Stride 永远不会相等。
+``` rust
+use core::cmp::Ordering;
+
+struct Stride(u64);
+
+impl PartialOrd for Stride {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        let self_value = self.0 as i8;
+        let other_value = other.0 as i8;
+        let pass_max = BigStride / 2;
+        if self_value > 0 && other_value < 0 && self_value - other_value > pass_max {
+            Some(Ordering::Less)
+        } else if self_value < 0 && other_value > 0 && other_value - self_value > pass_max  {
+            Some(Ordering::Grater)
+        } else {
+            Some(self_value.cmp(&other_value))
+        }
+    }
+}
+
+impl PartialEq for Stride {
+    fn eq(&self, other: &Self) -> bool {
+        false
+    }
+}
+
+```
+
+
+### 荣誉准则
+1. 在完成本次实验的过程（含此前学习的过程）中，我曾分别与 以下各位 就（与本次实验相关的）以下方面做过交流，还在代码中对应的位置以注释形式记录了具体的交流对象及内容：
+
+    向claude3.7老师请教了许多问题，感谢它的帮助
+
+2. 此外，我也参考了 以下资料 ，还在代码中对应的位置以注释形式记录了具体的参考来源及内容：
+
+    参考了 https://cheats.rs/ 手册的一些语法细节。
+
+3. 我独立完成了本次实验除以上方面之外的所有工作，包括代码与文档。 我清楚地知道，从以上方面获得的信息在一定程度上降低了实验难度，可能会影响起评分。
+
+4. 我从未使用过他人的代码，不管是原封不动地复制，还是经过了某些等价转换。 我未曾也不会向他人（含此后各届同学）复制或公开我的实验代码，我有义务妥善保管好它们。 我提交至本实验的评测系统的代码，均无意于破坏或妨碍任何计算机系统的正常运转。 我清楚地知道，以上情况均为本课程纪律所禁止，若违反，对应的实验成绩将按“-100”分计。
