script/tasks/
task_queue.rs1use std::collections::VecDeque;
8use std::default::Default;
9
10use crossbeam_channel::{self, Receiver};
11use js::context::JSContext;
12use rustc_hash::{FxHashMap, FxHashSet};
13use script_bindings::cell::DomRefCell;
14use script_bindings::root::DomRoot;
15use servo_base::id::PipelineId;
16
17use crate::dom::GlobalScope;
18use crate::dom::worker::TrustedWorkerAddress;
19use crate::realms::enter_auto_realm;
20use crate::runtime::script_runtime::ScriptThreadEventCategory;
21use crate::tasks::task::TaskBox;
22use crate::tasks::task_source::TaskSourceName;
23
24#[derive(MallocSizeOf)]
25pub(crate) struct QueuedTask {
26 pub(crate) worker: Option<TrustedWorkerAddress>,
27 pub(crate) event_category: ScriptThreadEventCategory,
28 #[ignore_malloc_size_of = "TaskBox is difficult"]
29 pub(crate) task: Box<dyn TaskBox>,
30 pub(crate) pipeline_id: Option<PipelineId>,
31 pub(crate) task_source: TaskSourceName,
32}
33
34pub(crate) trait QueuedTaskConversion {
36 fn pipeline_id(&self) -> Option<PipelineId>;
37 fn into_queued_task(self) -> Option<QueuedTask>;
38 fn from_queued_task(queued_task: QueuedTask) -> Self;
39 fn inactive_msg() -> Self;
40 fn wake_up_msg() -> Self;
41 fn is_wake_up(&self) -> bool;
42}
43
44#[derive(MallocSizeOf)]
45pub(crate) struct TaskQueue<T> {
46 port: Receiver<T>,
48 msg_queue: DomRefCell<VecDeque<T>>,
50 inactive: DomRefCell<FxHashMap<PipelineId, VecDeque<QueuedTask>>>,
52 closed_pipelines: DomRefCell<FxHashSet<PipelineId>>,
54}
55
56impl<T: QueuedTaskConversion> TaskQueue<T> {
57 pub(crate) fn new(port: Receiver<T>) -> TaskQueue<T> {
58 TaskQueue {
59 port,
60 msg_queue: DomRefCell::new(VecDeque::new()),
61 inactive: Default::default(),
62 closed_pipelines: Default::default(),
63 }
64 }
65
66 pub(crate) fn remove_tasks_for_exiting_pipeline(&self, pipeline_id: &PipelineId) {
70 self.inactive.borrow_mut().remove(pipeline_id);
71 self.closed_pipelines.borrow_mut().insert(*pipeline_id);
72 }
73
74 pub(crate) fn is_pipeline_closed(&self, pipeline_id: &PipelineId) -> bool {
75 self.closed_pipelines.borrow().contains(pipeline_id)
76 }
77
78 fn release_tasks_for_fully_active_documents(
81 &self,
82 fully_active: &FxHashSet<PipelineId>,
83 ) -> Vec<T> {
84 self.inactive
85 .borrow_mut()
86 .iter_mut()
87 .filter(|(pipeline_id, _)| fully_active.contains(pipeline_id))
88 .flat_map(|(_, inactive_queue)| {
89 inactive_queue
90 .drain(0..)
91 .map(|queued_task| T::from_queued_task(queued_task))
92 })
93 .collect()
94 }
95
96 fn store_task_for_inactive_pipeline(&self, msg: T, pipeline_id: &PipelineId) {
99 if !self.is_pipeline_closed(pipeline_id) {
100 let mut inactive = self.inactive.borrow_mut();
101 let inactive_queue = inactive.entry(*pipeline_id).or_default();
102 inactive_queue.push_back(
103 msg.into_queued_task()
104 .expect("Incoming messages should always be convertible into queued tasks"),
105 );
106 }
107
108 let mut msg_queue = self.msg_queue.borrow_mut();
109 if msg_queue.is_empty() {
110 msg_queue.push_back(T::inactive_msg());
115 }
116 }
117
118 pub(crate) fn take_tasks(&self, first_message: T, fully_active: &FxHashSet<PipelineId>) {
120 let mut incoming = self.release_tasks_for_fully_active_documents(fully_active);
122
123 if !first_message.is_wake_up() {
125 incoming.push(first_message);
126 }
127
128 while let Ok(message) = self.port.try_recv() {
130 if !message.is_wake_up() {
131 incoming.push(message);
132 }
133 }
134
135 for msg in incoming {
136 if let Some(pipeline_id) = msg.pipeline_id() &&
137 !fully_active.contains(&pipeline_id)
138 {
139 self.store_task_for_inactive_pipeline(msg, &pipeline_id);
140 continue;
141 }
142 self.msg_queue.borrow_mut().push_back(msg);
143 }
144 }
145
146 pub(crate) fn select(&self) -> &crossbeam_channel::Receiver<T> {
149 &self.port
152 }
153
154 pub(crate) fn recv(&self) -> Result<T, ()> {
156 self.msg_queue.borrow_mut().pop_front().ok_or(())
157 }
158
159 pub(crate) fn take_tasks_and_recv(
161 &self,
162 fully_active: &FxHashSet<PipelineId>,
163 ) -> Result<T, ()> {
164 self.take_tasks(T::wake_up_msg(), fully_active);
165 self.recv()
166 }
167
168 pub(crate) fn run_task(
169 &self,
170 cx: &mut JSContext,
171 pipeline_id: Option<PipelineId>,
172 global: Option<DomRoot<GlobalScope>>,
173 task: Box<dyn TaskBox>,
174 ) {
175 if pipeline_id.is_some() && global.is_none() {
179 return;
180 }
181
182 let Some(global) = global else {
183 task.run_box(cx);
184 return;
185 };
186
187 let mut realm = enter_auto_realm(cx, &*global);
188 let cx = &mut realm.current_realm();
189 task.run_box(cx)
190 }
191}