OLD | NEW |
---|---|
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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/child/compositor_worker_scheduler.h" | 5 #include "platform/scheduler/child/compositor_worker_scheduler.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/callback.h" | 9 #include "base/callback.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
11 #include "base/threading/thread.h" | 11 #include "base/threading/thread.h" |
12 #include "platform/scheduler/child/scheduler_helper.h" | |
13 #include "platform/scheduler/child/scheduler_tqm_delegate.h" | |
12 | 14 |
13 namespace blink { | 15 namespace blink { |
14 namespace scheduler { | 16 namespace scheduler { |
15 | 17 |
16 // TODO(scheduler-dev): Get rid of this asap! | 18 CompositorWorkerScheduler::CompositorWorkerScheduler( |
Sami
2017/04/12 15:54:06
FYI, last time we tried to do this there was a min
nhiroki
2017/04/13 08:23:50
Thank you for the information. I'll take care of p
Sami
2017/04/19 11:14:07
It's probably fine to try landing it at least sinc
nhiroki
2017/04/19 23:10:50
OK, let's try!
| |
17 namespace { | 19 base::Thread* thread, |
18 class CompositorWorkerTaskRunnerWrapper : public TaskQueue { | 20 scoped_refptr<SchedulerTqmDelegate> main_task_runner) |
19 public: | 21 : thread_(thread), |
20 explicit CompositorWorkerTaskRunnerWrapper( | 22 helper_(new SchedulerHelper( |
21 scoped_refptr<base::SingleThreadTaskRunner> task_runner) | 23 main_task_runner, |
22 : task_runner_(task_runner) {} | 24 "compositor.scheduler", |
23 | 25 TRACE_DISABLED_BY_DEFAULT("compositor.scheduler"), |
24 // TaskQueue implementation: | 26 TRACE_DISABLED_BY_DEFAULT("compositor.scheduler.debug"))) {} |
25 void UnregisterTaskQueue() override { NOTREACHED(); } | |
26 | |
27 bool RunsTasksOnCurrentThread() const override { | |
28 return task_runner_->RunsTasksOnCurrentThread(); | |
29 } | |
30 | |
31 bool PostDelayedTask(const tracked_objects::Location& from_here, | |
32 base::OnceClosure task, | |
33 base::TimeDelta delay) override { | |
34 return task_runner_->PostDelayedTask(from_here, std::move(task), delay); | |
35 } | |
36 | |
37 bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here, | |
38 base::OnceClosure task, | |
39 base::TimeDelta delay) override { | |
40 return task_runner_->PostNonNestableDelayedTask(from_here, std::move(task), | |
41 delay); | |
42 } | |
43 | |
44 std::unique_ptr<QueueEnabledVoter> CreateQueueEnabledVoter() override { | |
45 NOTREACHED(); | |
46 return nullptr; | |
47 } | |
48 | |
49 void InsertFence(InsertFencePosition position) override { NOTREACHED(); } | |
50 | |
51 void RemoveFence() override { NOTREACHED(); } | |
52 | |
53 bool BlockedByFence() const override { | |
54 NOTREACHED(); | |
55 return false; | |
56 } | |
57 | |
58 bool IsQueueEnabled() const override { | |
59 NOTREACHED(); | |
60 return true; | |
61 } | |
62 | |
63 bool IsEmpty() const override { | |
64 NOTREACHED(); | |
65 return false; | |
66 }; | |
67 | |
68 size_t GetNumberOfPendingTasks() const override { | |
69 NOTREACHED(); | |
70 return 0; | |
71 }; | |
72 | |
73 bool HasPendingImmediateWork() const override { | |
74 NOTREACHED(); | |
75 return false; | |
76 }; | |
77 | |
78 base::Optional<base::TimeTicks> GetNextScheduledWakeUp() override { | |
79 NOTREACHED(); | |
80 return base::nullopt; | |
81 } | |
82 | |
83 const char* GetName() const override { | |
84 NOTREACHED(); | |
85 return nullptr; | |
86 }; | |
87 | |
88 QueueType GetQueueType() const override { | |
89 NOTREACHED(); | |
90 return QueueType::DEFAULT; | |
91 } | |
92 | |
93 void SetQueuePriority(QueuePriority priority) override { NOTREACHED(); } | |
94 | |
95 QueuePriority GetQueuePriority() const override { | |
96 NOTREACHED(); | |
97 return QueuePriority::NORMAL_PRIORITY; | |
98 }; | |
99 | |
100 void AddTaskObserver( | |
101 base::MessageLoop::TaskObserver* task_observer) override { | |
102 NOTREACHED(); | |
103 } | |
104 | |
105 void RemoveTaskObserver( | |
106 base::MessageLoop::TaskObserver* task_observer) override { | |
107 NOTREACHED(); | |
108 } | |
109 | |
110 void SetTimeDomain(TimeDomain* domain) override { NOTREACHED(); } | |
111 | |
112 TimeDomain* GetTimeDomain() const override { | |
113 return nullptr; | |
114 } | |
115 | |
116 void SetBlameContext(base::trace_event::BlameContext*) override { | |
117 NOTREACHED(); | |
118 } | |
119 | |
120 void SetObserver(Observer* observer) override { NOTREACHED(); } | |
121 | |
122 private: | |
123 ~CompositorWorkerTaskRunnerWrapper() override {} | |
124 | |
125 scoped_refptr<base::SingleThreadTaskRunner> task_runner_; | |
126 }; | |
127 } // namespace | |
128 | |
129 CompositorWorkerScheduler::CompositorWorkerScheduler(base::Thread* thread) | |
130 : thread_(thread) {} | |
131 | 27 |
132 CompositorWorkerScheduler::~CompositorWorkerScheduler() {} | 28 CompositorWorkerScheduler::~CompositorWorkerScheduler() {} |
133 | 29 |
134 void CompositorWorkerScheduler::Init() {} | 30 void CompositorWorkerScheduler::Init() {} |
135 | 31 |
136 scoped_refptr<TaskQueue> CompositorWorkerScheduler::DefaultTaskRunner() { | 32 scoped_refptr<TaskQueue> CompositorWorkerScheduler::DefaultTaskRunner() { |
137 // TODO(sad): Implement a more robust scheduler that can do idle tasks for GC | 33 // TODO(sad): Implement a more robust scheduler that can do idle tasks for GC |
138 // without regressing performance of the rest of the system. | 34 // without regressing performance of the rest of the system. |
139 return make_scoped_refptr( | 35 return helper_->DefaultTaskRunner(); |
140 new CompositorWorkerTaskRunnerWrapper(thread_->task_runner())); | |
141 } | 36 } |
142 | 37 |
143 scoped_refptr<scheduler::SingleThreadIdleTaskRunner> | 38 scoped_refptr<scheduler::SingleThreadIdleTaskRunner> |
144 CompositorWorkerScheduler::IdleTaskRunner() { | 39 CompositorWorkerScheduler::IdleTaskRunner() { |
145 // TODO(flackr): This posts idle tasks as regular tasks. We need to create | 40 // TODO(flackr): This posts idle tasks as regular tasks. We need to create |
146 // an idle task runner with the semantics we want for the compositor thread | 41 // an idle task runner with the semantics we want for the compositor thread |
147 // which runs them after the current frame has been drawn before the next | 42 // which runs them after the current frame has been drawn before the next |
148 // vsync. https://crbug.com/609532 | 43 // vsync. https://crbug.com/609532 |
149 return make_scoped_refptr(new SingleThreadIdleTaskRunner( | 44 return make_scoped_refptr(new SingleThreadIdleTaskRunner( |
150 thread_->task_runner(), this, "compositor.scheduler")); | 45 thread_->task_runner(), this, "compositor.scheduler")); |
151 } | 46 } |
152 | 47 |
153 bool CompositorWorkerScheduler::CanExceedIdleDeadlineIfRequired() const { | 48 bool CompositorWorkerScheduler::CanExceedIdleDeadlineIfRequired() const { |
154 return false; | 49 return false; |
155 } | 50 } |
156 | 51 |
157 bool CompositorWorkerScheduler::ShouldYieldForHighPriorityWork() { | 52 bool CompositorWorkerScheduler::ShouldYieldForHighPriorityWork() { |
158 return false; | 53 return false; |
159 } | 54 } |
160 | 55 |
161 void CompositorWorkerScheduler::AddTaskObserver( | 56 void CompositorWorkerScheduler::AddTaskObserver( |
162 base::MessageLoop::TaskObserver* task_observer) { | 57 base::MessageLoop::TaskObserver* task_observer) { |
163 thread_->message_loop()->AddTaskObserver(task_observer); | 58 helper_->AddTaskObserver(task_observer); |
164 } | 59 } |
165 | 60 |
166 void CompositorWorkerScheduler::RemoveTaskObserver( | 61 void CompositorWorkerScheduler::RemoveTaskObserver( |
167 base::MessageLoop::TaskObserver* task_observer) { | 62 base::MessageLoop::TaskObserver* task_observer) { |
168 thread_->message_loop()->RemoveTaskObserver(task_observer); | 63 helper_->RemoveTaskObserver(task_observer); |
169 } | 64 } |
170 | 65 |
171 void CompositorWorkerScheduler::Shutdown() {} | 66 void CompositorWorkerScheduler::Shutdown() {} |
172 | 67 |
68 scoped_refptr<TaskQueue> CompositorWorkerScheduler::NewUnthrottledTaskRunner( | |
69 TaskQueue::QueueType queue_type) { | |
70 helper_->CheckOnValidThread(); | |
71 scoped_refptr<TaskQueue> unthrottled_task_queue( | |
72 helper_->NewTaskQueue(TaskQueue::Spec(queue_type) | |
73 .SetShouldMonitorQuiescence(true) | |
74 .SetTimeDomain(nullptr))); | |
75 return unthrottled_task_queue; | |
76 } | |
77 | |
173 void CompositorWorkerScheduler::OnIdleTaskPosted() {} | 78 void CompositorWorkerScheduler::OnIdleTaskPosted() {} |
174 | 79 |
175 base::TimeTicks CompositorWorkerScheduler::WillProcessIdleTask() { | 80 base::TimeTicks CompositorWorkerScheduler::WillProcessIdleTask() { |
176 // TODO(flackr): Return the next frame time as the deadline instead. | 81 // TODO(flackr): Return the next frame time as the deadline instead. |
177 // TODO(flackr): Ensure that oilpan GC does happen on the compositor thread | 82 // TODO(flackr): Ensure that oilpan GC does happen on the compositor thread |
178 // even though we will have no long idle periods. https://crbug.com/609531 | 83 // even though we will have no long idle periods. https://crbug.com/609531 |
179 return base::TimeTicks::Now() + base::TimeDelta::FromMillisecondsD(16.7); | 84 return base::TimeTicks::Now() + base::TimeDelta::FromMillisecondsD(16.7); |
180 } | 85 } |
181 | 86 |
182 void CompositorWorkerScheduler::DidProcessIdleTask() {} | 87 void CompositorWorkerScheduler::DidProcessIdleTask() {} |
183 | 88 |
184 base::TimeTicks CompositorWorkerScheduler::NowTicks() { | 89 base::TimeTicks CompositorWorkerScheduler::NowTicks() { |
185 return base::TimeTicks::Now(); | 90 return base::TimeTicks::Now(); |
186 } | 91 } |
187 | 92 |
188 } // namespace scheduler | 93 } // namespace scheduler |
189 } // namespace blink | 94 } // namespace blink |
OLD | NEW |