Print log target

src/io/mod.rs

@@ -69,7 +69,7 @@ impl Log for SimpleLogger {
     }
     fn log(&self, record: &Record) {
         if self.enabled(record.metadata()) {
-            print_in_color(format_args!("{}\n", record.args()), Color::from(record.level()));
+            print_in_color(format_args!("[{}] {}\n", record.target(), record.args()), Color::from(record.level()));
         }
     }
     fn flush(&self) {}

src/process/processor.rs

@@ -64,7 +64,7 @@ impl Processor {
             (_, &Status::Ready) => self.scheduler.insert(pid),
             _ => {}
         }
-        trace!("Processor: process {} {:?} -> {:?}", pid, status0, status);
+        trace!("process {} {:?} -> {:?}", pid, status0, status);
         self.get_mut(pid).status = status;
     }
 
@@ -77,7 +77,7 @@ impl Processor {
         }
         self.event_hub.tick();
         while let Some(event) = self.event_hub.pop() {
-            debug!("Processor: event {:?}", event);
+            debug!("event {:?}", event);
             match event {
                 Event::Schedule => {
                     self.event_hub.push(10, Event::Schedule);
@@ -153,7 +153,7 @@ impl Processor {
             *from_pt = Some(old_table);
         }
 
-        info!("Processor: switch from {} to {}\n  rsp: ??? -> {:#x}", pid0, pid, to.rsp);
+        info!("switch from {} to {}\n  rsp: ??? -> {:#x}", pid0, pid, to.rsp);
         unsafe {
             // FIXME: safely pass MutexGuard
             use core::mem::forget;
@@ -181,7 +181,7 @@ impl Processor {
     }
 
     pub fn exit(&mut self, pid: Pid, error_code: ErrorCode) {
-        info!("Processor: {} exit, code: {}", pid, error_code);
+        info!("{} exit, code: {}", pid, error_code);
         self.set_status(pid, Status::Exited(error_code));
         if let Some(waiter) = self.find_waiter(pid) {
             info!("  then wakeup {}", waiter);
@@ -203,7 +203,7 @@ impl Processor {
 
     /// Let current process wait for another
     pub fn current_wait_for(&mut self, pid: Pid) -> WaitResult {
-        info!("Processor: current {} wait for {:?}", self.current_pid, pid);
+        info!("current {} wait for {:?}", self.current_pid, pid);
         if self.procs.values().filter(|&p| p.parent == self.current_pid).next().is_none() {
             return WaitResult::NotExist;
         }
@@ -214,7 +214,7 @@ impl Processor {
             self.try_wait(pid).unwrap()
         });
         let exit_code = self.get(pid).exit_code().unwrap();
-        info!("Processor: {} wait end and remove {}", self.current_pid, pid);
+        info!("{} wait end and remove {}", self.current_pid, pid);
         self.procs.remove(&pid);
         WaitResult::Ok(pid, exit_code)
     }

src/process/scheduler.rs

@@ -10,176 +10,186 @@ pub trait Scheduler {
     fn tick(&mut self, current: Pid) -> bool;   // need reschedule?
 }
 
-pub struct RRScheduler {
-    max_time_slice: usize,
-    infos: [RRProcInfo; MAX_PROCESS_NUM],
-}
+pub use self::rr::RRScheduler;
+pub use self::stride::StrideScheduler;
 
-#[derive(Debug, Default, Copy, Clone)]
-struct RRProcInfo {
-    present: bool,
-    rest_slice: usize,
-    prev: Pid,
-    next: Pid,
-}
+mod rr {
+    use super::*;
 
-impl Scheduler for RRScheduler {
-    fn insert(&mut self, pid: Pid) {
-        let pid = pid + 1;
-        {
-            let info = &mut self.infos[pid];
-            assert!(!info.present);
-            info.present = true;
-            if info.rest_slice == 0 {
-                info.rest_slice = self.max_time_slice;
-            }
-        }
-        self._list_add_before(pid, 0);
-        debug!("RRScheduler: insert {}", pid - 1);
+    pub struct RRScheduler {
+        max_time_slice: usize,
+        infos: [RRProcInfo; MAX_PROCESS_NUM],
     }
 
-    fn remove(&mut self, pid: Pid) {
-        let pid = pid + 1;
-        assert!(self.infos[pid].present);
-        self.infos[pid].present = false;
-        self._list_remove(pid);
-        debug!("RRScheduler: remove {}", pid - 1);
+    #[derive(Debug, Default, Copy, Clone)]
+    struct RRProcInfo {
+        present: bool,
+        rest_slice: usize,
+        prev: Pid,
+        next: Pid,
     }
 
-    fn select(&mut self) -> Option<Pid> {
-        let ret = match self.infos[0].next {
-            0 => None,
-            i => Some(i - 1),
-        };
-        debug!("RRScheduler: select {:?}", ret);
-        ret
-    }
+    impl Scheduler for RRScheduler {
+        fn insert(&mut self, pid: Pid) {
+            let pid = pid + 1;
+            {
+                let info = &mut self.infos[pid];
+                assert!(!info.present);
+                info.present = true;
+                if info.rest_slice == 0 {
+                    info.rest_slice = self.max_time_slice;
+                }
+            }
+            self._list_add_before(pid, 0);
+            debug!("insert {}", pid - 1);
+        }
 
-    fn tick(&mut self, current: Pid) -> bool {
-        let current = current + 1;
-        assert!(!self.infos[current].present);
+        fn remove(&mut self, pid: Pid) {
+            let pid = pid + 1;
+            assert!(self.infos[pid].present);
+            self.infos[pid].present = false;
+            self._list_remove(pid);
+            debug!("remove {}", pid - 1);
+        }
 
-        let rest = &mut self.infos[current].rest_slice;
-        if *rest > 0 {
-            *rest -= 1;
-        } else {
-            warn!("current process rest_slice = 0, need reschedule")
+        fn select(&mut self) -> Option<Pid> {
+            let ret = match self.infos[0].next {
+                0 => None,
+                i => Some(i - 1),
+            };
+            debug!("select {:?}", ret);
+            ret
         }
-        *rest == 0
-    }
-}
 
-impl RRScheduler {
-    pub fn new(max_time_slice: usize) -> Self {
-        RRScheduler {
-            max_time_slice,
-            infos: [RRProcInfo::default(); MAX_PROCESS_NUM],
+        fn tick(&mut self, current: Pid) -> bool {
+            let current = current + 1;
+            assert!(!self.infos[current].present);
+
+            let rest = &mut self.infos[current].rest_slice;
+            if *rest > 0 {
+                *rest -= 1;
+            } else {
+                warn!("current process rest_slice = 0, need reschedule")
+            }
+            *rest == 0
         }
     }
-    fn _list_add_before(&mut self, i: Pid, at: Pid) {
-        let prev = self.infos[at].prev;
-        self.infos[i].next = at;
-        self.infos[i].prev = prev;
-        self.infos[prev].next = i;
-        self.infos[at].prev = i;
-    }
-    fn _list_remove(&mut self, i: Pid) {
-        let next = self.infos[i].next;
-        let prev = self.infos[i].prev;
-        self.infos[next].prev = prev;
-        self.infos[prev].next = next;
-        self.infos[i].next = 0;
-        self.infos[i].prev = 0;
+
+    impl RRScheduler {
+        pub fn new(max_time_slice: usize) -> Self {
+            RRScheduler {
+                max_time_slice,
+                infos: [RRProcInfo::default(); MAX_PROCESS_NUM],
+            }
+        }
+        fn _list_add_before(&mut self, i: Pid, at: Pid) {
+            let prev = self.infos[at].prev;
+            self.infos[i].next = at;
+            self.infos[i].prev = prev;
+            self.infos[prev].next = i;
+            self.infos[at].prev = i;
+        }
+        fn _list_remove(&mut self, i: Pid) {
+            let next = self.infos[i].next;
+            let prev = self.infos[i].prev;
+            self.infos[next].prev = prev;
+            self.infos[prev].next = next;
+            self.infos[i].next = 0;
+            self.infos[i].prev = 0;
+        }
     }
 }
 
+mod stride {
+    use super::*;
 
-pub struct StrideScheduler {
-    max_time_slice: usize,
-    infos: [StrideProcInfo; MAX_PROCESS_NUM],
-    queue: BinaryHeap<(Stride, Pid)>, // It's max heap, so pass < 0
-}
+    pub struct StrideScheduler {
+        max_time_slice: usize,
+        infos: [StrideProcInfo; MAX_PROCESS_NUM],
+        queue: BinaryHeap<(Stride, Pid)>, // It's max heap, so pass < 0
+    }
 
-#[derive(Debug, Default, Copy, Clone)]
-struct StrideProcInfo {
-    present: bool,
-    rest_slice: usize,
-    stride: Stride,
-    priority: u8,
-}
+    #[derive(Debug, Default, Copy, Clone)]
+    struct StrideProcInfo {
+        present: bool,
+        rest_slice: usize,
+        stride: Stride,
+        priority: u8,
+    }
 
-impl StrideProcInfo {
-    fn pass(&mut self) {
-        const BIG_STRIDE: Stride = 1 << 20;
-        let pass = if self.priority == 0 {
-            BIG_STRIDE
-        } else {
-            BIG_STRIDE / self.priority as Stride
-        };
-        // FIXME: overflowing_add is not working ???
-        // self.stride.overflowing_add(pass);
-        self.stride += pass;
+    impl StrideProcInfo {
+        fn pass(&mut self) {
+            const BIG_STRIDE: Stride = 1 << 20;
+            let pass = if self.priority == 0 {
+                BIG_STRIDE
+            } else {
+                BIG_STRIDE / self.priority as Stride
+            };
+            // FIXME: overflowing_add is not working ???
+            // self.stride.overflowing_add(pass);
+            self.stride += pass;
+        }
     }
-}
 
-type Stride = i32;
+    type Stride = i32;
 
-impl Scheduler for StrideScheduler {
-    fn insert(&mut self, pid: Pid) {
-        let info = &mut self.infos[pid];
-        assert!(!info.present);
-        info.present = true;
-        if info.rest_slice == 0 {
-            info.rest_slice = self.max_time_slice;
+    impl Scheduler for StrideScheduler {
+        fn insert(&mut self, pid: Pid) {
+            let info = &mut self.infos[pid];
+            assert!(!info.present);
+            info.present = true;
+            if info.rest_slice == 0 {
+                info.rest_slice = self.max_time_slice;
+            }
+            self.queue.push((-info.stride, pid));
+            debug!("insert {}", pid);
         }
-        self.queue.push((-info.stride, pid));
-        debug!("StrideScheduler: insert {}", pid);
-    }
 
-    fn remove(&mut self, pid: Pid) {
-        let info = &mut self.infos[pid];
-        assert!(info.present);
-        info.present = false;
-        // FIXME: Support removing any element
-        assert_eq!(self.queue.pop().unwrap().1, pid, "Can only remove the top");
-        debug!("StrideScheduler: remove {}", pid);
-    }
+        fn remove(&mut self, pid: Pid) {
+            let info = &mut self.infos[pid];
+            assert!(info.present);
+            info.present = false;
+            // FIXME: Support removing any element
+            assert_eq!(self.queue.pop().unwrap().1, pid, "Can only remove the top");
+            debug!("remove {}", pid);
+        }
 
-    fn select(&mut self) -> Option<Pid> {
-        let ret = self.queue.peek().map(|&(_, pid)| pid);
-        if let Some(pid) = ret {
-            let old_stride = self.infos[pid].stride;
-            self.infos[pid].pass();
-            let stride = self.infos[pid].stride;
-            debug!("StrideScheduler: {} stride {:#x} -> {:#x}", pid, old_stride, stride);
+        fn select(&mut self) -> Option<Pid> {
+            let ret = self.queue.peek().map(|&(_, pid)| pid);
+            if let Some(pid) = ret {
+                let old_stride = self.infos[pid].stride;
+                self.infos[pid].pass();
+                let stride = self.infos[pid].stride;
+                debug!("{} stride {:#x} -> {:#x}", pid, old_stride, stride);
+            }
+            debug!("select {:?}", ret);
+            ret
         }
-        debug!("StrideScheduler: select {:?}", ret);
-        ret
-    }
 
-    fn tick(&mut self, current: Pid) -> bool {
-        assert!(!self.infos[current].present);
+        fn tick(&mut self, current: Pid) -> bool {
+            assert!(!self.infos[current].present);
 
-        let rest = &mut self.infos[current].rest_slice;
-        if *rest > 0 {
-            *rest -= 1;
-        } else {
-            warn!("current process rest_slice = 0, need reschedule")
+            let rest = &mut self.infos[current].rest_slice;
+            if *rest > 0 {
+                *rest -= 1;
+            } else {
+                warn!("current process rest_slice = 0, need reschedule")
+            }
+            *rest == 0
         }
-        *rest == 0
     }
-}
 
-impl StrideScheduler {
-    pub fn new(max_time_slice: usize) -> Self {
-        StrideScheduler {
-            max_time_slice,
-            infos: [StrideProcInfo::default(); MAX_PROCESS_NUM],
-            queue: BinaryHeap::new(),
+    impl StrideScheduler {
+        pub fn new(max_time_slice: usize) -> Self {
+            StrideScheduler {
+                max_time_slice,
+                infos: [StrideProcInfo::default(); MAX_PROCESS_NUM],
+                queue: BinaryHeap::new(),
+            }
+        }
+        pub fn set_priority(&mut self, pid: Pid, priority: u8) {
+            self.infos[pid].priority = priority;
+            debug!("{} priority = {}", pid, priority);
         }
-    }
-    pub fn set_priority(&mut self, pid: Pid, priority: u8) {
-        self.infos[pid].priority = priority;
-        debug!("StrideScheduler: {} priority = {}", pid, priority);
     }
 }

src/thread.rs

@@ -31,6 +31,7 @@ pub fn spawn<F, T>(f: F) -> JoinHandle<T>
         F: Send + 'static + FnOnce() -> T,
         T: Send + 'static,
 {
+    info!("spawn:");
     use process;
     let pid = process::add_kernel_process(kernel_thread_entry::<F, T>, &f as *const _ as usize);
     return JoinHandle {
@@ -43,7 +44,6 @@ pub fn spawn<F, T>(f: F) -> JoinHandle<T>
             F: Send + 'static + FnOnce() -> T,
             T: Send + 'static,
     {
-        debug!("kernel_thread_entry");
         let f = unsafe { ptr::read(f as *mut F) };
         let ret = Box::new(f());
         let mut processor = PROCESSOR.try().unwrap().lock();
@@ -63,6 +63,7 @@ pub fn yield_now() {
 
 /// Blocks unless or until the current thread's token is made available.
 pub fn park() {
+    info!("park:");
     let mut processor = PROCESSOR.try().unwrap().lock();
     let pid = processor.current_pid();
     processor.sleep_(pid);