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 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
116 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | 116 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, |
117 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | 117 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, |
118 TILE_TASK_WORKER_POOL_TYPE_GPU, | 118 TILE_TASK_WORKER_POOL_TYPE_GPU, |
119 TILE_TASK_WORKER_POOL_TYPE_BITMAP | 119 TILE_TASK_WORKER_POOL_TYPE_BITMAP |
120 }; | 120 }; |
121 | 121 |
122 static const int kTimeLimitMillis = 2000; | 122 static const int kTimeLimitMillis = 2000; |
123 static const int kWarmupRuns = 5; | 123 static const int kWarmupRuns = 5; |
124 static const int kTimeCheckInterval = 10; | 124 static const int kTimeCheckInterval = 10; |
125 | 125 |
126 class PerfImageDecodeTaskImpl : public ImageDecodeTask { | 126 class PerfImageDecodeTaskImpl : public TileTask { |
127 public: | 127 public: |
128 PerfImageDecodeTaskImpl() {} | 128 PerfImageDecodeTaskImpl() : TileTask(true) {} |
129 | 129 |
130 // Overridden from Task: | 130 // Overridden from Task: |
131 void RunOnWorkerThread() override {} | 131 void RunOnWorkerThread() override {} |
132 | 132 |
133 // Overridden from TileTask: | 133 // Overridden from TileTask: |
134 void ScheduleOnOriginThread(RasterBufferProvider* provider) override {} | 134 void ScheduleOnOriginThread(RasterBufferProvider* provider) override {} |
135 void CompleteOnOriginThread(RasterBufferProvider* provider) override { | 135 void CompleteOnOriginThread(RasterBufferProvider* provider) override { |
136 Reset(); | 136 Reset(); |
137 } | 137 } |
138 | 138 |
139 void Reset() { | 139 void Reset() { |
140 did_run_ = false; | 140 did_run_ = false; |
141 did_complete_ = false; | 141 did_complete_ = false; |
142 } | 142 } |
143 | 143 |
144 protected: | 144 protected: |
145 ~PerfImageDecodeTaskImpl() override {} | 145 ~PerfImageDecodeTaskImpl() override {} |
146 | 146 |
147 private: | 147 private: |
148 DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl); | 148 DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl); |
149 }; | 149 }; |
150 | 150 |
151 class PerfRasterTaskImpl : public RasterTask { | 151 class PerfRasterTaskImpl : public TileTask { |
152 public: | 152 public: |
153 PerfRasterTaskImpl(std::unique_ptr<ScopedResource> resource, | 153 PerfRasterTaskImpl(std::unique_ptr<ScopedResource> resource, |
154 ImageDecodeTask::Vector* dependencies) | 154 TileTask::Vector* dependencies) |
155 : RasterTask(dependencies), resource_(std::move(resource)) {} | 155 : TileTask(true, dependencies), resource_(std::move(resource)) {} |
156 | 156 |
157 // Overridden from Task: | 157 // Overridden from Task: |
158 void RunOnWorkerThread() override {} | 158 void RunOnWorkerThread() override {} |
159 | 159 |
160 // Overridden from TileTask: | 160 // Overridden from TileTask: |
161 void ScheduleOnOriginThread(RasterBufferProvider* provider) override { | 161 void ScheduleOnOriginThread(RasterBufferProvider* provider) override { |
162 // No tile ids are given to support partial updates. | 162 // No tile ids are given to support partial updates. |
163 raster_buffer_ = provider->AcquireBufferForRaster(resource_.get(), 0, 0); | 163 raster_buffer_ = provider->AcquireBufferForRaster(resource_.get(), 0, 0); |
164 } | 164 } |
165 void CompleteOnOriginThread(RasterBufferProvider* provider) override { | 165 void CompleteOnOriginThread(RasterBufferProvider* provider) override { |
(...skipping 11 matching lines...) Expand all Loading... |
177 | 177 |
178 private: | 178 private: |
179 std::unique_ptr<ScopedResource> resource_; | 179 std::unique_ptr<ScopedResource> resource_; |
180 std::unique_ptr<RasterBuffer> raster_buffer_; | 180 std::unique_ptr<RasterBuffer> raster_buffer_; |
181 | 181 |
182 DISALLOW_COPY_AND_ASSIGN(PerfRasterTaskImpl); | 182 DISALLOW_COPY_AND_ASSIGN(PerfRasterTaskImpl); |
183 }; | 183 }; |
184 | 184 |
185 class TileTaskWorkerPoolPerfTestBase { | 185 class TileTaskWorkerPoolPerfTestBase { |
186 public: | 186 public: |
187 typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector; | 187 typedef std::vector<scoped_refptr<TileTask>> RasterTaskVector; |
188 | 188 |
189 enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL }; | 189 enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL }; |
190 | 190 |
191 TileTaskWorkerPoolPerfTestBase() | 191 TileTaskWorkerPoolPerfTestBase() |
192 : context_provider_(make_scoped_refptr(new PerfContextProvider)), | 192 : context_provider_(make_scoped_refptr(new PerfContextProvider)), |
193 task_runner_(new base::TestSimpleTaskRunner), | 193 task_runner_(new base::TestSimpleTaskRunner), |
194 task_graph_runner_(new SynchronousTaskGraphRunner), | 194 task_graph_runner_(new SynchronousTaskGraphRunner), |
195 timer_(kWarmupRuns, | 195 timer_(kWarmupRuns, |
196 base::TimeDelta::FromMilliseconds(kTimeLimitMillis), | 196 base::TimeDelta::FromMilliseconds(kTimeLimitMillis), |
197 kTimeCheckInterval) {} | 197 kTimeCheckInterval) {} |
198 | 198 |
199 void CreateImageDecodeTasks(unsigned num_image_decode_tasks, | 199 void CreateImageDecodeTasks(unsigned num_image_decode_tasks, |
200 ImageDecodeTask::Vector* image_decode_tasks) { | 200 TileTask::Vector* image_decode_tasks) { |
201 for (unsigned i = 0; i < num_image_decode_tasks; ++i) | 201 for (unsigned i = 0; i < num_image_decode_tasks; ++i) |
202 image_decode_tasks->push_back(new PerfImageDecodeTaskImpl); | 202 image_decode_tasks->push_back(new PerfImageDecodeTaskImpl); |
203 } | 203 } |
204 | 204 |
205 void CreateRasterTasks(unsigned num_raster_tasks, | 205 void CreateRasterTasks(unsigned num_raster_tasks, |
206 const ImageDecodeTask::Vector& image_decode_tasks, | 206 const TileTask::Vector& image_decode_tasks, |
207 RasterTaskVector* raster_tasks) { | 207 RasterTaskVector* raster_tasks) { |
208 const gfx::Size size(1, 1); | 208 const gfx::Size size(1, 1); |
209 | 209 |
210 for (unsigned i = 0; i < num_raster_tasks; ++i) { | 210 for (unsigned i = 0; i < num_raster_tasks; ++i) { |
211 std::unique_ptr<ScopedResource> resource( | 211 std::unique_ptr<ScopedResource> resource( |
212 ScopedResource::Create(resource_provider_.get())); | 212 ScopedResource::Create(resource_provider_.get())); |
213 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 213 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
214 RGBA_8888); | 214 RGBA_8888); |
215 | 215 |
216 ImageDecodeTask::Vector dependencies = image_decode_tasks; | 216 TileTask::Vector dependencies = image_decode_tasks; |
217 raster_tasks->push_back( | 217 raster_tasks->push_back( |
218 new PerfRasterTaskImpl(std::move(resource), &dependencies)); | 218 new PerfRasterTaskImpl(std::move(resource), &dependencies)); |
219 } | 219 } |
220 } | 220 } |
221 | 221 |
222 void BuildTileTaskGraph(TaskGraph* graph, | 222 void BuildTileTaskGraph(TaskGraph* graph, |
223 const RasterTaskVector& raster_tasks) { | 223 const RasterTaskVector& raster_tasks) { |
224 uint16_t priority = 0; | 224 uint16_t priority = 0; |
225 | 225 |
226 for (auto& raster_task : raster_tasks) { | 226 for (auto& raster_task : raster_tasks) { |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
293 } | 293 } |
294 | 294 |
295 void RunMessageLoopUntilAllTasksHaveCompleted() { | 295 void RunMessageLoopUntilAllTasksHaveCompleted() { |
296 task_graph_runner_->RunUntilIdle(); | 296 task_graph_runner_->RunUntilIdle(); |
297 task_runner_->RunUntilIdle(); | 297 task_runner_->RunUntilIdle(); |
298 } | 298 } |
299 | 299 |
300 void RunScheduleTasksTest(const std::string& test_name, | 300 void RunScheduleTasksTest(const std::string& test_name, |
301 unsigned num_raster_tasks, | 301 unsigned num_raster_tasks, |
302 unsigned num_image_decode_tasks) { | 302 unsigned num_image_decode_tasks) { |
303 ImageDecodeTask::Vector image_decode_tasks; | 303 TileTask::Vector image_decode_tasks; |
304 RasterTaskVector raster_tasks; | 304 RasterTaskVector raster_tasks; |
305 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | 305 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); |
306 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); | 306 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); |
307 | 307 |
308 // Avoid unnecessary heap allocations by reusing the same graph. | 308 // Avoid unnecessary heap allocations by reusing the same graph. |
309 TaskGraph graph; | 309 TaskGraph graph; |
310 | 310 |
311 timer_.Reset(); | 311 timer_.Reset(); |
312 do { | 312 do { |
313 graph.Reset(); | 313 graph.Reset(); |
314 BuildTileTaskGraph(&graph, raster_tasks); | 314 BuildTileTaskGraph(&graph, raster_tasks); |
315 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph); | 315 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph); |
316 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); | 316 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); |
317 timer_.NextLap(); | 317 timer_.NextLap(); |
318 } while (!timer_.HasTimeLimitExpired()); | 318 } while (!timer_.HasTimeLimitExpired()); |
319 | 319 |
320 TaskGraph empty; | 320 TaskGraph empty; |
321 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty); | 321 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty); |
322 RunMessageLoopUntilAllTasksHaveCompleted(); | 322 RunMessageLoopUntilAllTasksHaveCompleted(); |
323 | 323 |
324 perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name, | 324 perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name, |
325 timer_.LapsPerSecond(), "runs/s", true); | 325 timer_.LapsPerSecond(), "runs/s", true); |
326 } | 326 } |
327 | 327 |
328 void RunScheduleAlternateTasksTest(const std::string& test_name, | 328 void RunScheduleAlternateTasksTest(const std::string& test_name, |
329 unsigned num_raster_tasks, | 329 unsigned num_raster_tasks, |
330 unsigned num_image_decode_tasks) { | 330 unsigned num_image_decode_tasks) { |
331 const size_t kNumVersions = 2; | 331 const size_t kNumVersions = 2; |
332 ImageDecodeTask::Vector image_decode_tasks[kNumVersions]; | 332 TileTask::Vector image_decode_tasks[kNumVersions]; |
333 RasterTaskVector raster_tasks[kNumVersions]; | 333 RasterTaskVector raster_tasks[kNumVersions]; |
334 for (size_t i = 0; i < kNumVersions; ++i) { | 334 for (size_t i = 0; i < kNumVersions; ++i) { |
335 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]); | 335 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]); |
336 CreateRasterTasks(num_raster_tasks, image_decode_tasks[i], | 336 CreateRasterTasks(num_raster_tasks, image_decode_tasks[i], |
337 &raster_tasks[i]); | 337 &raster_tasks[i]); |
338 } | 338 } |
339 | 339 |
340 // Avoid unnecessary heap allocations by reusing the same graph. | 340 // Avoid unnecessary heap allocations by reusing the same graph. |
341 TaskGraph graph; | 341 TaskGraph graph; |
342 | 342 |
(...skipping 12 matching lines...) Expand all Loading... |
355 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty); | 355 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty); |
356 RunMessageLoopUntilAllTasksHaveCompleted(); | 356 RunMessageLoopUntilAllTasksHaveCompleted(); |
357 | 357 |
358 perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(), | 358 perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(), |
359 test_name, timer_.LapsPerSecond(), "runs/s", true); | 359 test_name, timer_.LapsPerSecond(), "runs/s", true); |
360 } | 360 } |
361 | 361 |
362 void RunScheduleAndExecuteTasksTest(const std::string& test_name, | 362 void RunScheduleAndExecuteTasksTest(const std::string& test_name, |
363 unsigned num_raster_tasks, | 363 unsigned num_raster_tasks, |
364 unsigned num_image_decode_tasks) { | 364 unsigned num_image_decode_tasks) { |
365 ImageDecodeTask::Vector image_decode_tasks; | 365 TileTask::Vector image_decode_tasks; |
366 RasterTaskVector raster_tasks; | 366 RasterTaskVector raster_tasks; |
367 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | 367 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); |
368 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); | 368 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); |
369 | 369 |
370 // Avoid unnecessary heap allocations by reusing the same graph. | 370 // Avoid unnecessary heap allocations by reusing the same graph. |
371 TaskGraph graph; | 371 TaskGraph graph; |
372 | 372 |
373 timer_.Reset(); | 373 timer_.Reset(); |
374 do { | 374 do { |
375 graph.Reset(); | 375 graph.Reset(); |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
464 void SetUp() override { | 464 void SetUp() override { |
465 output_surface_ = FakeOutputSurface::Create3d(context_provider_); | 465 output_surface_ = FakeOutputSurface::Create3d(context_provider_); |
466 CHECK(output_surface_->BindToClient(&output_surface_client_)); | 466 CHECK(output_surface_->BindToClient(&output_surface_client_)); |
467 resource_provider_ = | 467 resource_provider_ = |
468 FakeResourceProvider::Create(output_surface_.get(), nullptr); | 468 FakeResourceProvider::Create(output_surface_.get(), nullptr); |
469 } | 469 } |
470 | 470 |
471 void RunBuildTileTaskGraphTest(const std::string& test_name, | 471 void RunBuildTileTaskGraphTest(const std::string& test_name, |
472 unsigned num_raster_tasks, | 472 unsigned num_raster_tasks, |
473 unsigned num_image_decode_tasks) { | 473 unsigned num_image_decode_tasks) { |
474 ImageDecodeTask::Vector image_decode_tasks; | 474 TileTask::Vector image_decode_tasks; |
475 RasterTaskVector raster_tasks; | 475 RasterTaskVector raster_tasks; |
476 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | 476 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); |
477 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); | 477 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); |
478 | 478 |
479 // Avoid unnecessary heap allocations by reusing the same graph. | 479 // Avoid unnecessary heap allocations by reusing the same graph. |
480 TaskGraph graph; | 480 TaskGraph graph; |
481 | 481 |
482 timer_.Reset(); | 482 timer_.Reset(); |
483 do { | 483 do { |
484 graph.Reset(); | 484 graph.Reset(); |
(...skipping 10 matching lines...) Expand all Loading... |
495 RunBuildTileTaskGraphTest("1_0", 1, 0); | 495 RunBuildTileTaskGraphTest("1_0", 1, 0); |
496 RunBuildTileTaskGraphTest("32_0", 32, 0); | 496 RunBuildTileTaskGraphTest("32_0", 32, 0); |
497 RunBuildTileTaskGraphTest("1_1", 1, 1); | 497 RunBuildTileTaskGraphTest("1_1", 1, 1); |
498 RunBuildTileTaskGraphTest("32_1", 32, 1); | 498 RunBuildTileTaskGraphTest("32_1", 32, 1); |
499 RunBuildTileTaskGraphTest("1_4", 1, 4); | 499 RunBuildTileTaskGraphTest("1_4", 1, 4); |
500 RunBuildTileTaskGraphTest("32_4", 32, 4); | 500 RunBuildTileTaskGraphTest("32_4", 32, 4); |
501 } | 501 } |
502 | 502 |
503 } // namespace | 503 } // namespace |
504 } // namespace cc | 504 } // namespace cc |
OLD | NEW |