OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "components/scheduler/base/task_queue_manager.h" | 5 #include "components/scheduler/base/task_queue_manager.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
11 #include "base/location.h" | 11 #include "base/location.h" |
12 #include "base/memory/ptr_util.h" | 12 #include "base/memory/ptr_util.h" |
13 #include "base/memory/ref_counted_memory.h" | 13 #include "base/memory/ref_counted_memory.h" |
14 #include "base/run_loop.h" | 14 #include "base/run_loop.h" |
15 #include "base/single_thread_task_runner.h" | 15 #include "base/single_thread_task_runner.h" |
16 #include "base/test/simple_test_tick_clock.h" | 16 #include "base/test/simple_test_tick_clock.h" |
17 #include "base/test/trace_event_analyzer.h" | 17 #include "base/test/trace_event_analyzer.h" |
18 #include "base/threading/thread.h" | 18 #include "base/threading/thread.h" |
19 #include "base/trace_event/blame_context.h" | 19 #include "base/trace_event/blame_context.h" |
20 #include "base/trace_event/trace_buffer.h" | 20 #include "base/trace_event/trace_buffer.h" |
21 #include "cc/test/ordered_simple_task_runner.h" | 21 #include "cc/test/ordered_simple_task_runner.h" |
22 #include "components/scheduler/base/real_time_domain.h" | 22 #include "components/scheduler/base/real_time_domain.h" |
23 #include "components/scheduler/base/task_queue_impl.h" | 23 #include "components/scheduler/base/task_queue_impl.h" |
24 #include "components/scheduler/base/task_queue_manager_delegate_for_test.h" | 24 #include "components/scheduler/base/task_queue_manager_delegate_for_test.h" |
25 #include "components/scheduler/base/task_queue_selector.h" | 25 #include "components/scheduler/base/task_queue_selector.h" |
26 #include "components/scheduler/base/test_always_fail_time_source.h" | 26 #include "components/scheduler/base/task_time_tracker.h" |
| 27 #include "components/scheduler/base/test_count_uses_time_source.h" |
27 #include "components/scheduler/base/test_time_source.h" | 28 #include "components/scheduler/base/test_time_source.h" |
28 #include "components/scheduler/base/virtual_time_domain.h" | 29 #include "components/scheduler/base/virtual_time_domain.h" |
29 #include "components/scheduler/base/work_queue.h" | 30 #include "components/scheduler/base/work_queue.h" |
30 #include "components/scheduler/base/work_queue_sets.h" | 31 #include "components/scheduler/base/work_queue_sets.h" |
31 #include "testing/gmock/include/gmock/gmock.h" | 32 #include "testing/gmock/include/gmock/gmock.h" |
32 | 33 |
33 using testing::ElementsAre; | 34 using testing::ElementsAre; |
34 using testing::ElementsAreArray; | 35 using testing::ElementsAreArray; |
35 using testing::_; | 36 using testing::_; |
36 using scheduler::internal::EnqueueOrder; | 37 using scheduler::internal::EnqueueOrder; |
(...skipping 25 matching lines...) Expand all Loading... |
62 void DeleteTaskQueueManager() { manager_.reset(); } | 63 void DeleteTaskQueueManager() { manager_.reset(); } |
63 | 64 |
64 protected: | 65 protected: |
65 void InitializeWithClock(size_t num_queues, | 66 void InitializeWithClock(size_t num_queues, |
66 std::unique_ptr<base::TickClock> test_time_source) { | 67 std::unique_ptr<base::TickClock> test_time_source) { |
67 test_task_runner_ = make_scoped_refptr( | 68 test_task_runner_ = make_scoped_refptr( |
68 new cc::OrderedSimpleTaskRunner(now_src_.get(), false)); | 69 new cc::OrderedSimpleTaskRunner(now_src_.get(), false)); |
69 main_task_runner_ = TaskQueueManagerDelegateForTest::Create( | 70 main_task_runner_ = TaskQueueManagerDelegateForTest::Create( |
70 test_task_runner_.get(), | 71 test_task_runner_.get(), |
71 base::WrapUnique(new TestTimeSource(now_src_.get()))); | 72 base::WrapUnique(new TestTimeSource(now_src_.get()))); |
72 manager_ = base::WrapUnique( | 73 |
73 new TaskQueueManager(main_task_runner_, "test.scheduler", | 74 manager_ = base::WrapUnique(new TaskQueueManager( |
74 "test.scheduler", "test.scheduler.debug")); | 75 main_task_runner_, "test.scheduler", "test.scheduler", |
| 76 "test.scheduler.debug", &task_time_tracker_)); |
75 | 77 |
76 for (size_t i = 0; i < num_queues; i++) | 78 for (size_t i = 0; i < num_queues; i++) |
77 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); | 79 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
78 } | 80 } |
79 | 81 |
80 void Initialize(size_t num_queues) { | 82 void Initialize(size_t num_queues) { |
81 now_src_.reset(new base::SimpleTestTickClock()); | 83 now_src_.reset(new base::SimpleTestTickClock()); |
82 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); | 84 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); |
83 InitializeWithClock(num_queues, | 85 InitializeWithClock(num_queues, |
84 base::WrapUnique(new TestTimeSource(now_src_.get()))); | 86 base::WrapUnique(new TestTimeSource(now_src_.get()))); |
85 } | 87 } |
86 | 88 |
87 void InitializeWithRealMessageLoop(size_t num_queues) { | 89 void InitializeWithRealMessageLoop(size_t num_queues) { |
88 now_src_.reset(new base::SimpleTestTickClock()); | 90 now_src_.reset(new base::SimpleTestTickClock()); |
89 message_loop_.reset(new base::MessageLoop()); | 91 message_loop_.reset(new base::MessageLoop()); |
90 manager_ = base::WrapUnique(new TaskQueueManager( | 92 manager_ = base::WrapUnique(new TaskQueueManager( |
91 MessageLoopTaskRunner::Create( | 93 MessageLoopTaskRunner::Create( |
92 base::WrapUnique(new TestTimeSource(now_src_.get()))), | 94 base::WrapUnique(new TestTimeSource(now_src_.get()))), |
93 "test.scheduler", "test.scheduler", "test.scheduler.debug")); | 95 "test.scheduler", "test.scheduler", "test.scheduler.debug", |
| 96 &task_time_tracker_)); |
94 | 97 |
95 for (size_t i = 0; i < num_queues; i++) | 98 for (size_t i = 0; i < num_queues; i++) |
96 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); | 99 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
97 } | 100 } |
98 | 101 |
99 std::unique_ptr<base::MessageLoop> message_loop_; | 102 std::unique_ptr<base::MessageLoop> message_loop_; |
100 std::unique_ptr<base::SimpleTestTickClock> now_src_; | 103 std::unique_ptr<base::SimpleTestTickClock> now_src_; |
101 scoped_refptr<TaskQueueManagerDelegateForTest> main_task_runner_; | 104 scoped_refptr<TaskQueueManagerDelegateForTest> main_task_runner_; |
102 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; | 105 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; |
103 std::unique_ptr<TaskQueueManager> manager_; | 106 std::unique_ptr<TaskQueueManager> manager_; |
104 std::vector<scoped_refptr<internal::TaskQueueImpl>> runners_; | 107 std::vector<scoped_refptr<internal::TaskQueueImpl>> runners_; |
| 108 TaskTimeTracker task_time_tracker_; |
105 }; | 109 }; |
106 | 110 |
107 void PostFromNestedRunloop(base::MessageLoop* message_loop, | 111 void PostFromNestedRunloop(base::MessageLoop* message_loop, |
108 base::SingleThreadTaskRunner* runner, | 112 base::SingleThreadTaskRunner* runner, |
109 std::vector<std::pair<base::Closure, bool>>* tasks) { | 113 std::vector<std::pair<base::Closure, bool>>* tasks) { |
110 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop); | 114 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop); |
111 for (std::pair<base::Closure, bool>& pair : *tasks) { | 115 for (std::pair<base::Closure, bool>& pair : *tasks) { |
112 if (pair.second) { | 116 if (pair.second) { |
113 runner->PostTask(FROM_HERE, pair.first); | 117 runner->PostTask(FROM_HERE, pair.first); |
114 } else { | 118 } else { |
115 runner->PostNonNestableTask(FROM_HERE, pair.first); | 119 runner->PostNonNestableTask(FROM_HERE, pair.first); |
116 } | 120 } |
117 } | 121 } |
118 base::RunLoop().RunUntilIdle(); | 122 base::RunLoop().RunUntilIdle(); |
119 } | 123 } |
120 | 124 |
121 void NopTask() {} | 125 void NopTask() {} |
122 | 126 |
123 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) { | 127 TEST_F(TaskQueueManagerTest, |
| 128 NowCalledMinimumNumberOfTimesToComputeTaskDurations) { |
124 message_loop_.reset(new base::MessageLoop()); | 129 message_loop_.reset(new base::MessageLoop()); |
| 130 // This memory is managed by the TaskQueueManager, but we need to hold a |
| 131 // pointer to this object to read out how many times Now was called. |
| 132 TestCountUsesTimeSource* test_count_uses_time_source = |
| 133 new TestCountUsesTimeSource(); |
| 134 |
125 manager_ = base::WrapUnique(new TaskQueueManager( | 135 manager_ = base::WrapUnique(new TaskQueueManager( |
126 MessageLoopTaskRunner::Create( | 136 MessageLoopTaskRunner::Create( |
127 base::WrapUnique(new TestAlwaysFailTimeSource())), | 137 base::WrapUnique(test_count_uses_time_source)), |
128 "test.scheduler", "test.scheduler", "test.scheduler.debug")); | 138 "test.scheduler", "test.scheduler", "test.scheduler.debug", |
| 139 &task_time_tracker_)); |
| 140 manager_->SetWorkBatchSize(6); |
129 | 141 |
130 for (size_t i = 0; i < 3; i++) | 142 for (size_t i = 0; i < 3; i++) |
131 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); | 143 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
132 | 144 |
133 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 145 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
134 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 146 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
135 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 147 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
136 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 148 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
137 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 149 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
138 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 150 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
139 | 151 |
140 message_loop_->RunUntilIdle(); | 152 message_loop_->RunUntilIdle(); |
| 153 // We need to call Now for the beginning of the first task, and then the end |
| 154 // of every task after. We reuse the end time of one task for the start time |
| 155 // of the next task. In this case, there were 6 tasks, so we expect 7 calls to |
| 156 // Now. |
| 157 EXPECT_EQ(7, test_count_uses_time_source->now_calls_count()); |
| 158 } |
| 159 |
| 160 TEST_F(TaskQueueManagerTest, |
| 161 NowNotCalledForNestedTasks) { |
| 162 message_loop_.reset(new base::MessageLoop()); |
| 163 // This memory is managed by the TaskQueueManager, but we need to hold a |
| 164 // pointer to this object to read out how many times Now was called. |
| 165 TestCountUsesTimeSource* test_count_uses_time_source = |
| 166 new TestCountUsesTimeSource(); |
| 167 |
| 168 manager_ = base::WrapUnique(new TaskQueueManager( |
| 169 MessageLoopTaskRunner::Create( |
| 170 base::WrapUnique(test_count_uses_time_source)), |
| 171 "test.scheduler", "test.scheduler", "test.scheduler.debug", |
| 172 &task_time_tracker_)); |
| 173 |
| 174 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
| 175 |
| 176 std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop; |
| 177 for (int i = 0; i <= 6; ++i) { |
| 178 tasks_to_post_from_nested_loop.push_back( |
| 179 std::make_pair(base::Bind(&NopTask), true)); |
| 180 } |
| 181 |
| 182 runners_[0]->PostTask( |
| 183 FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(), |
| 184 base::RetainedRef(runners_[0]), |
| 185 base::Unretained(&tasks_to_post_from_nested_loop))); |
| 186 |
| 187 message_loop_->RunUntilIdle(); |
| 188 // We need to call Now twice, to measure the start and end of the outermost |
| 189 // task. We shouldn't call it for any of the nested tasks. |
| 190 EXPECT_EQ(2, test_count_uses_time_source->now_calls_count()); |
141 } | 191 } |
142 | 192 |
143 void NullTask() {} | 193 void NullTask() {} |
144 | 194 |
145 void TestTask(EnqueueOrder value, std::vector<EnqueueOrder>* out_result) { | 195 void TestTask(EnqueueOrder value, std::vector<EnqueueOrder>* out_result) { |
146 out_result->push_back(value); | 196 out_result->push_back(value); |
147 } | 197 } |
148 | 198 |
149 TEST_F(TaskQueueManagerTest, SingleQueuePosting) { | 199 TEST_F(TaskQueueManagerTest, SingleQueuePosting) { |
150 Initialize(1u); | 200 Initialize(1u); |
(...skipping 1761 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1912 | 1962 |
1913 trace_analyzer::TraceEventVector events; | 1963 trace_analyzer::TraceEventVector events; |
1914 Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_ENTER_CONTEXT) || | 1964 Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_ENTER_CONTEXT) || |
1915 Query::EventPhaseIs(TRACE_EVENT_PHASE_LEAVE_CONTEXT); | 1965 Query::EventPhaseIs(TRACE_EVENT_PHASE_LEAVE_CONTEXT); |
1916 analyzer->FindEvents(q, &events); | 1966 analyzer->FindEvents(q, &events); |
1917 | 1967 |
1918 EXPECT_EQ(2u, events.size()); | 1968 EXPECT_EQ(2u, events.size()); |
1919 } | 1969 } |
1920 | 1970 |
1921 } // namespace scheduler | 1971 } // namespace scheduler |
OLD | NEW |