use super::{Task, TaskId};
use alloc::{
collections::{BTreeMap, VecDeque},
sync::Arc,
};
use core::task::Waker;
use spin::Mutex;
pub struct Executor {
tasks: BTreeMap<TaskId, Task>,
task_queue: Arc<Mutex<VecDeque<TaskId>>>,
waker_cache: BTreeMap<TaskId, Waker>,
}
impl Executor {
pub fn new() -> Self {
Executor {
tasks: BTreeMap::new(),
task_queue: Arc::new(Mutex::new(VecDeque::new())),
waker_cache: BTreeMap::new(),
}
}
}
impl Default for Executor {
fn default() -> Self {
Self::new()
}
}
impl Executor {
pub fn spawn(&mut self, task: Task) {
let task_id = task.id;
if self.tasks.insert(task.id, task).is_some() {
panic!("task with same ID already in tasks");
}
self.task_queue.lock().push_back(task_id);
}
}
use core::task::{Context, Poll};
impl Executor {
fn run_ready_tasks(&mut self) {
let Self {
tasks,
task_queue,
waker_cache,
} = self;
while let Some(task_id) = task_queue.lock().pop_front() {
let task = match tasks.get_mut(&task_id) {
Some(task) => task,
None => continue,
};
let waker = waker_cache
.entry(task_id)
.or_insert_with(|| TaskWaker::waker(task_id, task_queue.clone()));
let mut context = Context::from_waker(waker);
match task.poll(&mut context) {
Poll::Ready(()) => {
tasks.remove(&task_id);
waker_cache.remove(&task_id);
}
Poll::Pending => {}
}
}
}
}
struct TaskWaker {
task_id: TaskId,
task_queue: Arc<Mutex<VecDeque<TaskId>>>,
}
impl TaskWaker {
fn wake_task(&self) {
self.task_queue.lock().push_back(self.task_id);
}
}
use alloc::task::Wake;
impl Wake for TaskWaker {
fn wake(self: Arc<Self>) {
self.wake_task();
}
fn wake_by_ref(self: &Arc<Self>) {
self.wake_task();
}
}
impl TaskWaker {
fn waker(task_id: TaskId, task_queue: Arc<Mutex<VecDeque<TaskId>>>) -> Waker {
Waker::from(Arc::new(TaskWaker {
task_id,
task_queue,
}))
}
}
impl Executor {
pub fn run(&mut self) -> ! {
loop {
self.run_ready_tasks();
self.sleep_if_idle();
}
}
fn sleep_if_idle(&self) {
use crate::interrupts;
interrupts::disable_interrupts();
if self.task_queue.lock().is_empty() {
interrupts::enable_interrupts();
riscv::asm::wfi();
} else {
interrupts::enable_interrupts();
}
}
}