OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "platform/scheduler/base/time_domain.h" | 5 #include "platform/scheduler/base/time_domain.h" |
6 | 6 |
7 #include <set> | 7 #include <set> |
8 | 8 |
9 #include "platform/scheduler/base/task_queue_impl.h" | 9 #include "platform/scheduler/base/task_queue_impl.h" |
10 #include "platform/scheduler/base/task_queue_manager_delegate.h" | 10 #include "platform/scheduler/base/task_queue_manager_delegate.h" |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
144 newly_updatable_[i] = newly_updatable_.back(); | 144 newly_updatable_[i] = newly_updatable_.back(); |
145 newly_updatable_.pop_back(); | 145 newly_updatable_.pop_back(); |
146 was_updatable = true; | 146 was_updatable = true; |
147 } else { | 147 } else { |
148 i++; | 148 i++; |
149 } | 149 } |
150 } | 150 } |
151 return was_updatable; | 151 return was_updatable; |
152 } | 152 } |
153 | 153 |
154 void TimeDomain::UpdateWorkQueues( | 154 void TimeDomain::UpdateWorkQueues(LazyNow lazy_now) { |
155 bool should_trigger_wakeup, | |
156 const internal::TaskQueueImpl::Task* previous_task, | |
157 LazyNow lazy_now) { | |
158 DCHECK(main_thread_checker_.CalledOnValidThread()); | 155 DCHECK(main_thread_checker_.CalledOnValidThread()); |
159 | 156 |
160 // Move any ready delayed tasks into the Incoming queues. | 157 // Move any ready delayed tasks into the Incoming queues. |
161 WakeupReadyDelayedQueues(&lazy_now, should_trigger_wakeup, previous_task); | 158 WakeupReadyDelayedQueues(&lazy_now); |
162 | 159 |
163 MoveNewlyUpdatableQueuesIntoUpdatableQueueSet(); | 160 MoveNewlyUpdatableQueuesIntoUpdatableQueueSet(); |
164 | 161 |
165 auto iter = updatable_queue_set_.begin(); | 162 auto iter = updatable_queue_set_.begin(); |
166 while (iter != updatable_queue_set_.end()) { | 163 while (iter != updatable_queue_set_.end()) { |
167 internal::TaskQueueImpl* queue = *iter++; | 164 internal::TaskQueueImpl* queue = *iter++; |
168 // NOTE Update work queue may erase itself from |updatable_queue_set_|. | 165 // NOTE Update work queue may erase itself from |updatable_queue_set_|. |
169 // This is fine, erasing an element won't invalidate any interator, as long | 166 // This is fine, erasing an element won't invalidate any interator, as long |
170 // as the iterator isn't the element being delated. | 167 // as the iterator isn't the element being delated. |
171 if (queue->immediate_work_queue()->Empty()) | 168 if (queue->immediate_work_queue()->Empty()) |
172 queue->UpdateImmediateWorkQueue(should_trigger_wakeup, previous_task); | 169 queue->UpdateImmediateWorkQueue(); |
173 } | 170 } |
174 } | 171 } |
175 | 172 |
176 void TimeDomain::MoveNewlyUpdatableQueuesIntoUpdatableQueueSet() { | 173 void TimeDomain::MoveNewlyUpdatableQueuesIntoUpdatableQueueSet() { |
177 DCHECK(main_thread_checker_.CalledOnValidThread()); | 174 DCHECK(main_thread_checker_.CalledOnValidThread()); |
178 base::AutoLock lock(newly_updatable_lock_); | 175 base::AutoLock lock(newly_updatable_lock_); |
179 while (!newly_updatable_.empty()) { | 176 while (!newly_updatable_.empty()) { |
180 updatable_queue_set_.insert(newly_updatable_.back()); | 177 updatable_queue_set_.insert(newly_updatable_.back()); |
181 newly_updatable_.pop_back(); | 178 newly_updatable_.pop_back(); |
182 } | 179 } |
183 } | 180 } |
184 | 181 |
185 void TimeDomain::WakeupReadyDelayedQueues( | 182 void TimeDomain::WakeupReadyDelayedQueues(LazyNow* lazy_now) { |
186 LazyNow* lazy_now, | |
187 bool should_trigger_wakeup, | |
188 const internal::TaskQueueImpl::Task* previous_task) { | |
189 DCHECK(main_thread_checker_.CalledOnValidThread()); | 183 DCHECK(main_thread_checker_.CalledOnValidThread()); |
190 // Wake up any queues with pending delayed work. Note std::multipmap stores | 184 // Wake up any queues with pending delayed work. Note std::multipmap stores |
191 // the elements sorted by key, so the begin() iterator points to the earliest | 185 // the elements sorted by key, so the begin() iterator points to the earliest |
192 // queue to wakeup. | 186 // queue to wakeup. |
193 std::set<internal::TaskQueueImpl*> dedup_set; | 187 std::set<internal::TaskQueueImpl*> dedup_set; |
194 while (!delayed_wakeup_multimap_.empty()) { | 188 while (!delayed_wakeup_multimap_.empty()) { |
195 DelayedWakeupMultimap::iterator next_wakeup = | 189 DelayedWakeupMultimap::iterator next_wakeup = |
196 delayed_wakeup_multimap_.begin(); | 190 delayed_wakeup_multimap_.begin(); |
197 if (next_wakeup->first > lazy_now->Now()) | 191 if (next_wakeup->first > lazy_now->Now()) |
198 break; | 192 break; |
199 // A queue could have any number of delayed tasks pending so it's worthwhile | 193 // A queue could have any number of delayed tasks pending so it's worthwhile |
200 // deduping calls to UpdateDelayedWorkQueue since it takes a lock. | 194 // deduping calls to UpdateDelayedWorkQueue since it takes a lock. |
201 // NOTE the order in which these are called matters since the order | 195 // NOTE the order in which these are called matters since the order |
202 // in which EnqueueTaskLocks is called is respected when choosing which | 196 // in which EnqueueTaskLocks is called is respected when choosing which |
203 // queue to execute a task from. | 197 // queue to execute a task from. |
204 if (dedup_set.insert(next_wakeup->second).second) { | 198 if (dedup_set.insert(next_wakeup->second).second) { |
205 next_wakeup->second->UpdateDelayedWorkQueue( | 199 next_wakeup->second->UpdateDelayedWorkQueue(lazy_now); |
206 lazy_now, should_trigger_wakeup, previous_task); | |
207 } | 200 } |
208 delayed_wakeup_multimap_.erase(next_wakeup); | 201 delayed_wakeup_multimap_.erase(next_wakeup); |
209 } | 202 } |
210 } | 203 } |
211 | 204 |
212 void TimeDomain::ClearExpiredWakeups() { | 205 void TimeDomain::ClearExpiredWakeups() { |
213 DCHECK(main_thread_checker_.CalledOnValidThread()); | 206 DCHECK(main_thread_checker_.CalledOnValidThread()); |
214 LazyNow lazy_now(CreateLazyNow()); | 207 LazyNow lazy_now(CreateLazyNow()); |
215 while (!delayed_wakeup_multimap_.empty()) { | 208 while (!delayed_wakeup_multimap_.empty()) { |
216 DelayedWakeupMultimap::iterator next_wakeup = | 209 DelayedWakeupMultimap::iterator next_wakeup = |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
250 if (!delayed_wakeup_multimap_.empty()) { | 243 if (!delayed_wakeup_multimap_.empty()) { |
251 base::TimeDelta delay = delayed_wakeup_multimap_.begin()->first - Now(); | 244 base::TimeDelta delay = delayed_wakeup_multimap_.begin()->first - Now(); |
252 state->SetDouble("next_delay_ms", delay.InMillisecondsF()); | 245 state->SetDouble("next_delay_ms", delay.InMillisecondsF()); |
253 } | 246 } |
254 AsValueIntoInternal(state); | 247 AsValueIntoInternal(state); |
255 state->EndDictionary(); | 248 state->EndDictionary(); |
256 } | 249 } |
257 | 250 |
258 } // namespace scheduler | 251 } // namespace scheduler |
259 } // namespace blink | 252 } // namespace blink |
OLD | NEW |