Split TaskManager and Processor.

os/src/task/mod.rs

@@ -1,6 +1,8 @@
 mod context;
 mod switch;
 mod task;
+mod manager;
+mod processor;
 
 use crate::loader::{get_num_app, get_app_data};
 use crate::trap::TrapContext;
@@ -9,141 +11,38 @@ use lazy_static::*;
 use switch::__switch;
 use task::{TaskControlBlock, TaskStatus};
 use alloc::vec::Vec;
+use alloc::sync::Arc;
+use spin::Mutex;
+use manager::fetch_task;
 
 pub use context::TaskContext;
-
-pub struct TaskManager {
-    num_app: usize,
-    inner: RefCell<TaskManagerInner>,
-}
-
-struct TaskManagerInner {
-    tasks: Vec<TaskControlBlock>,
-    current_task: usize,
-}
-
-unsafe impl Sync for TaskManager {}
-
-lazy_static! {
-    pub static ref TASK_MANAGER: TaskManager = {
-        println!("init TASK_MANAGER");
-        let num_app = get_num_app();
-        println!("num_app = {}", num_app);
-        let mut tasks: Vec<TaskControlBlock> = Vec::new();
-        for i in 0..num_app {
-            tasks.push(TaskControlBlock::new(
-                get_app_data(i),
-                i,
-            ));
-        }
-        TaskManager {
-            num_app,
-            inner: RefCell::new(TaskManagerInner {
-                tasks,
-                current_task: 0,
-            }),
-        }
-    };
-}
-
-impl TaskManager {
-    fn run_first_task(&self) {
-        self.inner.borrow_mut().tasks[0].task_status = TaskStatus::Running;
-        let next_task_cx = self.inner.borrow().tasks[0].get_task_cx_ptr2();
-        let _unused: usize = 0;
-        unsafe {
-            __switch(
-                &_unused as *const _,
-                next_task_cx,
-            );
-        }
-    }
-
-    fn mark_current_suspended(&self) {
-        let mut inner = self.inner.borrow_mut();
-        let current = inner.current_task;
-        inner.tasks[current].task_status = TaskStatus::Ready;
-    }
-
-    fn mark_current_exited(&self) {
-        let mut inner = self.inner.borrow_mut();
-        let current = inner.current_task;
-        inner.tasks[current].task_status = TaskStatus::Exited;
-    }
-
-    fn find_next_task(&self) -> Option<usize> {
-        let inner = self.inner.borrow();
-        let current = inner.current_task;
-        (current + 1..current + self.num_app + 1)
-            .map(|id| id % self.num_app)
-            .find(|id| {
-                inner.tasks[*id].task_status == TaskStatus::Ready
-            })
-    }
-
-    fn get_current_token(&self) -> usize {
-        let inner = self.inner.borrow();
-        let current = inner.current_task;
-        inner.tasks[current].get_user_token()
-    }
-
-    fn get_current_trap_cx(&self) -> &mut TrapContext {
-        let inner = self.inner.borrow();
-        let current = inner.current_task;
-        inner.tasks[current].get_trap_cx()
-    }
-
-    fn run_next_task(&self) {
-        if let Some(next) = self.find_next_task() {
-            let mut inner = self.inner.borrow_mut();
-            let current = inner.current_task;
-            inner.tasks[next].task_status = TaskStatus::Running;
-            inner.current_task = next;
-            let current_task_cx = inner.tasks[current].get_task_cx_ptr2();
-            let next_task_cx = inner.tasks[next].get_task_cx_ptr2();
-            core::mem::drop(inner);
-            unsafe {
-                __switch(
-                    current_task_cx,
-                    next_task_cx,
-                );
-            }
-        } else {
-            panic!("All applications completed!");
-        }
-    }
-}
-
-pub fn run_first_task() {
-    TASK_MANAGER.run_first_task();
-}
-
-fn run_next_task() {
-    TASK_MANAGER.run_next_task();
-}
-
-fn mark_current_suspended() {
-    TASK_MANAGER.mark_current_suspended();
-}
-
-fn mark_current_exited() {
-    TASK_MANAGER.mark_current_exited();
-}
+pub use processor::{
+    run_tasks,
+    current_task,
+    current_user_token,
+    current_trap_cx,
+    take_current_task,
+    schedule,
+};
+pub use manager::add_task;
 
 pub fn suspend_current_and_run_next() {
-    mark_current_suspended();
-    run_next_task();
+    // There must be an application running.
+    let task = current_task().unwrap();
+    let task_cx_ptr = task.lock().get_task_cx_ptr2();
+    // Change status to Ready.
+    task.lock().task_status = TaskStatus::Ready;
+    // push back to ready queue.
+    add_task(task);
+    // jump to scheduling cycle
+    schedule(task_cx_ptr);
 }
 
 pub fn exit_current_and_run_next() {
-    mark_current_exited();
-    run_next_task();
+    // The resource recycle mechanism needs child processes. Now we just panic!
+    panic!("An application exited!");
 }
 
-pub fn current_user_token() -> usize {
-    TASK_MANAGER.get_current_token()
+pub fn add_application(elf_data: &[u8], app_id: usize) {
+    add_task(Arc::new(Mutex::new(TaskControlBlock::new(elf_data, app_id))));
 }
-
-pub fn current_trap_cx() -> &'static mut TrapContext {
-    TASK_MANAGER.get_current_trap_cx()
-}