OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 <stddef.h> | 5 #include <stddef.h> |
6 #include <stdint.h> | 6 #include <stdint.h> |
7 | 7 |
8 #include "base/macros.h" | 8 #include "base/macros.h" |
9 #include "base/memory/ptr_util.h" | 9 #include "base/memory/ptr_util.h" |
10 #include "base/test/test_simple_task_runner.h" | 10 #include "base/test/test_simple_task_runner.h" |
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
122 static const int kTimeCheckInterval = 10; | 122 static const int kTimeCheckInterval = 10; |
123 | 123 |
124 class PerfImageDecodeTaskImpl : public TileTask { | 124 class PerfImageDecodeTaskImpl : public TileTask { |
125 public: | 125 public: |
126 PerfImageDecodeTaskImpl() : TileTask(true) {} | 126 PerfImageDecodeTaskImpl() : TileTask(true) {} |
127 | 127 |
128 // Overridden from Task: | 128 // Overridden from Task: |
129 void RunOnWorkerThread() override {} | 129 void RunOnWorkerThread() override {} |
130 | 130 |
131 // Overridden from TileTask: | 131 // Overridden from TileTask: |
132 void OnTaskCompleted() override { state().Reset(); } | 132 void OnTaskCompleted() override {} |
133 | 133 |
134 protected: | 134 protected: |
135 ~PerfImageDecodeTaskImpl() override {} | 135 ~PerfImageDecodeTaskImpl() override {} |
136 | 136 |
137 private: | 137 private: |
138 DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl); | 138 DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl); |
139 }; | 139 }; |
140 | 140 |
141 class PerfRasterBufferProviderHelper { | 141 class PerfRasterBufferProviderHelper { |
142 public: | 142 public: |
(...skipping 15 matching lines...) Expand all Loading... |
158 resource_(std::move(resource)), | 158 resource_(std::move(resource)), |
159 raster_buffer_(std::move(raster_buffer)) {} | 159 raster_buffer_(std::move(raster_buffer)) {} |
160 | 160 |
161 // Overridden from Task: | 161 // Overridden from Task: |
162 void RunOnWorkerThread() override {} | 162 void RunOnWorkerThread() override {} |
163 | 163 |
164 // Overridden from TileTask: | 164 // Overridden from TileTask: |
165 void OnTaskCompleted() override { | 165 void OnTaskCompleted() override { |
166 if (helper_) | 166 if (helper_) |
167 helper_->ReleaseBufferForRaster(std::move(raster_buffer_)); | 167 helper_->ReleaseBufferForRaster(std::move(raster_buffer_)); |
168 | |
169 state().Reset(); | |
170 } | 168 } |
171 | 169 |
172 protected: | 170 protected: |
173 ~PerfRasterTaskImpl() override {} | 171 ~PerfRasterTaskImpl() override {} |
174 | 172 |
175 private: | 173 private: |
176 PerfRasterBufferProviderHelper* helper_; | 174 PerfRasterBufferProviderHelper* helper_; |
177 std::unique_ptr<ScopedResource> resource_; | 175 std::unique_ptr<ScopedResource> resource_; |
178 std::unique_ptr<RasterBuffer> raster_buffer_; | 176 std::unique_ptr<RasterBuffer> raster_buffer_; |
179 | 177 |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
217 if (helper) { | 215 if (helper) { |
218 raster_buffer = helper->AcquireBufferForRaster(resource.get(), 0, 0); | 216 raster_buffer = helper->AcquireBufferForRaster(resource.get(), 0, 0); |
219 } | 217 } |
220 TileTask::Vector dependencies = image_decode_tasks; | 218 TileTask::Vector dependencies = image_decode_tasks; |
221 raster_tasks->push_back( | 219 raster_tasks->push_back( |
222 new PerfRasterTaskImpl(helper, std::move(resource), | 220 new PerfRasterTaskImpl(helper, std::move(resource), |
223 std::move(raster_buffer), &dependencies)); | 221 std::move(raster_buffer), &dependencies)); |
224 } | 222 } |
225 } | 223 } |
226 | 224 |
| 225 void ResetRasterTasks(const RasterTaskVector& raster_tasks) { |
| 226 for (auto& raster_task : raster_tasks) { |
| 227 for (auto& decode_task : raster_task->dependencies()) |
| 228 decode_task->state().Reset(); |
| 229 |
| 230 raster_task->state().Reset(); |
| 231 } |
| 232 } |
| 233 |
| 234 void CancelRasterTasks(const RasterTaskVector& raster_tasks) { |
| 235 for (auto& raster_task : raster_tasks) { |
| 236 for (auto& decode_task : raster_task->dependencies()) { |
| 237 if (!decode_task->state().IsCanceled()) |
| 238 decode_task->state().DidCancel(); |
| 239 } |
| 240 |
| 241 if (!raster_task->state().IsCanceled()) |
| 242 raster_task->state().DidCancel(); |
| 243 } |
| 244 } |
| 245 |
227 void BuildTileTaskGraph(TaskGraph* graph, | 246 void BuildTileTaskGraph(TaskGraph* graph, |
228 const RasterTaskVector& raster_tasks) { | 247 const RasterTaskVector& raster_tasks) { |
229 uint16_t priority = 0; | 248 uint16_t priority = 0; |
230 | 249 |
231 for (auto& raster_task : raster_tasks) { | 250 for (auto& raster_task : raster_tasks) { |
232 priority++; | 251 priority++; |
233 | 252 |
234 for (auto& decode_task : raster_task->dependencies()) { | 253 for (auto& decode_task : raster_task->dependencies()) { |
235 // Add decode task if it doesn't already exist in graph. | 254 // Add decode task if it doesn't already exist in graph. |
236 TaskGraph::Node::Vector::iterator decode_it = | 255 TaskGraph::Node::Vector::iterator decode_it = |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
335 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | 354 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); |
336 CreateRasterTasks(this, num_raster_tasks, image_decode_tasks, | 355 CreateRasterTasks(this, num_raster_tasks, image_decode_tasks, |
337 &raster_tasks); | 356 &raster_tasks); |
338 | 357 |
339 // Avoid unnecessary heap allocations by reusing the same graph. | 358 // Avoid unnecessary heap allocations by reusing the same graph. |
340 TaskGraph graph; | 359 TaskGraph graph; |
341 | 360 |
342 timer_.Reset(); | 361 timer_.Reset(); |
343 do { | 362 do { |
344 graph.Reset(); | 363 graph.Reset(); |
| 364 ResetRasterTasks(raster_tasks); |
345 BuildTileTaskGraph(&graph, raster_tasks); | 365 BuildTileTaskGraph(&graph, raster_tasks); |
346 tile_task_manager_->ScheduleTasks(&graph); | 366 tile_task_manager_->ScheduleTasks(&graph); |
347 tile_task_manager_->CheckForCompletedTasks(); | 367 tile_task_manager_->CheckForCompletedTasks(); |
348 timer_.NextLap(); | 368 timer_.NextLap(); |
349 } while (!timer_.HasTimeLimitExpired()); | 369 } while (!timer_.HasTimeLimitExpired()); |
350 | 370 |
351 TaskGraph empty; | 371 TaskGraph empty; |
352 tile_task_manager_->ScheduleTasks(&empty); | 372 tile_task_manager_->ScheduleTasks(&empty); |
353 RunMessageLoopUntilAllTasksHaveCompleted(); | 373 RunMessageLoopUntilAllTasksHaveCompleted(); |
| 374 tile_task_manager_->CheckForCompletedTasks(); |
354 | 375 |
355 perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name, | 376 perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name, |
356 timer_.LapsPerSecond(), "runs/s", true); | 377 timer_.LapsPerSecond(), "runs/s", true); |
357 } | 378 } |
358 | 379 |
359 void RunScheduleAlternateTasksTest(const std::string& test_name, | 380 void RunScheduleAlternateTasksTest(const std::string& test_name, |
360 unsigned num_raster_tasks, | 381 unsigned num_raster_tasks, |
361 unsigned num_image_decode_tasks) { | 382 unsigned num_image_decode_tasks) { |
362 const size_t kNumVersions = 2; | 383 const size_t kNumVersions = 2; |
363 TileTask::Vector image_decode_tasks[kNumVersions]; | 384 TileTask::Vector image_decode_tasks[kNumVersions]; |
364 RasterTaskVector raster_tasks[kNumVersions]; | 385 RasterTaskVector raster_tasks[kNumVersions]; |
365 for (size_t i = 0; i < kNumVersions; ++i) { | 386 for (size_t i = 0; i < kNumVersions; ++i) { |
366 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]); | 387 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]); |
367 CreateRasterTasks(this, num_raster_tasks, image_decode_tasks[i], | 388 CreateRasterTasks(this, num_raster_tasks, image_decode_tasks[i], |
368 &raster_tasks[i]); | 389 &raster_tasks[i]); |
369 } | 390 } |
370 | 391 |
371 // Avoid unnecessary heap allocations by reusing the same graph. | 392 // Avoid unnecessary heap allocations by reusing the same graph. |
372 TaskGraph graph; | 393 TaskGraph graph; |
373 | 394 |
374 size_t count = 0; | 395 size_t count = 0; |
375 timer_.Reset(); | 396 timer_.Reset(); |
376 do { | 397 do { |
377 graph.Reset(); | 398 graph.Reset(); |
| 399 // Reset the tasks as for scheduling new state tasks are needed. |
| 400 ResetRasterTasks(raster_tasks[count % kNumVersions]); |
378 BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]); | 401 BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]); |
379 tile_task_manager_->ScheduleTasks(&graph); | 402 tile_task_manager_->ScheduleTasks(&graph); |
380 tile_task_manager_->CheckForCompletedTasks(); | 403 tile_task_manager_->CheckForCompletedTasks(); |
381 ++count; | 404 ++count; |
382 timer_.NextLap(); | 405 timer_.NextLap(); |
383 } while (!timer_.HasTimeLimitExpired()); | 406 } while (!timer_.HasTimeLimitExpired()); |
384 | 407 |
385 TaskGraph empty; | 408 TaskGraph empty; |
386 tile_task_manager_->ScheduleTasks(&empty); | 409 tile_task_manager_->ScheduleTasks(&empty); |
387 RunMessageLoopUntilAllTasksHaveCompleted(); | 410 RunMessageLoopUntilAllTasksHaveCompleted(); |
| 411 tile_task_manager_->CheckForCompletedTasks(); |
388 | 412 |
389 perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(), | 413 perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(), |
390 test_name, timer_.LapsPerSecond(), "runs/s", true); | 414 test_name, timer_.LapsPerSecond(), "runs/s", true); |
391 } | 415 } |
392 | 416 |
393 void RunScheduleAndExecuteTasksTest(const std::string& test_name, | 417 void RunScheduleAndExecuteTasksTest(const std::string& test_name, |
394 unsigned num_raster_tasks, | 418 unsigned num_raster_tasks, |
395 unsigned num_image_decode_tasks) { | 419 unsigned num_image_decode_tasks) { |
396 TileTask::Vector image_decode_tasks; | 420 TileTask::Vector image_decode_tasks; |
397 RasterTaskVector raster_tasks; | 421 RasterTaskVector raster_tasks; |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
513 // Avoid unnecessary heap allocations by reusing the same graph. | 537 // Avoid unnecessary heap allocations by reusing the same graph. |
514 TaskGraph graph; | 538 TaskGraph graph; |
515 | 539 |
516 timer_.Reset(); | 540 timer_.Reset(); |
517 do { | 541 do { |
518 graph.Reset(); | 542 graph.Reset(); |
519 BuildTileTaskGraph(&graph, raster_tasks); | 543 BuildTileTaskGraph(&graph, raster_tasks); |
520 timer_.NextLap(); | 544 timer_.NextLap(); |
521 } while (!timer_.HasTimeLimitExpired()); | 545 } while (!timer_.HasTimeLimitExpired()); |
522 | 546 |
| 547 CancelRasterTasks(raster_tasks); |
| 548 |
523 perf_test::PrintResult("build_raster_task_graph", "", test_name, | 549 perf_test::PrintResult("build_raster_task_graph", "", test_name, |
524 timer_.LapsPerSecond(), "runs/s", true); | 550 timer_.LapsPerSecond(), "runs/s", true); |
525 } | 551 } |
526 }; | 552 }; |
527 | 553 |
528 TEST_F(RasterBufferProviderCommonPerfTest, BuildTileTaskGraph) { | 554 TEST_F(RasterBufferProviderCommonPerfTest, BuildTileTaskGraph) { |
529 RunBuildTileTaskGraphTest("1_0", 1, 0); | 555 RunBuildTileTaskGraphTest("1_0", 1, 0); |
530 RunBuildTileTaskGraphTest("32_0", 32, 0); | 556 RunBuildTileTaskGraphTest("32_0", 32, 0); |
531 RunBuildTileTaskGraphTest("1_1", 1, 1); | 557 RunBuildTileTaskGraphTest("1_1", 1, 1); |
532 RunBuildTileTaskGraphTest("32_1", 32, 1); | 558 RunBuildTileTaskGraphTest("32_1", 32, 1); |
533 RunBuildTileTaskGraphTest("1_4", 1, 4); | 559 RunBuildTileTaskGraphTest("1_4", 1, 4); |
534 RunBuildTileTaskGraphTest("32_4", 32, 4); | 560 RunBuildTileTaskGraphTest("32_4", 32, 4); |
535 } | 561 } |
536 | 562 |
537 } // namespace | 563 } // namespace |
538 } // namespace cc | 564 } // namespace cc |
OLD | NEW |