Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(369)

Side by Side Diff: components/scheduler/base/task_queue_manager_unittest.cc

Issue 1898233002: Report expected task queueing time via UMA (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Address Alex's feedback. Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698