trident3-base 3.0.1

Foundation runtime library for Trident 3
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

pub struct Executor {
   pub tasks: BTreeMap<TaskId, Task>,
   pub task_queue: Arc<ArrayQueue<TaskId>>,
   pub waker_cache: BTreeMap<TaskId, Waker>,
}

impl Executor {
   pub fn new() -> Self {
      return Executor{
         tasks: BTreeMap::new(),
         task_queue: Arc::new(ArrayQueue::new(100)),
         waker_cache: BTreeMap::new(),
      };
   }

   pub fn spawn(&mut self, task: Task) {
      let task_id = task.id;
      if self.tasks.insert(task.id, task).is_some() {
         log::error!("A task with the same identifier already exists");
      }

      self.task_queue.push(task_id).expect("queue full");
   }

   pub fn run(&mut self) -> ! {
      loop{
         self.run_ready_tasks();
         self.sleep_if_idle();
      }
   }

   pub fn run_ready_tasks(&mut self) {
      // Destructure self to avoid borrow checker errors.
      let Self {
         tasks,
         task_queue,
         waker_cache,
      } = self;

      while let Some(task_id) = task_queue.pop() {
         let task = match tasks.get_mut(&task_id) {
            Some(task) => task,
            None => continue,
         };

         let waker = waker_cache.entry(task_id)
            .or_insert_with(|| TaskWaker::new(task_id, task_queue.clone()));

         let mut context = Context::from_waker(waker);
      }
   }

   pub fn sleep_if_idle(&self) {
      use x86_64::instructions::interrupts::{self, enable_and_hlt};

      interrupts::disable();
      if self.task_queue.is_empty() {
         enable_and_hlt();
      } else {
         interrupts::enable();
      }
   }
}

pub struct TaskWaker {
   pub task_id: TaskId,
   pub task_queue: Arc<ArrayQueue<TaskId>>,
}

impl TaskWaker {
   pub fn new(task_id: TaskId, task_queue: Arc<ArrayQueue<TaskId>>) -> Waker {
      Waker::from(Arc::new(TaskWaker {
         task_id,
         task_queue,
      }))
   }

   pub fn wake_task(&self) {
      self.task_queue.push(self.task_id).expect("task queue full");
   }
}

impl Wake for TaskWaker {
   fn wake(self: Arc<Self>) {
      self.wake_task();
   }

   fn wake_by_ref(self: &Arc<Self>) {
      self.wake_task();
   }
}

// IMPORTS //

use {
   super::{Task, TaskId},
   std_alloc::{collections::BTreeMap, sync::Arc, task::Wake},
   core::task::{Context, Poll, Waker},
   crossbeam_queue::ArrayQueue,
};