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() : weak_factory_(this) {} | |
16 | |
17 TimeDomain::~TimeDomain() {} | |
18 | |
19 void TimeDomain::UnregisterQueue(internal::TaskQueueImpl* queue) { | |
20 // We need to remove |task_queue| from delayed_wakeup_multimap_ which is a | |
21 // little awkward since it's keyed by time. O(n) running time. | |
22 for (DelayedWakeupMultimap::iterator iter = delayed_wakeup_multimap_.begin(); | |
23 iter != delayed_wakeup_multimap_.end();) { | |
24 if (iter->second == queue) { | |
25 DelayedWakeupMultimap::iterator temp = iter; | |
26 iter++; | |
27 // O(1) amortized. | |
28 delayed_wakeup_multimap_.erase(temp); | |
29 } else { | |
30 iter++; | |
31 } | |
32 } | |
33 | |
34 // |newly_updatable_| might contain |task_queue|, we use | |
35 // MoveNewlyUpdatableQueuesIntoUpdatableQueueSet to flush it out. | |
36 MoveNewlyUpdatableQueuesIntoUpdatableQueueSet(); | |
37 updatable_queue_set_.erase(queue); | |
38 } | |
39 | |
40 void TimeDomain::MigrateQueue(internal::TaskQueueImpl* queue, | |
41 TimeDomain* destination_time_domain) { | |
42 LazyNow destination_lazy_now = destination_time_domain->CreateLazyNow(); | |
43 // We need to remove |task_queue| from delayed_wakeup_multimap_ which is a | |
44 // little awkward since it's keyed by time. O(n) running time. | |
45 for (DelayedWakeupMultimap::iterator iter = delayed_wakeup_multimap_.begin(); | |
46 iter != delayed_wakeup_multimap_.end();) { | |
47 if (iter->second == queue) { | |
48 destination_time_domain->ScheduleDelayedWork(queue, iter->first, | |
49 &destination_lazy_now); | |
50 DelayedWakeupMultimap::iterator temp = iter; | |
51 iter++; | |
52 // O(1) amortized. | |
53 delayed_wakeup_multimap_.erase(temp); | |
54 } else { | |
55 iter++; | |
56 } | |
57 } | |
58 | |
59 // |newly_updatable_| might contain |queue|, we use | |
60 // MoveNewlyUpdatableQueuesIntoUpdatableQueueSet to flush it out. | |
61 MoveNewlyUpdatableQueuesIntoUpdatableQueueSet(); | |
62 updatable_queue_set_.erase(queue); | |
63 } | |
64 | |
65 void TimeDomain::ScheduleDelayedWork(internal::TaskQueueImpl* queue, | |
66 base::TimeTicks delayed_run_time, | |
67 LazyNow* lazy_now) { | |
68 DCHECK(main_thread_checker_.CalledOnValidThread()); | |
69 // Dedupe wakeups. | |
70 if (delayed_wakeup_multimap_.find(delayed_run_time) == | |
71 delayed_wakeup_multimap_.end()) { | |
72 base::TimeDelta delay = | |
73 std::max(base::TimeDelta(), delayed_run_time - lazy_now->Now()); | |
74 RequestWakeup(delay); | |
75 } | |
76 delayed_wakeup_multimap_.insert(std::make_pair(delayed_run_time, queue)); | |
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(CreateLazyNow()); | |
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"); | |
Sami
2015/11/19 14:52:23
Does this work? Looks like |state| will be appendi
alex clarke (OOO till 29th)
2015/11/19 15:57:14
Yes it does, without it the results were badly for
| |
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 |