1use super::{Task, TaskId};
2use alloc::{
3 collections::{BTreeMap, VecDeque},
4 sync::Arc,
5};
6use core::task::Waker;
7use spin::Mutex;
8
9pub struct Executor {
10 tasks: BTreeMap<TaskId, Task>,
11 task_queue: Arc<Mutex<VecDeque<TaskId>>>,
12 waker_cache: BTreeMap<TaskId, Waker>,
13}
14
15impl Executor {
16 pub fn new() -> Self {
17 Executor {
18 tasks: BTreeMap::new(),
19 task_queue: Arc::new(Mutex::new(VecDeque::new())),
20 waker_cache: BTreeMap::new(),
21 }
22 }
23}
24
25impl Default for Executor {
26 fn default() -> Self {
27 Self::new()
28 }
29}
30
31impl Executor {
32 pub fn spawn(&mut self, task: Task) {
33 let task_id = task.id;
34 if self.tasks.insert(task.id, task).is_some() {
35 panic!("task with same ID already in tasks");
36 }
37 self.task_queue.lock().push_back(task_id);
38 }
39}
40
41use core::task::{Context, Poll};
42
43impl Executor {
44 fn run_ready_tasks(&mut self) {
45 let Self {
46 tasks,
47 task_queue,
48 waker_cache,
49 } = self;
50
51 while let Some(task_id) = task_queue.lock().pop_front() {
52 let task = match tasks.get_mut(&task_id) {
53 Some(task) => task,
54 None => continue,
55 };
56 let waker = waker_cache
57 .entry(task_id)
58 .or_insert_with(|| TaskWaker::waker(task_id, task_queue.clone()));
59 let mut context = Context::from_waker(waker);
60 match task.poll(&mut context) {
61 Poll::Ready(()) => {
62 tasks.remove(&task_id);
63 waker_cache.remove(&task_id);
64 }
65 Poll::Pending => {}
66 }
67 }
68 }
69}
70
71struct TaskWaker {
72 task_id: TaskId,
73 task_queue: Arc<Mutex<VecDeque<TaskId>>>,
74}
75impl TaskWaker {
76 fn wake_task(&self) {
77 self.task_queue.lock().push_back(self.task_id);
78 }
79}
80
81use alloc::task::Wake;
82
83impl Wake for TaskWaker {
84 fn wake(self: Arc<Self>) {
85 self.wake_task();
86 }
87
88 fn wake_by_ref(self: &Arc<Self>) {
89 self.wake_task();
90 }
91}
92impl TaskWaker {
93 fn waker(task_id: TaskId, task_queue: Arc<Mutex<VecDeque<TaskId>>>) -> Waker {
94 Waker::from(Arc::new(TaskWaker {
95 task_id,
96 task_queue,
97 }))
98 }
99}
100impl Executor {
101 pub fn run(&mut self) -> ! {
102 loop {
103 self.run_ready_tasks();
104 self.sleep_if_idle();
105 }
106 }
107 fn sleep_if_idle(&self) {
108 use crate::interrupts;
109
110 interrupts::disable_interrupts();
111 if self.task_queue.lock().is_empty() {
112 interrupts::enable_interrupts();
113 riscv::asm::wfi();
114 } else {
115 interrupts::enable_interrupts();
116 }
117 }
118}