hustos
/
tornado-os
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Change definition of set task state function

This commit is contained in:
luojia65 2021-04-25 15:07:55 +08:00
parent a2e4ee7160
commit b6b990f350
9 changed files with 78 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
shared-scheduler/src/algorithm/mod.rs
View File

@ -12,12 +12,11 @@ pub trait Scheduler<T: Clone + PartialEq> {
fn add_task(&mut self, task: T) -> Option<T>;
/// 获取下一个任务的引用，但不弹出任务
fn peek_next_task(&self) -> Option<&T>;
fn peek_next_task_mut(&mut self) -> Option<&mut T>;
/// 弹出下一个时间段应当执行的任务
fn next_task(&mut self) -> Option<T>;
/// 获取正在运行的任务，中断发生时，将保存这个任务的上下文
fn current_task(&self) -> Option<T>;
/// 查找一个任务
fn find_first_task_mut(&mut self, p: impl Fn(&T) -> bool) -> Option<&mut T>;
/// 移除一个任务
fn remove_task(&mut self, task: &T);
/// 设置任务的优先级

73
shared-scheduler/src/algorithm/ring_fifo.rs
View File

@ -2,7 +2,7 @@
//!
use super::Scheduler;
use core::{marker::PhantomData, mem::MaybeUninit};
use core::mem::MaybeUninit;
use core::ptr;
/// 先进先出轮转任务调度器
@ -43,12 +43,12 @@ impl<T: Clone + PartialEq, const N: usize> Scheduler<T> for RingFifoScheduler<T,
// 拿出头部的引用
self.ring.front()
}
fn peek_next_task_mut(&mut self) -> Option<&mut T> {
self.ring.front_mut()
}
fn current_task(&self) -> Option<T> {
self.current.clone()
}
fn find_first_task_mut(&mut self, p: impl Fn(&T) -> bool) -> Option<&mut T> {
self.ring.iter_mut().find(|t| p(t))
}
fn remove_task(&mut self, task: &T) {
// 移除相应的线程并且确认恰移除一个线程
drop(task);
@ -110,37 +110,44 @@ impl<T, const N: usize> RingQueue<T, N> {
Some(unsafe { &*self.elem[self.front].as_ptr() })
}
}
pub fn iter_mut(&mut self) -> IterMut<'_, T, N> {
IterMut {
ptr: &mut self.elem as *mut [MaybeUninit<T>; N] as *mut [T; N],
front: self.front,
tail: self.tail,
_marker: PhantomData
}
}
}
pub struct IterMut<'a, T: 'a, const N: usize> {
ptr: *mut [T; N],
front: usize,
tail: usize,
_marker: PhantomData<&'a mut T>
}
// TODO: 这里有不确定 Unsafe 代码，需检查正确性
impl<'a, T, const N: usize> Iterator for IterMut<'a, T, N> {
type Item = &'a mut T;
fn next(&mut self) -> Option<Self::Item> {
if self.tail == self.front {
// is empty
pub fn front_mut(&mut self) -> Option<&mut T> {
if self.is_empty() {
None
} else {
let value = unsafe { &mut (*(self.ptr))[self.front] };
self.front = self.front.wrapping_add(1);
if self.front > N || self.front == 0 {
self.front = self.front.wrapping_sub(N);
}
Some(value)
Some(unsafe { &mut *self.elem[self.front].as_mut_ptr() })
}
}
// pub fn iter_mut(&mut self) -> IterMut<'_, T, N> {
// IterMut {
// ptr: &mut self.elem as *mut [MaybeUninit<T>; N] as *mut [T; N],
// front: self.front,
// tail: self.tail,
// _marker: PhantomData
// }
// }
}
// pub struct IterMut<'a, T: 'a, const N: usize> {
// ptr: *mut [T; N],
// front: usize,
// tail: usize,
// _marker: PhantomData<&'a mut T>
// }
// // TODO: 这里有不确定 Unsafe 代码，需检查正确性
// impl<'a, T, const N: usize> Iterator for IterMut<'a, T, N> {
// type Item = &'a mut T;
// fn next(&mut self) -> Option<Self::Item> {
// if self.tail == self.front {
// // is empty
// None
// } else {
// let value = unsafe { &mut (*(self.ptr))[self.front] };
// self.front = self.front.wrapping_add(1);
// if self.front > N || self.front == 0 {
// self.front = self.front.wrapping_sub(N);
// }
// Some(value)
// }
// }
// }

4
shared-scheduler/src/main.rs
View File

@ -61,8 +61,8 @@ pub static SHARED_RAW_TABLE: (
&'static SharedScheduler, // 共享调度器的地址
unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, TaskRepr) -> bool, // 添加任务
unsafe extern "C" fn(NonNull<()>, extern "C" fn(AddressSpaceId) -> bool) -> TaskResult, // 弹出任务
unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, TaskRepr) -> bool, // 删除任务
unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, TaskRepr, TaskState), // 改变任务的状态
unsafe extern "C" fn(NonNull<()>, TaskRepr) -> bool, // 删除任务
unsafe extern "C" fn(NonNull<()>, TaskRepr, TaskState), // 改变任务的状态
) = (
unsafe { &payload_compiled_start },
init_payload_environment,

22
shared-scheduler/src/task.rs
View File

@ -116,8 +116,6 @@ pub unsafe extern "C" fn shared_peek_task(
/// 删除一个共享调度器中的任务
pub unsafe extern "C" fn shared_delete_task(
shared_scheduler: NonNull<()>,
_hart_id: usize,
_address_space_id: AddressSpaceId,
task_repr: TaskRepr,
) -> bool {
let mut s: NonNull<SharedScheduler> = shared_scheduler.cast();
@ -136,23 +134,17 @@ pub unsafe extern "C" fn shared_delete_task(
/// 设置任务的状态
pub unsafe extern "C" fn shared_set_task_state(
shared_scheduler: NonNull<()>,
hart_id: usize,
address_space_id: AddressSpaceId,
task_repr: TaskRepr,
new_state: TaskState,
) {
let mut s: NonNull<SharedScheduler> = shared_scheduler.cast();
let mut scheduler = s.as_mut().lock();
if let Some(task) = scheduler.find_first_task_mut(|t| task_eq(t, hart_id, address_space_id, task_repr)) {
task.state = new_state;
let next_handle = scheduler.peek_next_task_mut();
if let Some(handle) = next_handle {
if handle.task_repr == task_repr {
handle.state = new_state;
} else {
panic!("change a previous task is not currently supported")
}
}
}
fn task_eq(
a: &TaskMeta,
hart_id: usize,
address_space_id: AddressSpaceId,
task_repr: TaskRepr,
) -> bool {
a.hart_id == hart_id && a.address_space_id == address_space_id && a.task_repr == task_repr
}

10
tornado-kernel/src/main.rs
View File

@ -104,9 +104,9 @@ pub extern "C" fn rust_main(hart_id: usize) -> ! {
let hart_id = crate::hart::KernelHartInfo::hart_id();
let address_space_id = process.address_space_id();
let stack_handle = process.alloc_stack().expect("alloc initial stack");
let task_1 = task::new_kernel(task_1(), process.clone(), shared_payload.shared_scheduler, hart_id, address_space_id, shared_payload.shared_set_task_state);
let task_2 = task::new_kernel(task_2(), process.clone(), shared_payload.shared_scheduler, hart_id, address_space_id, shared_payload.shared_set_task_state);
let task_3 = task::new_kernel(FibonacciFuture::new(6), process.clone(), shared_payload.shared_scheduler, hart_id, address_space_id, shared_payload.shared_set_task_state);
let task_1 = task::new_kernel(task_1(), process.clone(), shared_payload.shared_scheduler, shared_payload.shared_set_task_state);
let task_2 = task::new_kernel(task_2(), process.clone(), shared_payload.shared_scheduler, shared_payload.shared_set_task_state);
let task_3 = task::new_kernel(FibonacciFuture::new(6), process.clone(), shared_payload.shared_scheduler, shared_payload.shared_set_task_state);
println!("task_1: {:?}", task_1);
println!("task_2: {:?}", task_2);
println!("task_3: {:?}", task_3);
@ -118,8 +118,8 @@ pub extern "C" fn rust_main(hart_id: usize) -> ! {
task::run_until_idle(
|| unsafe { shared_payload.peek_task(task::kernel_should_switch) },
|task_repr| unsafe { shared_payload.delete_task(hart_id, address_space_id, task_repr) },
|task_repr, new_state| unsafe { shared_payload.set_task_state(hart_id, address_space_id, task_repr, new_state)}
|task_repr| unsafe { shared_payload.delete_task(task_repr) },
|task_repr, new_state| unsafe { shared_payload.set_task_state(task_repr, new_state)}
);
// 进入用户态

14
tornado-kernel/src/task/mod.rs
View File

@ -14,8 +14,6 @@ pub use shared::{
kernel_should_switch
};
use crate::memory::AddressSpaceId;
/// 共享调度器返回的结果
#[derive(Debug)]
#[repr(C)]
@ -38,17 +36,15 @@ pub fn new_kernel(
future: impl Future<Output = ()> + 'static + Send + Sync,
process: Arc<Process>,
shared_scheduler: NonNull<()>,
hart_id: usize,
address_space_id: AddressSpaceId,
set_task_state: unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize, TaskState),
set_task_state: unsafe extern "C" fn(NonNull<()>, usize, TaskState),
) -> Arc<KernelTaskRepr> {
Arc::new(KernelTaskRepr(KernelTask::new(future, process), shared_scheduler.as_ptr() as usize, hart_id, address_space_id, set_task_state))
Arc::new(KernelTaskRepr(KernelTask::new(future, process), shared_scheduler.as_ptr() as usize, set_task_state))
}
#[derive(Debug)]
pub struct KernelTaskRepr (
KernelTask, usize, usize, AddressSpaceId,
unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize, TaskState)
KernelTask, usize,
unsafe extern "C" fn(NonNull<()>, usize, TaskState)
);
impl KernelTaskRepr {
@ -61,7 +57,7 @@ impl KernelTaskRepr {
pub unsafe fn do_wake(self: &Arc<Self>) {
let shared_scheduler = NonNull::new(self.1 as *mut ()).unwrap();
let task_repr = Arc::as_ptr(self) as usize;
(self.4)(shared_scheduler, self.2, self.3, task_repr, TaskState::Ready)
(self.2)(shared_scheduler, task_repr, TaskState::Ready)
}
#[inline] pub fn task(&self) -> &KernelTask {
&self.0

16
tornado-kernel/src/task/shared.rs
View File

@ -48,8 +48,8 @@ pub struct SharedPayload {
pub(crate) shared_scheduler: NonNull<()>,
shared_add_task: unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize) -> bool,
shared_peek_task: unsafe extern "C" fn(NonNull<()>, extern "C" fn(AddressSpaceId) -> bool) -> TaskResult,
shared_delete_task: unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize) -> bool,
pub(crate) shared_set_task_state: unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize, TaskState),
shared_delete_task: unsafe extern "C" fn(NonNull<()>, usize) -> bool,
pub(crate) shared_set_task_state: unsafe extern "C" fn(NonNull<()>, usize, TaskState),
}
unsafe impl Send for SharedPayload {}
@ -63,8 +63,8 @@ type SharedPayloadRaw = (
NonNull<()>,
unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize) -> bool, // 添加任务
unsafe extern "C" fn(NonNull<()>, extern "C" fn(AddressSpaceId) -> bool) -> TaskResult, // 弹出任务
unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize) -> bool, // 删除任务
unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize, TaskState), // 改变任务的状态
unsafe extern "C" fn(NonNull<()>, usize) -> bool, // 删除任务
unsafe extern "C" fn(NonNull<()>, usize, TaskState), // 改变任务的状态
);
impl SharedPayload {
@ -113,15 +113,15 @@ impl SharedPayload {
}
/// 从共享调度器中删除任务
pub unsafe fn delete_task(&self, hart_id: usize, address_space_id: AddressSpaceId, task_repr: usize) -> bool {
pub unsafe fn delete_task(&self, task_repr: usize) -> bool {
let f = self.shared_delete_task;
f(self.shared_scheduler, hart_id, address_space_id, task_repr)
f(self.shared_scheduler, task_repr)
}
/// 设置一个任务的状态
pub unsafe fn set_task_state(&self, hart_id: usize, address_space_id: AddressSpaceId, task_repr: usize, new_state: TaskState) {
pub unsafe fn set_task_state(&self, task_repr: usize, new_state: TaskState) {
let f = self.shared_set_task_state;
f(self.shared_scheduler, hart_id, address_space_id, task_repr, new_state)
f(self.shared_scheduler, task_repr, new_state)
}
}

4
tornado-user/src/lib.rs
View File

@ -90,8 +90,8 @@ pub fn execute_async_main(main: impl Future<Output = i32> + Send + Sync + 'stati
}
shared::run_until_ready(
|| unsafe { shared_payload.peek_task(shared::user_should_switch) },
|task_repr| unsafe { shared_payload.delete_task(hart_id, address_space_id, task_repr) },
|task_repr, new_state| unsafe { shared_payload.set_task_state(hart_id, address_space_id, task_repr, new_state)}
|task_repr| unsafe { shared_payload.delete_task(task_repr) },
|task_repr, new_state| unsafe { shared_payload.set_task_state(task_repr, new_state)}
);
unsafe { EXIT_CODE }
}

16
tornado-user/src/shared.rs
View File

@ -71,8 +71,8 @@ pub struct SharedPayload {
shared_scheduler: NonNull<()>,
shared_add_task: unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize) -> bool,
shared_peek_task: unsafe extern "C" fn(NonNull<()>, extern "C" fn(AddressSpaceId) -> bool) -> TaskResult,
shared_delete_task: unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize) -> bool,
shared_set_task_state: unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize, TaskState),
shared_delete_task: unsafe extern "C" fn(NonNull<()>, usize) -> bool,
shared_set_task_state: unsafe extern "C" fn(NonNull<()>, usize, TaskState),
}
type SharedPayloadAsUsize = [usize; 7]; // 编译时基地址，（已清空）初始化函数，共享调度器地址，添加函数，弹出函数
@ -82,8 +82,8 @@ type SharedPayloadRaw = (
NonNull<()>,
unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize) -> bool, // 添加任务
unsafe extern "C" fn(NonNull<()>, extern "C" fn(AddressSpaceId) -> bool) -> TaskResult, // 弹出任务
unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize) -> bool, // 删除任务
unsafe extern "C" fn(NonNull<()>, usize, AddressSpaceId, usize, TaskState), // 改变任务的状态
unsafe extern "C" fn(NonNull<()>, usize) -> bool, // 删除任务
unsafe extern "C" fn(NonNull<()>, usize, TaskState), // 改变任务的状态
);
impl SharedPayload {
@ -115,13 +115,13 @@ impl SharedPayload {
let f = self.shared_peek_task;
f(self.shared_scheduler, should_yield)
}
pub unsafe fn delete_task(&self, hart_id: usize, address_space_id: AddressSpaceId, task_repr: usize) -> bool {
pub unsafe fn delete_task(&self, task_repr: usize) -> bool {
let f = self.shared_delete_task;
f(self.shared_scheduler, hart_id, address_space_id, task_repr)
f(self.shared_scheduler, task_repr)
}
pub unsafe fn set_task_state(&self, hart_id: usize, address_space_id: AddressSpaceId, task_repr: usize, new_state: TaskState) {
pub unsafe fn set_task_state(&self, task_repr: usize, new_state: TaskState) {
let f = self.shared_set_task_state;
f(self.shared_scheduler, hart_id, address_space_id, task_repr, new_state)
f(self.shared_scheduler, task_repr, new_state)
}
}