Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(489)

Side by Side Diff: third_party/WebKit/Source/platform/scheduler/base/time_domain.cc

Issue 2276353002: Remove after wakeup logic and replace PumpTask with Fences (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Slight simplification Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698