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/test_count_uses_time_source.h" |
| 27 #include "components/scheduler/base/test_task_time_tracker.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 15 matching lines...) Expand all Loading... |
52 private: | 53 private: |
53 explicit MessageLoopTaskRunner(std::unique_ptr<base::TickClock> tick_clock) | 54 explicit MessageLoopTaskRunner(std::unique_ptr<base::TickClock> tick_clock) |
54 : TaskQueueManagerDelegateForTest( | 55 : TaskQueueManagerDelegateForTest( |
55 base::MessageLoop::current()->task_runner(), | 56 base::MessageLoop::current()->task_runner(), |
56 std::move(tick_clock)) {} | 57 std::move(tick_clock)) {} |
57 ~MessageLoopTaskRunner() override {} | 58 ~MessageLoopTaskRunner() override {} |
58 }; | 59 }; |
59 | 60 |
60 class TaskQueueManagerTest : public testing::Test { | 61 class TaskQueueManagerTest : public testing::Test { |
61 public: | 62 public: |
| 63 TaskQueueManagerTest() {} |
62 void DeleteTaskQueueManager() { manager_.reset(); } | 64 void DeleteTaskQueueManager() { manager_.reset(); } |
63 | 65 |
64 protected: | 66 protected: |
65 void InitializeWithClock(size_t num_queues, | 67 void InitializeWithClock(size_t num_queues, |
66 std::unique_ptr<base::TickClock> test_time_source) { | 68 std::unique_ptr<base::TickClock> test_time_source) { |
67 test_task_runner_ = make_scoped_refptr( | 69 test_task_runner_ = make_scoped_refptr( |
68 new cc::OrderedSimpleTaskRunner(now_src_.get(), false)); | 70 new cc::OrderedSimpleTaskRunner(now_src_.get(), false)); |
69 main_task_runner_ = TaskQueueManagerDelegateForTest::Create( | 71 main_task_runner_ = TaskQueueManagerDelegateForTest::Create( |
70 test_task_runner_.get(), | 72 test_task_runner_.get(), |
71 base::WrapUnique(new TestTimeSource(now_src_.get()))); | 73 base::WrapUnique(new TestTimeSource(now_src_.get()))); |
72 manager_ = base::WrapUnique( | 74 |
73 new TaskQueueManager(main_task_runner_, "test.scheduler", | 75 manager_ = base::WrapUnique(new TaskQueueManager( |
74 "test.scheduler", "test.scheduler.debug")); | 76 main_task_runner_, "test.scheduler", "test.scheduler", |
| 77 "test.scheduler.debug")); |
| 78 manager_->SetTaskTimeTracker(&test_task_time_tracker_); |
75 | 79 |
76 for (size_t i = 0; i < num_queues; i++) | 80 for (size_t i = 0; i < num_queues; i++) |
77 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); | 81 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
78 } | 82 } |
79 | 83 |
80 void Initialize(size_t num_queues) { | 84 void Initialize(size_t num_queues) { |
81 now_src_.reset(new base::SimpleTestTickClock()); | 85 now_src_.reset(new base::SimpleTestTickClock()); |
82 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); | 86 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); |
83 InitializeWithClock(num_queues, | 87 InitializeWithClock(num_queues, |
84 base::WrapUnique(new TestTimeSource(now_src_.get()))); | 88 base::WrapUnique(new TestTimeSource(now_src_.get()))); |
85 } | 89 } |
86 | 90 |
87 void InitializeWithRealMessageLoop(size_t num_queues) { | 91 void InitializeWithRealMessageLoop(size_t num_queues) { |
88 now_src_.reset(new base::SimpleTestTickClock()); | 92 now_src_.reset(new base::SimpleTestTickClock()); |
89 message_loop_.reset(new base::MessageLoop()); | 93 message_loop_.reset(new base::MessageLoop()); |
| 94 // A null clock triggers some assertions. |
| 95 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); |
90 manager_ = base::WrapUnique(new TaskQueueManager( | 96 manager_ = base::WrapUnique(new TaskQueueManager( |
91 MessageLoopTaskRunner::Create( | 97 MessageLoopTaskRunner::Create( |
92 base::WrapUnique(new TestTimeSource(now_src_.get()))), | 98 base::WrapUnique(new TestTimeSource(now_src_.get()))), |
93 "test.scheduler", "test.scheduler", "test.scheduler.debug")); | 99 "test.scheduler", "test.scheduler", "test.scheduler.debug")); |
| 100 manager_->SetTaskTimeTracker(&test_task_time_tracker_); |
94 | 101 |
95 for (size_t i = 0; i < num_queues; i++) | 102 for (size_t i = 0; i < num_queues; i++) |
96 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); | 103 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
97 } | 104 } |
98 | 105 |
99 std::unique_ptr<base::MessageLoop> message_loop_; | 106 std::unique_ptr<base::MessageLoop> message_loop_; |
100 std::unique_ptr<base::SimpleTestTickClock> now_src_; | 107 std::unique_ptr<base::SimpleTestTickClock> now_src_; |
101 scoped_refptr<TaskQueueManagerDelegateForTest> main_task_runner_; | 108 scoped_refptr<TaskQueueManagerDelegateForTest> main_task_runner_; |
102 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; | 109 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; |
103 std::unique_ptr<TaskQueueManager> manager_; | 110 std::unique_ptr<TaskQueueManager> manager_; |
104 std::vector<scoped_refptr<internal::TaskQueueImpl>> runners_; | 111 std::vector<scoped_refptr<internal::TaskQueueImpl>> runners_; |
| 112 TestTaskTimeTracker test_task_time_tracker_; |
105 }; | 113 }; |
106 | 114 |
107 void PostFromNestedRunloop(base::MessageLoop* message_loop, | 115 void PostFromNestedRunloop(base::MessageLoop* message_loop, |
108 base::SingleThreadTaskRunner* runner, | 116 base::SingleThreadTaskRunner* runner, |
109 std::vector<std::pair<base::Closure, bool>>* tasks) { | 117 std::vector<std::pair<base::Closure, bool>>* tasks) { |
110 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop); | 118 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop); |
111 for (std::pair<base::Closure, bool>& pair : *tasks) { | 119 for (std::pair<base::Closure, bool>& pair : *tasks) { |
112 if (pair.second) { | 120 if (pair.second) { |
113 runner->PostTask(FROM_HERE, pair.first); | 121 runner->PostTask(FROM_HERE, pair.first); |
114 } else { | 122 } else { |
115 runner->PostNonNestableTask(FROM_HERE, pair.first); | 123 runner->PostNonNestableTask(FROM_HERE, pair.first); |
116 } | 124 } |
117 } | 125 } |
118 base::RunLoop().RunUntilIdle(); | 126 base::RunLoop().RunUntilIdle(); |
119 } | 127 } |
120 | 128 |
121 void NopTask() {} | 129 void NopTask() {} |
122 | 130 |
123 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) { | 131 TEST_F(TaskQueueManagerTest, |
| 132 NowCalledMinimumNumberOfTimesToComputeTaskDurations) { |
124 message_loop_.reset(new base::MessageLoop()); | 133 message_loop_.reset(new base::MessageLoop()); |
| 134 // This memory is managed by the TaskQueueManager, but we need to hold a |
| 135 // pointer to this object to read out how many times Now was called. |
| 136 TestCountUsesTimeSource* test_count_uses_time_source = |
| 137 new TestCountUsesTimeSource(); |
| 138 |
125 manager_ = base::WrapUnique(new TaskQueueManager( | 139 manager_ = base::WrapUnique(new TaskQueueManager( |
126 MessageLoopTaskRunner::Create( | 140 MessageLoopTaskRunner::Create( |
127 base::WrapUnique(new TestAlwaysFailTimeSource())), | 141 base::WrapUnique(test_count_uses_time_source)), |
128 "test.scheduler", "test.scheduler", "test.scheduler.debug")); | 142 "test.scheduler", "test.scheduler", "test.scheduler.debug")); |
| 143 manager_->SetWorkBatchSize(6); |
| 144 manager_->SetTaskTimeTracker(&test_task_time_tracker_); |
129 | 145 |
130 for (size_t i = 0; i < 3; i++) | 146 for (size_t i = 0; i < 3; i++) |
131 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); | 147 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
132 | 148 |
133 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 149 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
134 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 150 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
135 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 151 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
136 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 152 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
137 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 153 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
138 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 154 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
139 | 155 |
140 message_loop_->RunUntilIdle(); | 156 message_loop_->RunUntilIdle(); |
| 157 // We need to call Now for the beginning of the first task, and then the end |
| 158 // of every task after. We reuse the end time of one task for the start time |
| 159 // of the next task. In this case, there were 6 tasks, so we expect 7 calls to |
| 160 // Now. |
| 161 EXPECT_EQ(7, test_count_uses_time_source->now_calls_count()); |
| 162 } |
| 163 |
| 164 TEST_F(TaskQueueManagerTest, |
| 165 NowNotCalledForNestedTasks) { |
| 166 message_loop_.reset(new base::MessageLoop()); |
| 167 // This memory is managed by the TaskQueueManager, but we need to hold a |
| 168 // pointer to this object to read out how many times Now was called. |
| 169 TestCountUsesTimeSource* test_count_uses_time_source = |
| 170 new TestCountUsesTimeSource(); |
| 171 |
| 172 manager_ = base::WrapUnique(new TaskQueueManager( |
| 173 MessageLoopTaskRunner::Create( |
| 174 base::WrapUnique(test_count_uses_time_source)), |
| 175 "test.scheduler", "test.scheduler", "test.scheduler.debug")); |
| 176 manager_->SetTaskTimeTracker(&test_task_time_tracker_); |
| 177 |
| 178 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
| 179 |
| 180 std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop; |
| 181 for (int i = 0; i <= 6; ++i) { |
| 182 tasks_to_post_from_nested_loop.push_back( |
| 183 std::make_pair(base::Bind(&NopTask), true)); |
| 184 } |
| 185 |
| 186 runners_[0]->PostTask( |
| 187 FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(), |
| 188 base::RetainedRef(runners_[0]), |
| 189 base::Unretained(&tasks_to_post_from_nested_loop))); |
| 190 |
| 191 message_loop_->RunUntilIdle(); |
| 192 // We need to call Now twice, to measure the start and end of the outermost |
| 193 // task. We shouldn't call it for any of the nested tasks. |
| 194 EXPECT_EQ(2, test_count_uses_time_source->now_calls_count()); |
141 } | 195 } |
142 | 196 |
143 void NullTask() {} | 197 void NullTask() {} |
144 | 198 |
145 void TestTask(EnqueueOrder value, std::vector<EnqueueOrder>* out_result) { | 199 void TestTask(EnqueueOrder value, std::vector<EnqueueOrder>* out_result) { |
146 out_result->push_back(value); | 200 out_result->push_back(value); |
147 } | 201 } |
148 | 202 |
149 TEST_F(TaskQueueManagerTest, SingleQueuePosting) { | 203 TEST_F(TaskQueueManagerTest, SingleQueuePosting) { |
150 Initialize(1u); | 204 Initialize(1u); |
(...skipping 1761 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1912 | 1966 |
1913 trace_analyzer::TraceEventVector events; | 1967 trace_analyzer::TraceEventVector events; |
1914 Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_ENTER_CONTEXT) || | 1968 Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_ENTER_CONTEXT) || |
1915 Query::EventPhaseIs(TRACE_EVENT_PHASE_LEAVE_CONTEXT); | 1969 Query::EventPhaseIs(TRACE_EVENT_PHASE_LEAVE_CONTEXT); |
1916 analyzer->FindEvents(q, &events); | 1970 analyzer->FindEvents(q, &events); |
1917 | 1971 |
1918 EXPECT_EQ(2u, events.size()); | 1972 EXPECT_EQ(2u, events.size()); |
1919 } | 1973 } |
1920 | 1974 |
1921 } // namespace scheduler | 1975 } // namespace scheduler |
OLD | NEW |