Skip to main content

os/task/
executor.rs

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}