WangRunji
6 years ago
parent
c9a68634f5
commit
b77a52dccb
@ -1,8 +1,6 @@
|
||||
[workspace]
|
||||
members = [
|
||||
"crate/bit-allocator",
|
||||
"crate/memory",
|
||||
"crate/sync",
|
||||
"crate/thread",
|
||||
]
|
||||
exclude = ["kernel", "bootloader", "user/rust"]
|
||||
|
||||
@ -1,7 +0,0 @@
|
||||
[package]
|
||||
name = "bit-allocator"
|
||||
version = "0.1.0"
|
||||
authors = ["WangRunji <wangrunji0408@163.com>"]
|
||||
|
||||
[dependencies]
|
||||
bit_field = "0.9"
|
||||
@ -1,221 +0,0 @@
|
||||
#![no_std]
|
||||
#![feature(asm)]
|
||||
|
||||
extern crate bit_field;
|
||||
|
||||
use bit_field::BitField;
|
||||
use core::ops::Range;
|
||||
|
||||
/// Allocator of a bitmap, able to allocate / free bits.
|
||||
///
|
||||
/// CAP: the bitmap has a total of CAP bits, numbered from 0 to CAP-1 inclusively.
|
||||
///
|
||||
/// alloc: allocate a free bit.
|
||||
/// dealloc: free an allocated bit.
|
||||
///
|
||||
/// insert: mark bits in the range as allocated (available)
|
||||
/// remove: reverse of insert
|
||||
///
|
||||
/// any: whether there are free bits remaining
|
||||
/// test: whether a specific bit is free
|
||||
pub trait BitAlloc: Default {
|
||||
const CAP: usize;
|
||||
fn alloc(&mut self) -> Option<usize>;
|
||||
fn dealloc(&mut self, key: usize);
|
||||
fn insert(&mut self, range: Range<usize>);
|
||||
fn remove(&mut self, range: Range<usize>);
|
||||
fn any(&self) -> bool;
|
||||
fn test(&self, key: usize) -> bool;
|
||||
}
|
||||
|
||||
pub type BitAlloc256 = BitAllocCascade16<BitAlloc16>;
|
||||
pub type BitAlloc4K = BitAllocCascade16<BitAlloc256>;
|
||||
pub type BitAlloc64K = BitAllocCascade16<BitAlloc4K>;
|
||||
pub type BitAlloc1M = BitAllocCascade16<BitAlloc64K>;
|
||||
pub type BitAlloc16M = BitAllocCascade16<BitAlloc1M>;
|
||||
pub type BitAlloc256M = BitAllocCascade16<BitAlloc16M>;
|
||||
|
||||
/// Implement the bit allocator by segment tree algorithm.
|
||||
#[derive(Default)]
|
||||
pub struct BitAllocCascade16<T: BitAlloc> {
|
||||
bitset: u16, // for each bit, 1 indicates available, 0 indicates inavailable
|
||||
sub: [T; 16],
|
||||
}
|
||||
|
||||
impl<T: BitAlloc> BitAlloc for BitAllocCascade16<T> {
|
||||
const CAP: usize = T::CAP * 16;
|
||||
|
||||
fn alloc(&mut self) -> Option<usize> {
|
||||
if self.any() {
|
||||
let i = log2(self.bitset);
|
||||
let res = self.sub[i].alloc().unwrap() + i * T::CAP;
|
||||
self.bitset.set_bit(i, self.sub[i].any());
|
||||
Some(res)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
fn dealloc(&mut self, key: usize) {
|
||||
let i = key / T::CAP;
|
||||
self.sub[i].dealloc(key % T::CAP);
|
||||
self.bitset.set_bit(i, true);
|
||||
}
|
||||
fn insert(&mut self, range: Range<usize>) {
|
||||
self.for_range(range, |sub: &mut T, range| sub.insert(range));
|
||||
}
|
||||
fn remove(&mut self, range: Range<usize>) {
|
||||
self.for_range(range, |sub: &mut T, range| sub.remove(range));
|
||||
}
|
||||
fn any(&self) -> bool {
|
||||
self.bitset != 0
|
||||
}
|
||||
fn test(&self, key: usize) -> bool {
|
||||
self.sub[key / T::CAP].test(key % T::CAP)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: BitAlloc> BitAllocCascade16<T> {
|
||||
fn for_range(&mut self, range: Range<usize>, f: impl Fn(&mut T, Range<usize>)) {
|
||||
let Range { start, end } = range;
|
||||
assert!(start <= end);
|
||||
assert!(end <= Self::CAP);
|
||||
for i in start / T::CAP..=(end - 1) / T::CAP {
|
||||
let begin = if start / T::CAP == i {
|
||||
start % T::CAP
|
||||
} else {
|
||||
0
|
||||
};
|
||||
let end = if end / T::CAP == i {
|
||||
end % T::CAP
|
||||
} else {
|
||||
T::CAP
|
||||
};
|
||||
f(&mut self.sub[i], begin..end);
|
||||
self.bitset.set_bit(i, self.sub[i].any());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct BitAlloc16(u16);
|
||||
|
||||
/// BitAlloc16 acts as the leaf (except the leaf bits of course) nodes
|
||||
/// in the segment trees.
|
||||
impl BitAlloc for BitAlloc16 {
|
||||
const CAP: usize = 16;
|
||||
|
||||
fn alloc(&mut self) -> Option<usize> {
|
||||
if self.any() {
|
||||
let i = log2(self.0);
|
||||
self.0.set_bit(i, false);
|
||||
Some(i)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
fn dealloc(&mut self, key: usize) {
|
||||
assert!(!self.test(key));
|
||||
self.0.set_bit(key, true);
|
||||
}
|
||||
fn insert(&mut self, range: Range<usize>) {
|
||||
self.0.set_bits(range.clone(), 0xffff.get_bits(range));
|
||||
}
|
||||
fn remove(&mut self, range: Range<usize>) {
|
||||
self.0.set_bits(range, 0);
|
||||
}
|
||||
fn any(&self) -> bool {
|
||||
self.0 != 0
|
||||
}
|
||||
fn test(&self, key: usize) -> bool {
|
||||
self.0.get_bit(key)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
fn log2(x: u16) -> usize {
|
||||
assert_ne!(x, 0);
|
||||
let pos: u16;
|
||||
unsafe { asm!("bsrw $1, $0" :"=r"(pos) :"r"(x) : :"volatile") };
|
||||
pos as usize
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(not(target_arch = "x86_64"))]
|
||||
fn log2(x: u16) -> usize {
|
||||
log2_naive(x)
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "x86_64"))]
|
||||
#[inline(always)]
|
||||
fn log2_naive(mut x: u16) -> usize {
|
||||
//a naive implement
|
||||
assert_ne!(x, 0);
|
||||
let mut pos = -1;
|
||||
while x != 0 {
|
||||
pos += 1;
|
||||
x >>= 1;
|
||||
}
|
||||
pos as usize
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[cfg(not(target_arch = "x86_64"))]
|
||||
#[test]
|
||||
fn log2_() {
|
||||
for x in 1..=0xffff {
|
||||
assert_eq!(log2(x), log2_naive(x), "log2 failed: {}", x);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bitalloc16() {
|
||||
let mut ba = BitAlloc16::default();
|
||||
assert_eq!(BitAlloc16::CAP, 16);
|
||||
ba.insert(0..16);
|
||||
for i in 0..16 {
|
||||
assert_eq!(ba.test(i), true);
|
||||
}
|
||||
ba.remove(8..14);
|
||||
assert_eq!(ba.alloc(), Some(15));
|
||||
assert_eq!(ba.alloc(), Some(14));
|
||||
assert_eq!(ba.alloc(), Some(7));
|
||||
ba.dealloc(14);
|
||||
ba.dealloc(15);
|
||||
ba.dealloc(7);
|
||||
|
||||
for _ in 0..10 {
|
||||
assert!(ba.alloc().is_some());
|
||||
}
|
||||
assert!(!ba.any());
|
||||
assert!(ba.alloc().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bitalloc4k() {
|
||||
let mut ba = BitAlloc4K::default();
|
||||
assert_eq!(BitAlloc4K::CAP, 4096);
|
||||
ba.insert(0..4096);
|
||||
for i in 0..4096 {
|
||||
assert_eq!(ba.test(i), true);
|
||||
}
|
||||
ba.remove(8..4094);
|
||||
for i in 0..4096 {
|
||||
assert_eq!(ba.test(i), i < 8 || i >= 4094);
|
||||
}
|
||||
assert_eq!(ba.alloc(), Some(4095));
|
||||
assert_eq!(ba.alloc(), Some(4094));
|
||||
assert_eq!(ba.alloc(), Some(7));
|
||||
ba.dealloc(4095);
|
||||
ba.dealloc(4094);
|
||||
ba.dealloc(7);
|
||||
|
||||
for _ in 0..10 {
|
||||
assert!(ba.alloc().is_some());
|
||||
}
|
||||
assert!(ba.alloc().is_none());
|
||||
}
|
||||
}
|
||||
@ -1,11 +0,0 @@
|
||||
[package]
|
||||
name = "rcore-thread"
|
||||
version = "0.1.0"
|
||||
authors = ["WangRunji <wangrunji0408@163.com>"]
|
||||
description = "Bare-metal thread scheduler and executor"
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
log = "0.4"
|
||||
spin = "0.5"
|
||||
deque = { git = "https://github.com/rcore-os/deque.git", branch = "no_std" }
|
||||
@ -1 +0,0 @@
|
||||
fn main() {}
|
||||
@ -1,19 +0,0 @@
|
||||
[package]
|
||||
name = "example"
|
||||
version = "0.1.0"
|
||||
authors = ["WangRunji <wangrunji0408@163.com>"]
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
log = "0.4"
|
||||
linked_list_allocator = "0.6"
|
||||
blog_os = { git = "https://github.com/phil-opp/blog_os.git" }
|
||||
rcore-thread = { path = ".." }
|
||||
|
||||
[package.metadata.bootimage]
|
||||
default-target = "x86_64-blog_os.json"
|
||||
run-command = ["qemu-system-x86_64",
|
||||
"-drive", "format=raw,file={}",
|
||||
"-serial", "mon:stdio",
|
||||
"-device", "isa-debug-exit,iobase=0xf4,iosize=0x04"
|
||||
]
|
||||
@ -1,5 +0,0 @@
|
||||
# Example of `rcore-thread` crate
|
||||
|
||||
```bash
|
||||
bootimage run --release
|
||||
```
|
||||
@ -1,204 +0,0 @@
|
||||
#![no_std]
|
||||
#![no_main]
|
||||
#![feature(asm)]
|
||||
#![feature(alloc)]
|
||||
#![feature(naked_functions)]
|
||||
#![feature(lang_items)]
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
use core::alloc::Layout;
|
||||
use core::panic::PanicInfo;
|
||||
use alloc::{boxed::Box, sync::Arc};
|
||||
|
||||
use blog_os::{exit_qemu, gdt, interrupts::init_idt, serial_println};
|
||||
use linked_list_allocator::LockedHeap;
|
||||
use rcore_thread::{*, std_thread as thread};
|
||||
|
||||
const STACK_SIZE: usize = 0x2000;
|
||||
const HEAP_SIZE: usize = 0x100000;
|
||||
const MAX_CPU_NUM: usize = 1;
|
||||
const MAX_PROC_NUM: usize = 32;
|
||||
|
||||
|
||||
/// The entry of the kernel
|
||||
#[no_mangle]
|
||||
pub extern "C" fn _start() -> ! {
|
||||
// init x86
|
||||
gdt::init();
|
||||
init_idt();
|
||||
// init log
|
||||
init_log();
|
||||
// init heap
|
||||
unsafe { HEAP_ALLOCATOR.lock().init(HEAP.as_ptr() as usize, HEAP_SIZE); }
|
||||
// init processor
|
||||
let scheduler = scheduler::RRScheduler::new(5);
|
||||
let thread_pool = Arc::new(ThreadPool::new(scheduler, MAX_PROC_NUM));
|
||||
unsafe { processor().init(0, Thread::init(), thread_pool); }
|
||||
// init threads
|
||||
thread::spawn(|| {
|
||||
let tid = processor().tid();
|
||||
serial_println!("[{}] yield", tid);
|
||||
thread::yield_now();
|
||||
serial_println!("[{}] spawn", tid);
|
||||
let t2 = thread::spawn(|| {
|
||||
let tid = processor().tid();
|
||||
serial_println!("[{}] yield", tid);
|
||||
thread::yield_now();
|
||||
serial_println!("[{}] return 8", tid);
|
||||
8
|
||||
});
|
||||
serial_println!("[{}] join", tid);
|
||||
let ret = t2.join();
|
||||
serial_println!("[{}] get {:?}", tid, ret);
|
||||
serial_println!("[{}] exit", tid);
|
||||
});
|
||||
// run threads
|
||||
processor().run();
|
||||
}
|
||||
|
||||
fn init_log() {
|
||||
use log::*;
|
||||
struct SimpleLogger;
|
||||
impl Log for SimpleLogger {
|
||||
fn enabled(&self, _metadata: &Metadata) -> bool {
|
||||
true
|
||||
}
|
||||
fn log(&self, record: &Record) {
|
||||
serial_println!("[{:>5}] {}", record.level(), record.args());
|
||||
}
|
||||
fn flush(&self) {}
|
||||
}
|
||||
static LOGGER: SimpleLogger = SimpleLogger;
|
||||
set_logger(&LOGGER).unwrap();
|
||||
set_max_level(LevelFilter::Trace);
|
||||
}
|
||||
|
||||
/// The context of a thread.
|
||||
///
|
||||
/// When a thread yield, its context will be stored at its stack.
|
||||
#[derive(Debug, Default)]
|
||||
#[repr(C)]
|
||||
struct ContextData {
|
||||
rdi: usize, // arg0
|
||||
r15: usize,
|
||||
r14: usize,
|
||||
r13: usize,
|
||||
r12: usize,
|
||||
rbp: usize,
|
||||
rbx: usize,
|
||||
rip: usize,
|
||||
}
|
||||
|
||||
impl ContextData {
|
||||
fn new(entry: extern fn(usize) -> !, arg0: usize) -> Self {
|
||||
ContextData {
|
||||
rip: entry as usize,
|
||||
rdi: arg0,
|
||||
..ContextData::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct Thread {
|
||||
rsp: usize,
|
||||
stack: [u8; STACK_SIZE],
|
||||
}
|
||||
|
||||
impl Thread {
|
||||
unsafe fn init() -> Box<Self> {
|
||||
Box::new(core::mem::uninitialized())
|
||||
}
|
||||
fn new(entry: extern fn(usize) -> !, arg0: usize) -> Box<Self> {
|
||||
let mut thread = unsafe { Thread::init() };
|
||||
let rsp = thread.stack.as_ptr() as usize + STACK_SIZE - core::mem::size_of::<ContextData>();
|
||||
// push a Context at stack top
|
||||
let init_context = ContextData::new(entry, arg0);
|
||||
unsafe { (rsp as *mut ContextData).write(init_context); }
|
||||
thread.rsp = rsp;
|
||||
thread
|
||||
}
|
||||
}
|
||||
|
||||
/// Implement `switch_to` for a thread
|
||||
impl Context for Thread {
|
||||
/// Switch to another thread.
|
||||
unsafe fn switch_to(&mut self, target: &mut Context) {
|
||||
let (to, _): (*mut Thread, usize) = core::mem::transmute(target);
|
||||
inner(self, to);
|
||||
|
||||
#[naked]
|
||||
#[inline(never)]
|
||||
unsafe extern "C" fn inner(_from: *mut Thread, _to: *mut Thread) {
|
||||
asm!(
|
||||
"
|
||||
// push rip (by caller)
|
||||
|
||||
// Save self callee-save registers
|
||||
push rbx
|
||||
push rbp
|
||||
push r12
|
||||
push r13
|
||||
push r14
|
||||
push r15
|
||||
push rdi
|
||||
|
||||
// Switch stacks
|
||||
mov [rdi], rsp // *rdi = from_rsp
|
||||
mov rsp, [rsi] // *rsi = to_rsp
|
||||
|
||||
// Restore target callee-save registers
|
||||
pop rdi
|
||||
pop r15
|
||||
pop r14
|
||||
pop r13
|
||||
pop r12
|
||||
pop rbp
|
||||
pop rbx
|
||||
|
||||
// pop rip
|
||||
ret"
|
||||
: : : : "intel" "volatile" )
|
||||
}
|
||||
}
|
||||
|
||||
fn set_tid(&mut self, _tid: usize) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Define global `Processor` for each core.
|
||||
static PROCESSORS: [Processor; MAX_CPU_NUM] = [Processor::new()];
|
||||
|
||||
/// Now we only have one core.
|
||||
fn cpu_id() -> usize { 0 }
|
||||
|
||||
/// Implement dependency for `rcore_thread::std_thread`
|
||||
#[no_mangle]
|
||||
pub fn processor() -> &'static Processor {
|
||||
&PROCESSORS[cpu_id()]
|
||||
}
|
||||
|
||||
/// Implement dependency for `rcore_thread::std_thread`
|
||||
#[no_mangle]
|
||||
pub fn new_kernel_context(entry: extern fn(usize) -> !, arg0: usize) -> Box<Context> {
|
||||
Thread::new(entry, arg0)
|
||||
}
|
||||
|
||||
#[panic_handler]
|
||||
fn panic(info: &PanicInfo) -> ! {
|
||||
serial_println!("\n{}", info);
|
||||
|
||||
unsafe { exit_qemu(); }
|
||||
loop {}
|
||||
}
|
||||
|
||||
#[global_allocator]
|
||||
static HEAP_ALLOCATOR: LockedHeap = LockedHeap::empty();
|
||||
|
||||
static mut HEAP: [u8; HEAP_SIZE] = [0; HEAP_SIZE];
|
||||
|
||||
#[lang = "oom"]
|
||||
fn oom(_: Layout) -> ! {
|
||||
panic!("out of memory");
|
||||
}
|
||||
@ -1,15 +0,0 @@
|
||||
{
|
||||
"llvm-target": "x86_64-unknown-none",
|
||||
"data-layout": "e-m:e-i64:64-f80:128-n8:16:32:64-S128",
|
||||
"arch": "x86_64",
|
||||
"target-endian": "little",
|
||||
"target-pointer-width": "64",
|
||||
"target-c-int-width": "32",
|
||||
"os": "none",
|
||||
"executables": true,
|
||||
"linker-flavor": "ld.lld",
|
||||
"linker": "rust-lld",
|
||||
"panic-strategy": "abort",
|
||||
"disable-redzone": true,
|
||||
"features": "-mmx,-sse,+soft-float"
|
||||
}
|
||||
@ -1,63 +0,0 @@
|
||||
//! Enable and disable interrupt for each architecture.
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
pub unsafe fn disable_and_store() -> usize {
|
||||
let rflags: usize;
|
||||
asm!("pushfq; popq $0; cli" : "=r"(rflags) ::: "volatile");
|
||||
rflags & (1 << 9)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
pub unsafe fn restore(flags: usize) {
|
||||
if flags != 0 {
|
||||
asm!("sti" :::: "volatile");
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
pub unsafe fn enable_and_wfi() {
|
||||
asm!("sti; hlt" :::: "volatile");
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]
|
||||
pub unsafe fn disable_and_store() -> usize {
|
||||
let sstatus: usize;
|
||||
asm!("csrci sstatus, 1 << 1" : "=r"(sstatus) ::: "volatile");
|
||||
sstatus & (1 << 1)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]
|
||||
pub unsafe fn restore(flags: usize) {
|
||||
asm!("csrs sstatus, $0" :: "r"(flags) :: "volatile");
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]
|
||||
pub unsafe fn enable_and_wfi() {
|
||||
asm!("csrsi sstatus, 1 << 1; wfi" :::: "volatile");
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
pub unsafe fn disable_and_store() -> usize {
|
||||
let daif: u32;
|
||||
asm!("mrs $0, DAIF; msr daifset, #2": "=r"(daif) ::: "volatile");
|
||||
daif as usize
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
pub unsafe fn restore(flags: usize) {
|
||||
asm!("msr DAIF, $0" :: "r"(flags as u32) :: "volatile");
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
pub unsafe fn enable_and_wfi() {
|
||||
asm!("msr daifclr, #2; wfi" :::: "volatile");
|
||||
}
|
||||
@ -1,19 +0,0 @@
|
||||
#![cfg_attr(not(test), no_std)]
|
||||
#![feature(alloc)]
|
||||
#![feature(const_fn)]
|
||||
#![feature(linkage)]
|
||||
#![feature(vec_resize_default)]
|
||||
#![feature(asm)]
|
||||
#![feature(exact_size_is_empty)]
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
mod interrupt;
|
||||
mod processor;
|
||||
pub mod scheduler;
|
||||
pub mod std_thread;
|
||||
mod thread_pool;
|
||||
mod timer;
|
||||
|
||||
pub use crate::processor::Processor;
|
||||
pub use crate::thread_pool::*;
|
||||
@ -1,127 +0,0 @@
|
||||
use crate::interrupt;
|
||||
use crate::thread_pool::*;
|
||||
use alloc::boxed::Box;
|
||||
use alloc::sync::Arc;
|
||||
use core::cell::UnsafeCell;
|
||||
use log::*;
|
||||
|
||||
/// Thread executor
|
||||
///
|
||||
/// Per-CPU struct. Defined at global.
|
||||
/// Only accessed by associated CPU with interrupt disabled.
|
||||
#[derive(Default)]
|
||||
pub struct Processor {
|
||||
inner: UnsafeCell<Option<ProcessorInner>>,
|
||||
}
|
||||
|
||||
unsafe impl Sync for Processor {}
|
||||
|
||||
struct ProcessorInner {
|
||||
id: usize,
|
||||
proc: Option<(Tid, Box<Context>)>,
|
||||
loop_context: Box<Context>,
|
||||
manager: Arc<ThreadPool>,
|
||||
}
|
||||
|
||||
impl Processor {
|
||||
pub const fn new() -> Self {
|
||||
Processor {
|
||||
inner: UnsafeCell::new(None),
|
||||
}
|
||||
}
|
||||
|
||||
pub unsafe fn init(&self, id: usize, context: Box<Context>, manager: Arc<ThreadPool>) {
|
||||
*self.inner.get() = Some(ProcessorInner {
|
||||
id,
|
||||
proc: None,
|
||||
loop_context: context,
|
||||
manager,
|
||||
});
|
||||
}
|
||||
|
||||
fn inner(&self) -> &mut ProcessorInner {
|
||||
unsafe { &mut *self.inner.get() }
|
||||
.as_mut()
|
||||
.expect("Processor is not initialized")
|
||||
}
|
||||
|
||||
/// Begin running processes after CPU setup.
|
||||
///
|
||||
/// This function never returns. It loops, doing:
|
||||
/// - choose a process to run
|
||||
/// - switch to start running that process
|
||||
/// - eventually that process transfers control
|
||||
/// via switch back to the scheduler.
|
||||
pub fn run(&self) -> ! {
|
||||
let inner = self.inner();
|
||||
unsafe {
|
||||
interrupt::disable_and_store();
|
||||
}
|
||||
loop {
|
||||
if let Some(proc) = inner.manager.run(inner.id) {
|
||||
trace!("CPU{} begin running thread {}", inner.id, proc.0);
|
||||
inner.proc = Some(proc);
|
||||
unsafe {
|
||||
inner
|
||||
.loop_context
|
||||
.switch_to(&mut *inner.proc.as_mut().unwrap().1);
|
||||
}
|
||||
let (tid, context) = inner.proc.take().unwrap();
|
||||
trace!("CPU{} stop running thread {}", inner.id, tid);
|
||||
inner.manager.stop(tid, context);
|
||||
} else {
|
||||
trace!("CPU{} idle", inner.id);
|
||||
unsafe {
|
||||
interrupt::enable_and_wfi();
|
||||
}
|
||||
// wait for a timer interrupt
|
||||
unsafe {
|
||||
interrupt::disable_and_store();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Called by process running on this Processor.
|
||||
/// Yield and reschedule.
|
||||
///
|
||||
/// The interrupt may be enabled.
|
||||
pub fn yield_now(&self) {
|
||||
let inner = self.inner();
|
||||
unsafe {
|
||||
let flags = interrupt::disable_and_store();
|
||||
inner
|
||||
.proc
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.1
|
||||
.switch_to(&mut *inner.loop_context);
|
||||
interrupt::restore(flags);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn tid(&self) -> Tid {
|
||||
self.inner().proc.as_ref().unwrap().0
|
||||
}
|
||||
|
||||
pub fn context(&self) -> &Context {
|
||||
&*self.inner().proc.as_ref().unwrap().1
|
||||
}
|
||||
|
||||
pub fn manager(&self) -> &ThreadPool {
|
||||
&*self.inner().manager
|
||||
}
|
||||
|
||||
/// Called by timer interrupt handler.
|
||||
///
|
||||
/// The interrupt should be disabled in the handler.
|
||||
pub fn tick(&self) {
|
||||
// If I'm idle, tid == None, need_reschedule == false.
|
||||
// Will go back to `run()` after interrupt return.
|
||||
let tid = self.inner().proc.as_ref().map(|p| p.0);
|
||||
let need_reschedule = self.manager().tick(self.inner().id, tid);
|
||||
if need_reschedule {
|
||||
self.yield_now();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,34 +0,0 @@
|
||||
use alloc::{collections::BinaryHeap, vec::Vec};
|
||||
|
||||
use log::*;
|
||||
use spin::Mutex;
|
||||
|
||||
pub use self::o1::O1Scheduler;
|
||||
pub use self::rr::RRScheduler;
|
||||
pub use self::stride::StrideScheduler;
|
||||
pub use self::work_stealing::WorkStealingScheduler;
|
||||
|
||||
mod o1;
|
||||
mod rr;
|
||||
mod stride;
|
||||
mod work_stealing;
|
||||
|
||||
type Tid = usize;
|
||||
|
||||
/// The scheduler for a ThreadPool
|
||||
pub trait Scheduler: 'static {
|
||||
/// Push a thread to the back of ready queue.
|
||||
fn push(&self, tid: Tid);
|
||||
/// Select a thread to run, pop it from the queue.
|
||||
fn pop(&self, cpu_id: usize) -> Option<Tid>;
|
||||
/// Got a tick from CPU.
|
||||
/// Return true if need reschedule.
|
||||
fn tick(&self, current_tid: Tid) -> bool;
|
||||
/// Set priority of a thread.
|
||||
fn set_priority(&self, tid: Tid, priority: u8);
|
||||
}
|
||||
|
||||
fn expand<T: Default + Clone>(vec: &mut Vec<T>, id: usize) {
|
||||
let len = vec.len();
|
||||
vec.resize(len.max(id + 1), T::default());
|
||||
}
|
||||
@ -1,65 +0,0 @@
|
||||
//! O(1) scheduler introduced in Linux 2.6
|
||||
//!
|
||||
//! Two queues are maintained, one is active, another is inactive.
|
||||
//! Take the first task from the active queue to run. When it is empty, swap active and inactive queues.
|
||||
|
||||
use super::*;
|
||||
|
||||
pub struct O1Scheduler {
|
||||
inner: Mutex<O1SchedulerInner>,
|
||||
}
|
||||
|
||||
struct O1SchedulerInner {
|
||||
active_queue: usize,
|
||||
queues: [Vec<Tid>; 2],
|
||||
}
|
||||
|
||||
impl Scheduler for O1Scheduler {
|
||||
fn push(&self, tid: usize) {
|
||||
self.inner.lock().push(tid);
|
||||
}
|
||||
fn pop(&self, _cpu_id: usize) -> Option<usize> {
|
||||
self.inner.lock().pop()
|
||||
}
|
||||
fn tick(&self, current_tid: usize) -> bool {
|
||||
self.inner.lock().tick(current_tid)
|
||||
}
|
||||
fn set_priority(&self, _tid: usize, _priority: u8) {}
|
||||
}
|
||||
|
||||
impl O1Scheduler {
|
||||
pub fn new() -> Self {
|
||||
let inner = O1SchedulerInner {
|
||||
active_queue: 0,
|
||||
queues: [Vec::new(), Vec::new()],
|
||||
};
|
||||
O1Scheduler {
|
||||
inner: Mutex::new(inner),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl O1SchedulerInner {
|
||||
fn push(&mut self, tid: Tid) {
|
||||
let inactive_queue = 1 - self.active_queue;
|
||||
self.queues[inactive_queue].push(tid);
|
||||
trace!("o1 push {}", tid - 1);
|
||||
}
|
||||
|
||||
fn pop(&mut self) -> Option<Tid> {
|
||||
let ret = match self.queues[self.active_queue].pop() {
|
||||
Some(tid) => return Some(tid),
|
||||
None => {
|
||||
// active queue is empty, swap 'em
|
||||
self.active_queue = 1 - self.active_queue;
|
||||
self.queues[self.active_queue].pop()
|
||||
}
|
||||
};
|
||||
trace!("o1 pop {:?}", ret);
|
||||
ret
|
||||
}
|
||||
|
||||
fn tick(&mut self, _current: Tid) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
@ -1,109 +0,0 @@
|
||||
use super::*;
|
||||
|
||||
pub struct RRScheduler {
|
||||
inner: Mutex<RRSchedulerInner>,
|
||||
}
|
||||
|
||||
struct RRSchedulerInner {
|
||||
max_time_slice: usize,
|
||||
infos: Vec<RRProcInfo>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Copy, Clone)]
|
||||
struct RRProcInfo {
|
||||
present: bool,
|
||||
rest_slice: usize,
|
||||
prev: Tid,
|
||||
next: Tid,
|
||||
}
|
||||
|
||||
impl Scheduler for RRScheduler {
|
||||
fn push(&self, tid: usize) {
|
||||
self.inner.lock().push(tid);
|
||||
}
|
||||
fn pop(&self, _cpu_id: usize) -> Option<usize> {
|
||||
self.inner.lock().pop()
|
||||
}
|
||||
fn tick(&self, current_tid: usize) -> bool {
|
||||
self.inner.lock().tick(current_tid)
|
||||
}
|
||||
fn set_priority(&self, _tid: usize, _priority: u8) {}
|
||||
}
|
||||
|
||||
impl RRScheduler {
|
||||
pub fn new(max_time_slice: usize) -> Self {
|
||||
let inner = RRSchedulerInner {
|
||||
max_time_slice,
|
||||
infos: Vec::default(),
|
||||
};
|
||||
RRScheduler {
|
||||
inner: Mutex::new(inner),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl RRSchedulerInner {
|
||||
fn push(&mut self, tid: Tid) {
|
||||
let tid = tid + 1;
|
||||
expand(&mut self.infos, tid);
|
||||
{
|
||||
let info = &mut self.infos[tid];
|
||||
assert!(!info.present);
|
||||
info.present = true;
|
||||
if info.rest_slice == 0 {
|
||||
info.rest_slice = self.max_time_slice;
|
||||
}
|
||||
}
|
||||
self._list_add_before(tid, 0);
|
||||
trace!("rr push {}", tid - 1);
|
||||
}
|
||||
|
||||
fn pop(&mut self) -> Option<Tid> {
|
||||
let ret = match self.infos[0].next {
|
||||
0 => None,
|
||||
tid => {
|
||||
self.infos[tid].present = false;
|
||||
self._list_remove(tid);
|
||||
Some(tid - 1)
|
||||
}
|
||||
};
|
||||
trace!("rr pop {:?}", ret);
|
||||
ret
|
||||
}
|
||||
|
||||
fn tick(&mut self, current: Tid) -> bool {
|
||||
let current = current + 1;
|
||||
expand(&mut self.infos, current);
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
impl RRSchedulerInner {
|
||||
fn _list_add_before(&mut self, i: Tid, at: Tid) {
|
||||
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_add_after(&mut self, i: Tid, at: Tid) {
|
||||
let next = self.infos[at].next;
|
||||
self._list_add_before(i, next);
|
||||
}
|
||||
fn _list_remove(&mut self, i: Tid) {
|
||||
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;
|
||||
}
|
||||
}
|
||||
@ -1,113 +0,0 @@
|
||||
//! Stride scheduler
|
||||
//!
|
||||
//! Each task is assigned a priority. Each task has a running stride.
|
||||
//! The task with least stride is selected to run.
|
||||
//! When a task is rescheduled, its stride is added to proportional to 1 / priority.
|
||||
|
||||
use super::*;
|
||||
|
||||
pub struct StrideScheduler {
|
||||
inner: Mutex<StrideSchedulerInner>,
|
||||
}
|
||||
|
||||
pub struct StrideSchedulerInner {
|
||||
max_time_slice: usize,
|
||||
infos: Vec<StrideProcInfo>,
|
||||
queue: BinaryHeap<(Stride, Tid)>, // It's max heap, so pass < 0
|
||||
}
|
||||
|
||||
#[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;
|
||||
}
|
||||
}
|
||||
|
||||
type Stride = i32;
|
||||
|
||||
impl Scheduler for StrideScheduler {
|
||||
fn push(&self, tid: usize) {
|
||||
self.inner.lock().push(tid);
|
||||
}
|
||||
fn pop(&self, _cpu_id: usize) -> Option<usize> {
|
||||
self.inner.lock().pop()
|
||||
}
|
||||
fn tick(&self, current_tid: usize) -> bool {
|
||||
self.inner.lock().tick(current_tid)
|
||||
}
|
||||
fn set_priority(&self, tid: usize, priority: u8) {
|
||||
self.inner.lock().set_priority(tid, priority);
|
||||
}
|
||||
}
|
||||
|
||||
impl StrideScheduler {
|
||||
pub fn new(max_time_slice: usize) -> Self {
|
||||
let inner = StrideSchedulerInner {
|
||||
max_time_slice,
|
||||
infos: Vec::default(),
|
||||
queue: BinaryHeap::default(),
|
||||
};
|
||||
StrideScheduler {
|
||||
inner: Mutex::new(inner),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl StrideSchedulerInner {
|
||||
fn push(&mut self, tid: Tid) {
|
||||
expand(&mut self.infos, tid);
|
||||
let info = &mut self.infos[tid];
|
||||
assert!(!info.present);
|
||||
info.present = true;
|
||||
if info.rest_slice == 0 {
|
||||
info.rest_slice = self.max_time_slice;
|
||||
}
|
||||
self.queue.push((-info.stride, tid));
|
||||
trace!("stride push {}", tid);
|
||||
}
|
||||
|
||||
fn pop(&mut self) -> Option<Tid> {
|
||||
let ret = self.queue.pop().map(|(_, tid)| tid);
|
||||
if let Some(tid) = ret {
|
||||
let old_stride = self.infos[tid].stride;
|
||||
self.infos[tid].pass();
|
||||
let stride = self.infos[tid].stride;
|
||||
trace!("stride {} {:#x} -> {:#x}", tid, old_stride, stride);
|
||||
}
|
||||
trace!("stride pop {:?}", ret);
|
||||
ret
|
||||
}
|
||||
|
||||
fn tick(&mut self, current: Tid) -> bool {
|
||||
expand(&mut self.infos, current);
|
||||
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 set_priority(&mut self, tid: Tid, priority: u8) {
|
||||
self.infos[tid].priority = priority;
|
||||
trace!("stride {} priority = {}", tid, priority);
|
||||
}
|
||||
}
|
||||
@ -1,80 +0,0 @@
|
||||
//! Work stealing scheduler
|
||||
//!
|
||||
//! Each CPU has its own queue, and each CPU takes new jobs from its own queue.
|
||||
//! When its queue is empty, steal jobs from other CPU's queue.
|
||||
|
||||
use super::*;
|
||||
use deque::{self, Stealer, Stolen, Worker};
|
||||
|
||||
pub struct WorkStealingScheduler {
|
||||
/// The ready queue of each processors
|
||||
workers: Vec<Worker<Tid>>,
|
||||
/// Stealers to all processors' queue
|
||||
stealers: Vec<Stealer<Tid>>,
|
||||
}
|
||||
|
||||
impl WorkStealingScheduler {
|
||||
pub fn new(core_num: usize) -> Self {
|
||||
let (workers, stealers) = (0..core_num).map(|_| deque::new()).unzip();
|
||||
WorkStealingScheduler { workers, stealers }
|
||||
}
|
||||
}
|
||||
|
||||
impl Scheduler for WorkStealingScheduler {
|
||||
fn push(&self, tid: usize) {
|
||||
// not random, but uniform
|
||||
// no sync, because we don't need to
|
||||
static mut WORKER_CPU: usize = 0;
|
||||
let n = self.workers.len();
|
||||
let mut cpu = unsafe {
|
||||
WORKER_CPU = WORKER_CPU + 1;
|
||||
if WORKER_CPU >= n {
|
||||
WORKER_CPU -= n;
|
||||
}
|
||||
WORKER_CPU
|
||||
};
|
||||
|
||||
// potential racing, so we just check once more
|
||||
if cpu >= n {
|
||||
cpu -= n;
|
||||
}
|
||||
self.workers[cpu].push(tid);
|
||||
trace!("work-stealing: cpu{} push thread {}", cpu, tid);
|
||||
}
|
||||
|
||||
fn pop(&self, cpu_id: usize) -> Option<usize> {
|
||||
if let Some(tid) = self.workers[cpu_id].pop() {
|
||||
trace!("work-stealing: cpu{} pop thread {}", cpu_id, tid);
|
||||
return Some(tid);
|
||||
}
|
||||
let n = self.workers.len();
|
||||
for i in 1..n {
|
||||
let mut other_id = cpu_id + i;
|
||||
if other_id >= n {
|
||||
other_id -= n;
|
||||
}
|
||||
loop {
|
||||
match self.stealers[other_id].steal() {
|
||||
Stolen::Abort => {} // retry
|
||||
Stolen::Empty => break,
|
||||
Stolen::Data(tid) => {
|
||||
trace!(
|
||||
"work-stealing: cpu{} steal thread {} from cpu{}",
|
||||
cpu_id,
|
||||
tid,
|
||||
other_id
|
||||
);
|
||||
return Some(tid);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn tick(&self, _current_tid: usize) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn set_priority(&self, _tid: usize, _priority: u8) {}
|
||||
}
|
||||
@ -1,221 +0,0 @@
|
||||
use crate::scheduler::Scheduler;
|
||||
use crate::timer::Timer;
|
||||
use alloc::boxed::Box;
|
||||
use alloc::vec::Vec;
|
||||
use log::*;
|
||||
use spin::{Mutex, MutexGuard};
|
||||
|
||||
struct Thread {
|
||||
status: Status,
|
||||
status_after_stop: Status,
|
||||
waiter: Option<Tid>,
|
||||
context: Option<Box<Context>>,
|
||||
}
|
||||
|
||||
pub type Tid = usize;
|
||||
type ExitCode = usize;
|
||||
|
||||
#[derive(Debug, Clone, Eq, PartialEq)]
|
||||
pub enum Status {
|
||||
Ready,
|
||||
Running(usize),
|
||||
Sleeping,
|
||||
/// aka ZOMBIE. Its context was dropped.
|
||||
Exited(ExitCode),
|
||||
}
|
||||
|
||||
#[derive(Eq, PartialEq)]
|
||||
enum Event {
|
||||
Wakeup(Tid),
|
||||
}
|
||||
|
||||
pub trait Context {
|
||||
/// Switch to target context
|
||||
unsafe fn switch_to(&mut self, target: &mut Context);
|
||||
|
||||
/// A tid is allocated for this context
|
||||
fn set_tid(&mut self, tid: Tid);
|
||||
}
|
||||
|
||||
pub struct ThreadPool {
|
||||
threads: Vec<Mutex<Option<Thread>>>,
|
||||
scheduler: Box<Scheduler>,
|
||||
timer: Mutex<Timer<Event>>,
|
||||
}
|
||||
|
||||
impl ThreadPool {
|
||||
pub fn new(scheduler: impl Scheduler, max_proc_num: usize) -> Self {
|
||||
ThreadPool {
|
||||
threads: new_vec_default(max_proc_num),
|
||||
scheduler: Box::new(scheduler),
|
||||
timer: Mutex::new(Timer::new()),
|
||||
}
|
||||
}
|
||||
|
||||
fn alloc_tid(&self) -> (Tid, MutexGuard<Option<Thread>>) {
|
||||
for (i, proc) in self.threads.iter().enumerate() {
|
||||
let thread = proc.lock();
|
||||
if thread.is_none() {
|
||||
return (i, thread);
|
||||
}
|
||||
}
|
||||
panic!("Thread number exceeded");
|
||||
}
|
||||
|
||||
/// Add a new thread
|
||||
/// Calls action with tid and thread context
|
||||
pub fn add(&self, mut context: Box<Context>) -> Tid {
|
||||
let (tid, mut thread) = self.alloc_tid();
|
||||
context.set_tid(tid);
|
||||
*thread = Some(Thread {
|
||||
status: Status::Ready,
|
||||
status_after_stop: Status::Ready,
|
||||
waiter: None,
|
||||
context: Some(context),
|
||||
});
|
||||
self.scheduler.push(tid);
|
||||
tid
|
||||
}
|
||||
|
||||
/// Make thread `tid` time slice -= 1.
|
||||
/// Return true if time slice == 0.
|
||||
/// Called by timer interrupt handler.
|
||||
pub(crate) fn tick(&self, cpu_id: usize, tid: Option<Tid>) -> bool {
|
||||
if cpu_id == 0 {
|
||||
let mut timer = self.timer.lock();
|
||||
timer.tick();
|
||||
while let Some(event) = timer.pop() {
|
||||
match event {
|
||||
Event::Wakeup(tid) => self.set_status(tid, Status::Ready),
|
||||
}
|
||||
}
|
||||
}
|
||||
match tid {
|
||||
Some(tid) => self.scheduler.tick(tid),
|
||||
None => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Set the priority of thread `tid`
|
||||
pub fn set_priority(&self, tid: Tid, priority: u8) {
|
||||
self.scheduler.set_priority(tid, priority);
|
||||
}
|
||||
|
||||
/// Called by Processor to get a thread to run.
|
||||
/// The manager first mark it `Running`,
|
||||
/// then take out and return its Context.
|
||||
pub(crate) fn run(&self, cpu_id: usize) -> Option<(Tid, Box<Context>)> {
|
||||
self.scheduler.pop(cpu_id).map(|tid| {
|
||||
let mut proc_lock = self.threads[tid].lock();
|
||||
let mut proc = proc_lock.as_mut().expect("thread not exist");
|
||||
proc.status = Status::Running(cpu_id);
|
||||
(tid, proc.context.take().expect("context not exist"))
|
||||
})
|
||||
}
|
||||
|
||||
/// Called by Processor to finish running a thread
|
||||
/// and give its context back.
|
||||
pub(crate) fn stop(&self, tid: Tid, context: Box<Context>) {
|
||||
let mut proc_lock = self.threads[tid].lock();
|
||||
let proc = proc_lock.as_mut().expect("thread not exist");
|
||||
proc.status = proc.status_after_stop.clone();
|
||||
proc.status_after_stop = Status::Ready;
|
||||
proc.context = Some(context);
|
||||
match proc.status {
|
||||
Status::Ready => self.scheduler.push(tid),
|
||||
Status::Exited(_) => self.exit_handler(proc),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
/// Called by `JoinHandle` to let thread `tid` wait for `target`.
|
||||
/// The `tid` is going to sleep, and will be woke up when `target` exit.
|
||||
/// (see `exit_handler()`)
|
||||
pub(crate) fn wait(&self, tid: Tid, target: Tid) {
|
||||
self.set_status(tid, Status::Sleeping);
|
||||
let mut target_lock = self.threads[target].lock();
|
||||
let target = target_lock.as_mut().expect("thread not exist");
|
||||
target.waiter = Some(tid);
|
||||
}
|
||||
|
||||
/// Switch the status of a thread.
|
||||
/// Insert/Remove it to/from scheduler if necessary.
|
||||
fn set_status(&self, tid: Tid, status: Status) {
|
||||
let mut proc_lock = self.threads[tid].lock();
|
||||
if let Some(mut proc) = proc_lock.as_mut() {
|
||||
trace!("thread {} {:?} -> {:?}", tid, proc.status, status);
|
||||
match (&proc.status, &status) {
|
||||
(Status::Ready, Status::Ready) => return,
|
||||
(Status::Ready, _) => panic!("can not remove a thread from ready queue"),
|
||||
(Status::Exited(_), _) => panic!("can not set status for a exited thread"),
|
||||
(Status::Sleeping, Status::Exited(_)) => self.timer.lock().stop(Event::Wakeup(tid)),
|
||||
(Status::Running(_), Status::Ready) => {} // thread will be added to scheduler in stop()
|
||||
(_, Status::Ready) => self.scheduler.push(tid),
|
||||
_ => {}
|
||||
}
|
||||
match proc.status {
|
||||
Status::Running(_) => proc.status_after_stop = status,
|
||||
_ => proc.status = status,
|
||||
}
|
||||
match proc.status {
|
||||
Status::Exited(_) => self.exit_handler(proc),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Try to remove an exited thread `tid`.
|
||||
/// Return its exit code if success.
|
||||
pub fn try_remove(&self, tid: Tid) -> Option<ExitCode> {
|
||||
let mut proc_lock = self.threads[tid].lock();
|
||||
let proc = proc_lock.as_ref().expect("thread not exist");
|
||||
match proc.status {
|
||||
Status::Exited(code) => {
|
||||
// release the tid
|
||||
*proc_lock = None;
|
||||
Some(code)
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Sleep `tid` for `time` ticks.
|
||||
/// `time` == 0 means sleep forever
|
||||
pub fn sleep(&self, tid: Tid, time: usize) {
|
||||
self.set_status(tid, Status::Sleeping);
|
||||
if time != 0 {
|
||||
self.timer.lock().start(time, Event::Wakeup(tid));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn wakeup(&self, tid: Tid) {
|
||||
let mut proc_lock = self.threads[tid].lock();
|
||||
if let Some(mut proc) = proc_lock.as_mut() {
|
||||
trace!("thread {} {:?} -> {:?}", tid, proc.status, Status::Ready);
|
||||
if let Status::Sleeping = proc.status {
|
||||
proc.status = Status::Ready;
|
||||
self.scheduler.push(tid);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn exit(&self, tid: Tid, code: ExitCode) {
|
||||
// NOTE: if `tid` is running, status change will be deferred.
|
||||
self.set_status(tid, Status::Exited(code));
|
||||
}
|
||||
/// Called when a thread exit
|
||||
fn exit_handler(&self, proc: &mut Thread) {
|
||||
// wake up waiter
|
||||
if let Some(waiter) = proc.waiter {
|
||||
self.wakeup(waiter);
|
||||
}
|
||||
// drop its context
|
||||
proc.context = None;
|
||||
}
|
||||
}
|
||||
|
||||
fn new_vec_default<T: Default>(size: usize) -> Vec<T> {
|
||||
let mut vec = Vec::new();
|
||||
vec.resize_with(size, Default::default);
|
||||
vec
|
||||
}
|
||||
@ -1,65 +0,0 @@
|
||||
//! A simple timer
|
||||
|
||||
use alloc::collections::VecDeque;
|
||||
|
||||
type Time = usize;
|
||||
|
||||
struct Event<T> {
|
||||
time: Time,
|
||||
data: T,
|
||||
}
|
||||
|
||||
/// A simple timer using ordered dequeue
|
||||
pub struct Timer<T> {
|
||||
tick: Time,
|
||||
timers: VecDeque<Event<T>>,
|
||||
}
|
||||
|
||||
impl<T: PartialEq> Timer<T> {
|
||||
/// Create a new timer.
|
||||
pub fn new() -> Self {
|
||||
Timer {
|
||||
tick: 0,
|
||||
timers: VecDeque::new(),
|
||||
}
|
||||
}
|
||||
/// Called on each tick.
|
||||
pub fn tick(&mut self) {
|
||||
self.tick += 1;
|
||||
}
|
||||
/// Pop an expired timer after `tick`.
|
||||
///
|
||||
/// This must be called after calling `tick`,
|
||||
/// and should be called multiple times until return `None`.
|
||||
pub fn pop(&mut self) -> Option<T> {
|
||||
match self.timers.front() {
|
||||
None => return None,
|
||||
Some(timer) if timer.time != self.tick => return None,
|
||||
_ => {}
|
||||
};
|
||||
self.timers.pop_front().map(|t| t.data)
|
||||
}
|
||||
/// Start a timer with given time interval
|
||||
pub fn start(&mut self, time_after: Time, data: T) {
|
||||
//debug!("{:?} {:?}", self.tick, time_after);
|
||||
let time = self.tick + time_after;
|
||||
let event = Event { time, data };
|
||||
let mut it = self.timers.iter();
|
||||
let mut i: usize = 0;
|
||||
loop {
|
||||
match it.next() {
|
||||
None => break,
|
||||
Some(e) if e.time >= time => break,
|
||||
_ => {}
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
self.timers.insert(i, event);
|
||||
}
|
||||
/// Stop a timer
|
||||
pub fn stop(&mut self, data: T) {
|
||||
if let Some(i) = self.timers.iter().position(|t| t.data == data) {
|
||||
self.timers.remove(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in new issue