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 118 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
129 // Overridden from Task: | 129 // Overridden from Task: |
130 void RunOnWorkerThread() override {} | 130 void RunOnWorkerThread() override {} |
131 | 131 |
132 // Overridden from TileTask: | 132 // Overridden from TileTask: |
133 void ScheduleOnOriginThread(RasterBufferProvider* provider) override {} | 133 void ScheduleOnOriginThread(RasterBufferProvider* provider) override {} |
134 void CompleteOnOriginThread(RasterBufferProvider* provider) override { | 134 void CompleteOnOriginThread(RasterBufferProvider* provider) override { |
135 Reset(); | 135 Reset(); |
136 } | 136 } |
137 | 137 |
138 void Reset() { | 138 void Reset() { |
139 did_run_ = false; | 139 state().Reset(); |
140 did_complete_ = false; | 140 did_complete_ = false; |
141 } | 141 } |
142 | 142 |
143 protected: | 143 protected: |
144 ~PerfImageDecodeTaskImpl() override {} | 144 ~PerfImageDecodeTaskImpl() override {} |
145 | 145 |
146 private: | 146 private: |
147 DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl); | 147 DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl); |
148 }; | 148 }; |
149 | 149 |
(...skipping 10 matching lines...) Expand all Loading... |
160 void ScheduleOnOriginThread(RasterBufferProvider* provider) override { | 160 void ScheduleOnOriginThread(RasterBufferProvider* provider) override { |
161 // No tile ids are given to support partial updates. | 161 // No tile ids are given to support partial updates. |
162 raster_buffer_ = provider->AcquireBufferForRaster(resource_.get(), 0, 0); | 162 raster_buffer_ = provider->AcquireBufferForRaster(resource_.get(), 0, 0); |
163 } | 163 } |
164 void CompleteOnOriginThread(RasterBufferProvider* provider) override { | 164 void CompleteOnOriginThread(RasterBufferProvider* provider) override { |
165 provider->ReleaseBufferForRaster(std::move(raster_buffer_)); | 165 provider->ReleaseBufferForRaster(std::move(raster_buffer_)); |
166 Reset(); | 166 Reset(); |
167 } | 167 } |
168 | 168 |
169 void Reset() { | 169 void Reset() { |
170 did_run_ = false; | 170 state().Reset(); |
171 did_complete_ = false; | 171 did_complete_ = false; |
172 } | 172 } |
173 | 173 |
174 protected: | 174 protected: |
175 ~PerfRasterTaskImpl() override {} | 175 ~PerfRasterTaskImpl() override {} |
176 | 176 |
177 private: | 177 private: |
178 std::unique_ptr<ScopedResource> resource_; | 178 std::unique_ptr<ScopedResource> resource_; |
179 std::unique_ptr<RasterBuffer> raster_buffer_; | 179 std::unique_ptr<RasterBuffer> raster_buffer_; |
180 | 180 |
(...skipping 14 matching lines...) Expand all Loading... |
195 base::TimeDelta::FromMilliseconds(kTimeLimitMillis), | 195 base::TimeDelta::FromMilliseconds(kTimeLimitMillis), |
196 kTimeCheckInterval) {} | 196 kTimeCheckInterval) {} |
197 | 197 |
198 void CreateImageDecodeTasks(unsigned num_image_decode_tasks, | 198 void CreateImageDecodeTasks(unsigned num_image_decode_tasks, |
199 TileTask::Vector* image_decode_tasks) { | 199 TileTask::Vector* image_decode_tasks) { |
200 for (unsigned i = 0; i < num_image_decode_tasks; ++i) | 200 for (unsigned i = 0; i < num_image_decode_tasks; ++i) |
201 image_decode_tasks->push_back(new PerfImageDecodeTaskImpl); | 201 image_decode_tasks->push_back(new PerfImageDecodeTaskImpl); |
202 } | 202 } |
203 | 203 |
204 void CreateRasterTasks(unsigned num_raster_tasks, | 204 void CreateRasterTasks(unsigned num_raster_tasks, |
205 const TileTask::Vector& image_decode_tasks, | 205 unsigned num_image_decode_tasks, |
206 RasterTaskVector* raster_tasks) { | 206 RasterTaskVector* raster_tasks) { |
207 const gfx::Size size(1, 1); | 207 const gfx::Size size(1, 1); |
208 | 208 |
209 for (unsigned i = 0; i < num_raster_tasks; ++i) { | 209 for (unsigned i = 0; i < num_raster_tasks; ++i) { |
| 210 TileTask::Vector image_decode_tasks; |
| 211 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); |
210 std::unique_ptr<ScopedResource> resource( | 212 std::unique_ptr<ScopedResource> resource( |
211 ScopedResource::Create(resource_provider_.get())); | 213 ScopedResource::Create(resource_provider_.get())); |
212 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 214 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
213 RGBA_8888); | 215 RGBA_8888); |
214 | 216 |
215 TileTask::Vector dependencies = image_decode_tasks; | |
216 raster_tasks->push_back( | 217 raster_tasks->push_back( |
217 new PerfRasterTaskImpl(std::move(resource), &dependencies)); | 218 new PerfRasterTaskImpl(std::move(resource), &image_decode_tasks)); |
218 } | 219 } |
219 } | 220 } |
220 | 221 |
221 void BuildTileTaskGraph(TaskGraph* graph, | 222 void BuildTileTaskGraph(TaskGraph* graph, |
222 const RasterTaskVector& raster_tasks) { | 223 const RasterTaskVector& raster_tasks) { |
223 uint16_t priority = 0; | 224 uint16_t priority = 0; |
224 | 225 |
225 for (auto& raster_task : raster_tasks) { | 226 for (auto& raster_task : raster_tasks) { |
226 priority++; | 227 priority++; |
227 | 228 |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
292 } | 293 } |
293 | 294 |
294 void RunMessageLoopUntilAllTasksHaveCompleted() { | 295 void RunMessageLoopUntilAllTasksHaveCompleted() { |
295 task_graph_runner_->RunUntilIdle(); | 296 task_graph_runner_->RunUntilIdle(); |
296 task_runner_->RunUntilIdle(); | 297 task_runner_->RunUntilIdle(); |
297 } | 298 } |
298 | 299 |
299 void RunScheduleTasksTest(const std::string& test_name, | 300 void RunScheduleTasksTest(const std::string& test_name, |
300 unsigned num_raster_tasks, | 301 unsigned num_raster_tasks, |
301 unsigned num_image_decode_tasks) { | 302 unsigned num_image_decode_tasks) { |
302 TileTask::Vector image_decode_tasks; | |
303 RasterTaskVector raster_tasks; | 303 RasterTaskVector raster_tasks; |
304 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | 304 CreateRasterTasks(num_raster_tasks, num_image_decode_tasks, &raster_tasks); |
305 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); | |
306 | 305 |
307 // Avoid unnecessary heap allocations by reusing the same graph. | 306 // Avoid unnecessary heap allocations by reusing the same graph. |
308 TaskGraph graph; | 307 TaskGraph graph; |
309 | 308 |
310 timer_.Reset(); | 309 timer_.Reset(); |
311 do { | 310 do { |
312 graph.Reset(); | 311 graph.Reset(); |
313 BuildTileTaskGraph(&graph, raster_tasks); | 312 BuildTileTaskGraph(&graph, raster_tasks); |
314 tile_task_worker_pool_->ScheduleTasks(&graph); | 313 tile_task_worker_pool_->ScheduleTasks(&graph); |
315 tile_task_worker_pool_->CheckForCompletedTasks(); | 314 tile_task_worker_pool_->CheckForCompletedTasks(); |
316 timer_.NextLap(); | 315 timer_.NextLap(); |
317 } while (!timer_.HasTimeLimitExpired()); | 316 } while (!timer_.HasTimeLimitExpired()); |
318 | 317 |
319 TaskGraph empty; | 318 TaskGraph empty; |
320 tile_task_worker_pool_->ScheduleTasks(&empty); | 319 tile_task_worker_pool_->ScheduleTasks(&empty); |
321 RunMessageLoopUntilAllTasksHaveCompleted(); | 320 RunMessageLoopUntilAllTasksHaveCompleted(); |
322 | 321 |
323 perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name, | 322 perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name, |
324 timer_.LapsPerSecond(), "runs/s", true); | 323 timer_.LapsPerSecond(), "runs/s", true); |
325 } | 324 } |
326 | 325 |
327 void RunScheduleAlternateTasksTest(const std::string& test_name, | 326 void RunScheduleAlternateTasksTest(const std::string& test_name, |
328 unsigned num_raster_tasks, | 327 unsigned num_raster_tasks, |
329 unsigned num_image_decode_tasks) { | 328 unsigned num_image_decode_tasks) { |
330 const size_t kNumVersions = 2; | 329 const size_t kNumVersions = 2; |
331 TileTask::Vector image_decode_tasks[kNumVersions]; | |
332 RasterTaskVector raster_tasks[kNumVersions]; | 330 RasterTaskVector raster_tasks[kNumVersions]; |
333 for (size_t i = 0; i < kNumVersions; ++i) { | 331 for (size_t i = 0; i < kNumVersions; ++i) { |
334 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]); | 332 CreateRasterTasks(num_raster_tasks, num_image_decode_tasks, |
335 CreateRasterTasks(num_raster_tasks, image_decode_tasks[i], | |
336 &raster_tasks[i]); | 333 &raster_tasks[i]); |
337 } | 334 } |
338 | 335 |
339 // Avoid unnecessary heap allocations by reusing the same graph. | 336 // Avoid unnecessary heap allocations by reusing the same graph. |
340 TaskGraph graph; | 337 TaskGraph graph; |
341 | 338 |
342 size_t count = 0; | 339 size_t count = 0; |
343 timer_.Reset(); | 340 timer_.Reset(); |
344 do { | 341 do { |
345 graph.Reset(); | 342 graph.Reset(); |
346 BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]); | 343 BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]); |
347 tile_task_worker_pool_->ScheduleTasks(&graph); | 344 tile_task_worker_pool_->ScheduleTasks(&graph); |
348 tile_task_worker_pool_->CheckForCompletedTasks(); | 345 tile_task_worker_pool_->CheckForCompletedTasks(); |
349 ++count; | 346 ++count; |
350 timer_.NextLap(); | 347 timer_.NextLap(); |
351 } while (!timer_.HasTimeLimitExpired()); | 348 } while (!timer_.HasTimeLimitExpired()); |
352 | 349 |
353 TaskGraph empty; | 350 TaskGraph empty; |
354 tile_task_worker_pool_->ScheduleTasks(&empty); | 351 tile_task_worker_pool_->ScheduleTasks(&empty); |
355 RunMessageLoopUntilAllTasksHaveCompleted(); | 352 RunMessageLoopUntilAllTasksHaveCompleted(); |
356 | 353 |
357 perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(), | 354 perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(), |
358 test_name, timer_.LapsPerSecond(), "runs/s", true); | 355 test_name, timer_.LapsPerSecond(), "runs/s", true); |
359 } | 356 } |
360 | 357 |
361 void RunScheduleAndExecuteTasksTest(const std::string& test_name, | 358 void RunScheduleAndExecuteTasksTest(const std::string& test_name, |
362 unsigned num_raster_tasks, | 359 unsigned num_raster_tasks, |
363 unsigned num_image_decode_tasks) { | 360 unsigned num_image_decode_tasks) { |
364 TileTask::Vector image_decode_tasks; | |
365 RasterTaskVector raster_tasks; | 361 RasterTaskVector raster_tasks; |
366 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | 362 CreateRasterTasks(num_raster_tasks, num_image_decode_tasks, &raster_tasks); |
367 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); | |
368 | 363 |
369 // Avoid unnecessary heap allocations by reusing the same graph. | 364 // Avoid unnecessary heap allocations by reusing the same graph. |
370 TaskGraph graph; | 365 TaskGraph graph; |
371 | 366 |
372 timer_.Reset(); | 367 timer_.Reset(); |
373 do { | 368 do { |
374 graph.Reset(); | 369 graph.Reset(); |
375 BuildTileTaskGraph(&graph, raster_tasks); | 370 BuildTileTaskGraph(&graph, raster_tasks); |
376 tile_task_worker_pool_->ScheduleTasks(&graph); | 371 tile_task_worker_pool_->ScheduleTasks(&graph); |
377 RunMessageLoopUntilAllTasksHaveCompleted(); | 372 RunMessageLoopUntilAllTasksHaveCompleted(); |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
463 void SetUp() override { | 458 void SetUp() override { |
464 output_surface_ = FakeOutputSurface::Create3d(context_provider_); | 459 output_surface_ = FakeOutputSurface::Create3d(context_provider_); |
465 CHECK(output_surface_->BindToClient(&output_surface_client_)); | 460 CHECK(output_surface_->BindToClient(&output_surface_client_)); |
466 resource_provider_ = | 461 resource_provider_ = |
467 FakeResourceProvider::Create(output_surface_.get(), nullptr); | 462 FakeResourceProvider::Create(output_surface_.get(), nullptr); |
468 } | 463 } |
469 | 464 |
470 void RunBuildTileTaskGraphTest(const std::string& test_name, | 465 void RunBuildTileTaskGraphTest(const std::string& test_name, |
471 unsigned num_raster_tasks, | 466 unsigned num_raster_tasks, |
472 unsigned num_image_decode_tasks) { | 467 unsigned num_image_decode_tasks) { |
473 TileTask::Vector image_decode_tasks; | |
474 RasterTaskVector raster_tasks; | 468 RasterTaskVector raster_tasks; |
475 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | 469 CreateRasterTasks(num_raster_tasks, num_image_decode_tasks, &raster_tasks); |
476 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); | |
477 | 470 |
478 // Avoid unnecessary heap allocations by reusing the same graph. | 471 // Avoid unnecessary heap allocations by reusing the same graph. |
479 TaskGraph graph; | 472 TaskGraph graph; |
480 | 473 |
481 timer_.Reset(); | 474 timer_.Reset(); |
482 do { | 475 do { |
483 graph.Reset(); | 476 graph.Reset(); |
484 BuildTileTaskGraph(&graph, raster_tasks); | 477 BuildTileTaskGraph(&graph, raster_tasks); |
485 timer_.NextLap(); | 478 timer_.NextLap(); |
486 } while (!timer_.HasTimeLimitExpired()); | 479 } while (!timer_.HasTimeLimitExpired()); |
487 | 480 |
488 perf_test::PrintResult("build_raster_task_graph", "", test_name, | 481 perf_test::PrintResult("build_raster_task_graph", "", test_name, |
489 timer_.LapsPerSecond(), "runs/s", true); | 482 timer_.LapsPerSecond(), "runs/s", true); |
490 } | 483 } |
491 }; | 484 }; |
492 | 485 |
493 TEST_F(TileTaskWorkerPoolCommonPerfTest, BuildTileTaskGraph) { | 486 TEST_F(TileTaskWorkerPoolCommonPerfTest, BuildTileTaskGraph) { |
494 RunBuildTileTaskGraphTest("1_0", 1, 0); | 487 RunBuildTileTaskGraphTest("1_0", 1, 0); |
495 RunBuildTileTaskGraphTest("32_0", 32, 0); | 488 RunBuildTileTaskGraphTest("32_0", 32, 0); |
496 RunBuildTileTaskGraphTest("1_1", 1, 1); | 489 RunBuildTileTaskGraphTest("1_1", 1, 1); |
497 RunBuildTileTaskGraphTest("32_1", 32, 1); | 490 RunBuildTileTaskGraphTest("32_1", 32, 1); |
498 RunBuildTileTaskGraphTest("1_4", 1, 4); | 491 RunBuildTileTaskGraphTest("1_4", 1, 4); |
499 RunBuildTileTaskGraphTest("32_4", 32, 4); | 492 RunBuildTileTaskGraphTest("32_4", 32, 4); |
500 } | 493 } |
501 | 494 |
502 } // namespace | 495 } // namespace |
503 } // namespace cc | 496 } // namespace cc |
OLD | NEW |