| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/bind.h" | |
| 6 #include "base/format_macros.h" | |
| 7 #include "base/memory/scoped_vector.h" | |
| 8 #include "base/strings/stringprintf.h" | |
| 9 #include "base/synchronization/condition_variable.h" | |
| 10 #include "base/synchronization/lock.h" | |
| 11 #include "base/synchronization/waitable_event.h" | |
| 12 #include "base/threading/thread.h" | |
| 13 #include "base/time/time.h" | |
| 14 #include "build/build_config.h" | |
| 15 #include "testing/gtest/include/gtest/gtest.h" | |
| 16 #include "testing/perf/perf_test.h" | |
| 17 | |
| 18 #if defined(OS_ANDROID) | |
| 19 #include "base/android/java_handler_thread.h" | |
| 20 #endif | |
| 21 | |
| 22 namespace base { | |
| 23 | |
| 24 class ScheduleWorkTest : public testing::Test { | |
| 25 public: | |
| 26 ScheduleWorkTest() : counter_(0) {} | |
| 27 | |
| 28 void Increment(uint64_t amount) { counter_ += amount; } | |
| 29 | |
| 30 void Schedule(int index) { | |
| 31 base::TimeTicks start = base::TimeTicks::Now(); | |
| 32 base::ThreadTicks thread_start; | |
| 33 if (ThreadTicks::IsSupported()) | |
| 34 thread_start = base::ThreadTicks::Now(); | |
| 35 base::TimeDelta minimum = base::TimeDelta::Max(); | |
| 36 base::TimeDelta maximum = base::TimeDelta(); | |
| 37 base::TimeTicks now, lastnow = start; | |
| 38 uint64_t schedule_calls = 0u; | |
| 39 do { | |
| 40 for (size_t i = 0; i < kBatchSize; ++i) { | |
| 41 target_message_loop()->ScheduleWork(); | |
| 42 schedule_calls++; | |
| 43 } | |
| 44 now = base::TimeTicks::Now(); | |
| 45 base::TimeDelta laptime = now - lastnow; | |
| 46 lastnow = now; | |
| 47 minimum = std::min(minimum, laptime); | |
| 48 maximum = std::max(maximum, laptime); | |
| 49 } while (now - start < base::TimeDelta::FromSeconds(kTargetTimeSec)); | |
| 50 | |
| 51 scheduling_times_[index] = now - start; | |
| 52 if (ThreadTicks::IsSupported()) | |
| 53 scheduling_thread_times_[index] = | |
| 54 base::ThreadTicks::Now() - thread_start; | |
| 55 min_batch_times_[index] = minimum; | |
| 56 max_batch_times_[index] = maximum; | |
| 57 target_message_loop()->PostTask(FROM_HERE, | |
| 58 base::Bind(&ScheduleWorkTest::Increment, | |
| 59 base::Unretained(this), | |
| 60 schedule_calls)); | |
| 61 } | |
| 62 | |
| 63 void ScheduleWork(MessageLoop::Type target_type, int num_scheduling_threads) { | |
| 64 #if defined(OS_ANDROID) | |
| 65 if (target_type == MessageLoop::TYPE_JAVA) { | |
| 66 java_thread_.reset(new android::JavaHandlerThread("target")); | |
| 67 java_thread_->Start(); | |
| 68 } else | |
| 69 #endif | |
| 70 { | |
| 71 target_.reset(new Thread("target")); | |
| 72 target_->StartWithOptions(Thread::Options(target_type, 0u)); | |
| 73 } | |
| 74 | |
| 75 ScopedVector<Thread> scheduling_threads; | |
| 76 scheduling_times_.reset(new base::TimeDelta[num_scheduling_threads]); | |
| 77 scheduling_thread_times_.reset(new base::TimeDelta[num_scheduling_threads]); | |
| 78 min_batch_times_.reset(new base::TimeDelta[num_scheduling_threads]); | |
| 79 max_batch_times_.reset(new base::TimeDelta[num_scheduling_threads]); | |
| 80 | |
| 81 for (int i = 0; i < num_scheduling_threads; ++i) { | |
| 82 scheduling_threads.push_back(new Thread("posting thread")); | |
| 83 scheduling_threads[i]->Start(); | |
| 84 } | |
| 85 | |
| 86 for (int i = 0; i < num_scheduling_threads; ++i) { | |
| 87 scheduling_threads[i]->message_loop()->PostTask( | |
| 88 FROM_HERE, | |
| 89 base::Bind(&ScheduleWorkTest::Schedule, base::Unretained(this), i)); | |
| 90 } | |
| 91 | |
| 92 for (int i = 0; i < num_scheduling_threads; ++i) { | |
| 93 scheduling_threads[i]->Stop(); | |
| 94 } | |
| 95 #if defined(OS_ANDROID) | |
| 96 if (target_type == MessageLoop::TYPE_JAVA) { | |
| 97 java_thread_->Stop(); | |
| 98 java_thread_.reset(); | |
| 99 } else | |
| 100 #endif | |
| 101 { | |
| 102 target_->Stop(); | |
| 103 target_.reset(); | |
| 104 } | |
| 105 base::TimeDelta total_time; | |
| 106 base::TimeDelta total_thread_time; | |
| 107 base::TimeDelta min_batch_time = base::TimeDelta::Max(); | |
| 108 base::TimeDelta max_batch_time = base::TimeDelta(); | |
| 109 for (int i = 0; i < num_scheduling_threads; ++i) { | |
| 110 total_time += scheduling_times_[i]; | |
| 111 total_thread_time += scheduling_thread_times_[i]; | |
| 112 min_batch_time = std::min(min_batch_time, min_batch_times_[i]); | |
| 113 max_batch_time = std::max(max_batch_time, max_batch_times_[i]); | |
| 114 } | |
| 115 std::string trace = StringPrintf( | |
| 116 "%d_threads_scheduling_to_%s_pump", | |
| 117 num_scheduling_threads, | |
| 118 target_type == MessageLoop::TYPE_IO | |
| 119 ? "io" | |
| 120 : (target_type == MessageLoop::TYPE_UI ? "ui" : "default")); | |
| 121 perf_test::PrintResult( | |
| 122 "task", | |
| 123 "", | |
| 124 trace, | |
| 125 total_time.InMicroseconds() / static_cast<double>(counter_), | |
| 126 "us/task", | |
| 127 true); | |
| 128 perf_test::PrintResult( | |
| 129 "task", | |
| 130 "_min_batch_time", | |
| 131 trace, | |
| 132 min_batch_time.InMicroseconds() / static_cast<double>(kBatchSize), | |
| 133 "us/task", | |
| 134 false); | |
| 135 perf_test::PrintResult( | |
| 136 "task", | |
| 137 "_max_batch_time", | |
| 138 trace, | |
| 139 max_batch_time.InMicroseconds() / static_cast<double>(kBatchSize), | |
| 140 "us/task", | |
| 141 false); | |
| 142 if (ThreadTicks::IsSupported()) { | |
| 143 perf_test::PrintResult( | |
| 144 "task", | |
| 145 "_thread_time", | |
| 146 trace, | |
| 147 total_thread_time.InMicroseconds() / static_cast<double>(counter_), | |
| 148 "us/task", | |
| 149 true); | |
| 150 } | |
| 151 } | |
| 152 | |
| 153 MessageLoop* target_message_loop() { | |
| 154 #if defined(OS_ANDROID) | |
| 155 if (java_thread_) | |
| 156 return java_thread_->message_loop(); | |
| 157 #endif | |
| 158 return target_->message_loop(); | |
| 159 } | |
| 160 | |
| 161 private: | |
| 162 scoped_ptr<Thread> target_; | |
| 163 #if defined(OS_ANDROID) | |
| 164 scoped_ptr<android::JavaHandlerThread> java_thread_; | |
| 165 #endif | |
| 166 scoped_ptr<base::TimeDelta[]> scheduling_times_; | |
| 167 scoped_ptr<base::TimeDelta[]> scheduling_thread_times_; | |
| 168 scoped_ptr<base::TimeDelta[]> min_batch_times_; | |
| 169 scoped_ptr<base::TimeDelta[]> max_batch_times_; | |
| 170 uint64_t counter_; | |
| 171 | |
| 172 static const size_t kTargetTimeSec = 5; | |
| 173 static const size_t kBatchSize = 1000; | |
| 174 }; | |
| 175 | |
| 176 TEST_F(ScheduleWorkTest, ThreadTimeToIOFromOneThread) { | |
| 177 ScheduleWork(MessageLoop::TYPE_IO, 1); | |
| 178 } | |
| 179 | |
| 180 TEST_F(ScheduleWorkTest, ThreadTimeToIOFromTwoThreads) { | |
| 181 ScheduleWork(MessageLoop::TYPE_IO, 2); | |
| 182 } | |
| 183 | |
| 184 TEST_F(ScheduleWorkTest, ThreadTimeToIOFromFourThreads) { | |
| 185 ScheduleWork(MessageLoop::TYPE_IO, 4); | |
| 186 } | |
| 187 | |
| 188 TEST_F(ScheduleWorkTest, ThreadTimeToUIFromOneThread) { | |
| 189 ScheduleWork(MessageLoop::TYPE_UI, 1); | |
| 190 } | |
| 191 | |
| 192 TEST_F(ScheduleWorkTest, ThreadTimeToUIFromTwoThreads) { | |
| 193 ScheduleWork(MessageLoop::TYPE_UI, 2); | |
| 194 } | |
| 195 | |
| 196 TEST_F(ScheduleWorkTest, ThreadTimeToUIFromFourThreads) { | |
| 197 ScheduleWork(MessageLoop::TYPE_UI, 4); | |
| 198 } | |
| 199 | |
| 200 TEST_F(ScheduleWorkTest, ThreadTimeToDefaultFromOneThread) { | |
| 201 ScheduleWork(MessageLoop::TYPE_DEFAULT, 1); | |
| 202 } | |
| 203 | |
| 204 TEST_F(ScheduleWorkTest, ThreadTimeToDefaultFromTwoThreads) { | |
| 205 ScheduleWork(MessageLoop::TYPE_DEFAULT, 2); | |
| 206 } | |
| 207 | |
| 208 TEST_F(ScheduleWorkTest, ThreadTimeToDefaultFromFourThreads) { | |
| 209 ScheduleWork(MessageLoop::TYPE_DEFAULT, 4); | |
| 210 } | |
| 211 | |
| 212 #if defined(OS_ANDROID) | |
| 213 TEST_F(ScheduleWorkTest, ThreadTimeToJavaFromOneThread) { | |
| 214 ScheduleWork(MessageLoop::TYPE_JAVA, 1); | |
| 215 } | |
| 216 | |
| 217 TEST_F(ScheduleWorkTest, ThreadTimeToJavaFromTwoThreads) { | |
| 218 ScheduleWork(MessageLoop::TYPE_JAVA, 2); | |
| 219 } | |
| 220 | |
| 221 TEST_F(ScheduleWorkTest, ThreadTimeToJavaFromFourThreads) { | |
| 222 ScheduleWork(MessageLoop::TYPE_JAVA, 4); | |
| 223 } | |
| 224 #endif | |
| 225 | |
| 226 class FakeMessagePump : public MessagePump { | |
| 227 public: | |
| 228 FakeMessagePump() {} | |
| 229 ~FakeMessagePump() override {} | |
| 230 | |
| 231 void Run(Delegate* delegate) override {} | |
| 232 | |
| 233 void Quit() override {} | |
| 234 void ScheduleWork() override {} | |
| 235 void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override {} | |
| 236 }; | |
| 237 | |
| 238 class PostTaskTest : public testing::Test { | |
| 239 public: | |
| 240 void Run(int batch_size, int tasks_per_reload) { | |
| 241 base::TimeTicks start = base::TimeTicks::Now(); | |
| 242 base::TimeTicks now; | |
| 243 MessageLoop loop(scoped_ptr<MessagePump>(new FakeMessagePump)); | |
| 244 scoped_refptr<internal::IncomingTaskQueue> queue( | |
| 245 new internal::IncomingTaskQueue(&loop)); | |
| 246 uint32_t num_posted = 0; | |
| 247 do { | |
| 248 for (int i = 0; i < batch_size; ++i) { | |
| 249 for (int j = 0; j < tasks_per_reload; ++j) { | |
| 250 queue->AddToIncomingQueue( | |
| 251 FROM_HERE, base::Bind(&DoNothing), base::TimeDelta(), false); | |
| 252 num_posted++; | |
| 253 } | |
| 254 TaskQueue loop_local_queue; | |
| 255 queue->ReloadWorkQueue(&loop_local_queue); | |
| 256 while (!loop_local_queue.empty()) { | |
| 257 PendingTask t = loop_local_queue.front(); | |
| 258 loop_local_queue.pop(); | |
| 259 loop.RunTask(t); | |
| 260 } | |
| 261 } | |
| 262 | |
| 263 now = base::TimeTicks::Now(); | |
| 264 } while (now - start < base::TimeDelta::FromSeconds(5)); | |
| 265 std::string trace = StringPrintf("%d_tasks_per_reload", tasks_per_reload); | |
| 266 perf_test::PrintResult( | |
| 267 "task", | |
| 268 "", | |
| 269 trace, | |
| 270 (now - start).InMicroseconds() / static_cast<double>(num_posted), | |
| 271 "us/task", | |
| 272 true); | |
| 273 } | |
| 274 }; | |
| 275 | |
| 276 TEST_F(PostTaskTest, OneTaskPerReload) { | |
| 277 Run(10000, 1); | |
| 278 } | |
| 279 | |
| 280 TEST_F(PostTaskTest, TenTasksPerReload) { | |
| 281 Run(10000, 10); | |
| 282 } | |
| 283 | |
| 284 TEST_F(PostTaskTest, OneHundredTasksPerReload) { | |
| 285 Run(1000, 100); | |
| 286 } | |
| 287 | |
| 288 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
