OLD | NEW |
---|---|
(Empty) | |
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 | |
3 // found in the LICENSE file. | |
4 | |
5 #include "components/scheduler/base/time_domain.h" | |
6 | |
7 #include <set> | |
8 | |
9 #include "components/scheduler/base/task_queue_impl.h" | |
10 #include "components/scheduler/base/task_queue_manager_delegate.h" | |
11 #include "components/scheduler/scheduler_export.h" | |
12 | |
13 namespace scheduler { | |
14 | |
15 TimeDomain::TimeDomain(TaskQueueManagerDelegate* task_queue_manager_delegate) | |
16 : task_queue_manager_delegate_(task_queue_manager_delegate), | |
17 weak_factory_(this) { | |
18 DCHECK(task_queue_manager_delegate_); | |
19 } | |
20 | |
21 TimeDomain::~TimeDomain() {} | |
22 | |
23 void TimeDomain::UnregisterQueue(internal::TaskQueueImpl* queue) { | |
24 // We need to remove |task_queue| from delayed_wakeup_multimap_ which is a | |
25 // little awkward since it's keyed by time. O(n) running time. | |
26 for (DelayedWakeupMultimap::iterator iter = delayed_wakeup_multimap_.begin(); | |
27 iter != delayed_wakeup_multimap_.end();) { | |
28 if (iter->second == queue) { | |
29 DelayedWakeupMultimap::iterator temp = iter; | |
30 iter++; | |
31 // O(1) amortized. | |
32 delayed_wakeup_multimap_.erase(temp); | |
33 } else { | |
34 iter++; | |
35 } | |
36 } | |
37 | |
38 // |newly_updatable_| might contain |task_queue|, we use | |
39 // MoveNewlyUpdatableQueuesIntoUpdatableQueueSet to flush it out. | |
40 MoveNewlyUpdatableQueuesIntoUpdatableQueueSet(); | |
41 updatable_queue_set_.erase(queue); | |
42 } | |
43 | |
44 void TimeDomain::ScheduleDelayedWork(internal::TaskQueueImpl* queue, | |
45 base::TimeTicks delayed_run_time, | |
46 LazyNow* lazy_now) { | |
47 if (!task_queue_manager_delegate_->BelongsToCurrentThread()) { | |
48 // NOTE posting a delayed task from a different thread is not expected to be | |
49 // common. This pathway is less optimal than perhaps it could be because | |
50 // it causes two main thread tasks to be run. Should this assumption prove | |
51 // to be false in future, we may need to revisit this. | |
52 task_queue_manager_delegate_->PostTask( | |
53 FROM_HERE, base::Bind(&TimeDomain::ScheduleDelayedWorkTask, | |
54 weak_factory_.GetWeakPtr(), | |
55 scoped_refptr<internal::TaskQueueImpl>(queue), | |
56 delayed_run_time)); | |
57 return; | |
58 } | |
59 | |
60 // Make sure there's one (and only one) task posted to | |
Sami
2015/11/18 18:36:24
nit: this comment is making assumptions about the
alex clarke (OOO till 29th)
2015/11/19 12:20:12
Done.
| |
61 // |task_queue_manager_delegate_| to call |DelayedDoWork| at | |
62 // |delayed_run_time|. | |
63 if (delayed_wakeup_multimap_.find(delayed_run_time) == | |
64 delayed_wakeup_multimap_.end()) { | |
65 base::TimeDelta delay = | |
66 std::max(base::TimeDelta(), delayed_run_time - lazy_now->Now()); | |
67 ScheduleDoWork(delay); | |
68 } | |
69 delayed_wakeup_multimap_.insert(std::make_pair(delayed_run_time, queue)); | |
70 } | |
71 | |
72 void TimeDomain::ScheduleDelayedWorkTask( | |
73 scoped_refptr<internal::TaskQueueImpl> queue, | |
74 base::TimeTicks delayed_run_time) { | |
75 LazyNow lazy_now(GetLazyNow()); | |
76 ScheduleDelayedWork(queue.get(), delayed_run_time, &lazy_now); | |
77 } | |
78 | |
79 void TimeDomain::RegisterAsUpdatableTaskQueue(internal::TaskQueueImpl* queue) { | |
80 base::AutoLock lock(newly_updatable_lock_); | |
81 newly_updatable_.push_back(queue); | |
82 } | |
83 | |
84 void TimeDomain::UnregisterAsUpdatableTaskQueue( | |
85 internal::TaskQueueImpl* queue) { | |
86 DCHECK(main_thread_checker_.CalledOnValidThread()); | |
87 MoveNewlyUpdatableQueuesIntoUpdatableQueueSet(); | |
88 #ifndef NDEBUG | |
89 { | |
90 base::AutoLock lock(newly_updatable_lock_); | |
91 DCHECK(!(updatable_queue_set_.find(queue) == updatable_queue_set_.end() && | |
92 std::find(newly_updatable_.begin(), newly_updatable_.end(), | |
93 queue) != newly_updatable_.end())); | |
94 } | |
95 #endif | |
96 updatable_queue_set_.erase(queue); | |
97 } | |
98 | |
99 void TimeDomain::UpdateWorkQueues( | |
100 bool should_trigger_wakeup, | |
101 const internal::TaskQueueImpl::Task* previous_task) { | |
102 DCHECK(main_thread_checker_.CalledOnValidThread()); | |
103 LazyNow lazy_now(GetLazyNow()); | |
104 | |
105 // Move any ready delayed tasks into the incomming queues. | |
106 WakeupReadyDelayedQueues(&lazy_now); | |
107 | |
108 MoveNewlyUpdatableQueuesIntoUpdatableQueueSet(); | |
109 | |
110 auto iter = updatable_queue_set_.begin(); | |
111 while (iter != updatable_queue_set_.end()) { | |
112 internal::TaskQueueImpl* queue = *iter++; | |
113 // NOTE Update work queue may erase itself from |updatable_queue_set_|. | |
114 // This is fine, erasing an element won't invalidate any interator, as long | |
115 // as the iterator isn't the element being delated. | |
116 if (queue->work_queue().empty()) | |
117 queue->UpdateWorkQueue(&lazy_now, should_trigger_wakeup, previous_task); | |
118 } | |
119 } | |
120 | |
121 void TimeDomain::MoveNewlyUpdatableQueuesIntoUpdatableQueueSet() { | |
122 DCHECK(main_thread_checker_.CalledOnValidThread()); | |
123 base::AutoLock lock(newly_updatable_lock_); | |
124 while (!newly_updatable_.empty()) { | |
125 updatable_queue_set_.insert(newly_updatable_.back()); | |
126 newly_updatable_.pop_back(); | |
127 } | |
128 } | |
129 | |
130 void TimeDomain::WakeupReadyDelayedQueues(LazyNow* lazy_now) { | |
131 // Wake up any queues with pending delayed work. Note std::multipmap stores | |
132 // the elements sorted by key, so the begin() iterator points to the earliest | |
133 // queue to wakeup. | |
134 std::set<internal::TaskQueueImpl*> dedup_set; | |
135 while (!delayed_wakeup_multimap_.empty()) { | |
136 DelayedWakeupMultimap::iterator next_wakeup = | |
137 delayed_wakeup_multimap_.begin(); | |
138 if (next_wakeup->first > lazy_now->Now()) | |
139 break; | |
140 // A queue could have any number of delayed tasks pending so it's worthwhile | |
141 // deduping calls to MoveReadyDelayedTasksToIncomingQueue since it takes a | |
142 // lock. NOTE the order in which these are called matters since the order | |
143 // in which EnqueueTaskLocks is called is respected when choosing which | |
144 // queue to execute a task from. | |
145 if (dedup_set.insert(next_wakeup->second).second) | |
146 next_wakeup->second->MoveReadyDelayedTasksToIncomingQueue(lazy_now); | |
147 delayed_wakeup_multimap_.erase(next_wakeup); | |
148 } | |
149 } | |
150 | |
151 bool TimeDomain::NextScheduledRunTime(base::TimeTicks* out_time) const { | |
152 if (delayed_wakeup_multimap_.empty()) | |
153 return false; | |
154 | |
155 *out_time = delayed_wakeup_multimap_.begin()->first; | |
156 return true; | |
157 } | |
158 | |
159 bool TimeDomain::NextScheduledTaskQueue(TaskQueue** out_task_queue) const { | |
160 if (delayed_wakeup_multimap_.empty()) | |
161 return false; | |
162 | |
163 *out_task_queue = delayed_wakeup_multimap_.begin()->second; | |
164 return true; | |
165 } | |
166 | |
167 void TimeDomain::AsValueInto(base::trace_event::TracedValue* state) const { | |
168 state->BeginDictionary("time_domain"); | |
169 state->SetString("name", GetName()); | |
170 state->BeginArray("updatable_queue_set"); | |
171 for (auto& queue : updatable_queue_set_) | |
172 state->AppendString(queue->GetName()); | |
173 state->EndArray(); | |
174 AsValueIntoInternal(state); | |
175 state->EndDictionary(); | |
176 } | |
177 | |
178 } // namespace scheduler | |
OLD | NEW |