| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "cc/resources/tile_task_worker_pool.h" | |
| 6 | |
| 7 #include "base/test/test_simple_task_runner.h" | |
| 8 #include "base/time/time.h" | |
| 9 #include "cc/debug/lap_timer.h" | |
| 10 #include "cc/output/context_provider.h" | |
| 11 #include "cc/resources/bitmap_tile_task_worker_pool.h" | |
| 12 #include "cc/resources/gpu_rasterizer.h" | |
| 13 #include "cc/resources/gpu_tile_task_worker_pool.h" | |
| 14 #include "cc/resources/one_copy_tile_task_worker_pool.h" | |
| 15 #include "cc/resources/pixel_buffer_tile_task_worker_pool.h" | |
| 16 #include "cc/resources/raster_buffer.h" | |
| 17 #include "cc/resources/resource_pool.h" | |
| 18 #include "cc/resources/resource_provider.h" | |
| 19 #include "cc/resources/scoped_resource.h" | |
| 20 #include "cc/resources/tile_task_runner.h" | |
| 21 #include "cc/resources/zero_copy_tile_task_worker_pool.h" | |
| 22 #include "cc/test/fake_output_surface.h" | |
| 23 #include "cc/test/fake_output_surface_client.h" | |
| 24 #include "cc/test/test_context_support.h" | |
| 25 #include "cc/test/test_gpu_memory_buffer_manager.h" | |
| 26 #include "cc/test/test_shared_bitmap_manager.h" | |
| 27 #include "cc/test/test_web_graphics_context_3d.h" | |
| 28 #include "testing/gtest/include/gtest/gtest.h" | |
| 29 #include "testing/perf/perf_test.h" | |
| 30 #include "third_party/khronos/GLES2/gl2.h" | |
| 31 #include "third_party/skia/include/gpu/GrContext.h" | |
| 32 #include "third_party/skia/include/gpu/gl/GrGLInterface.h" | |
| 33 | |
| 34 namespace cc { | |
| 35 namespace { | |
| 36 | |
| 37 class PerfGLES2Interface : public gpu::gles2::GLES2InterfaceStub { | |
| 38 // Overridden from gpu::gles2::GLES2Interface: | |
| 39 GLuint CreateImageCHROMIUM(ClientBuffer buffer, | |
| 40 GLsizei width, | |
| 41 GLsizei height, | |
| 42 GLenum internalformat) override { | |
| 43 return 1u; | |
| 44 } | |
| 45 void GenBuffers(GLsizei n, GLuint* buffers) override { | |
| 46 for (GLsizei i = 0; i < n; ++i) | |
| 47 buffers[i] = 1u; | |
| 48 } | |
| 49 void GenTextures(GLsizei n, GLuint* textures) override { | |
| 50 for (GLsizei i = 0; i < n; ++i) | |
| 51 textures[i] = 1u; | |
| 52 } | |
| 53 void GetIntegerv(GLenum pname, GLint* params) override { | |
| 54 if (pname == GL_MAX_TEXTURE_SIZE) | |
| 55 *params = INT_MAX; | |
| 56 } | |
| 57 void GenQueriesEXT(GLsizei n, GLuint* queries) override { | |
| 58 for (GLsizei i = 0; i < n; ++i) | |
| 59 queries[i] = 1u; | |
| 60 } | |
| 61 void GetQueryObjectuivEXT(GLuint query, | |
| 62 GLenum pname, | |
| 63 GLuint* params) override { | |
| 64 if (pname == GL_QUERY_RESULT_AVAILABLE_EXT) | |
| 65 *params = 1; | |
| 66 } | |
| 67 }; | |
| 68 | |
| 69 class PerfContextProvider : public ContextProvider { | |
| 70 public: | |
| 71 PerfContextProvider() : context_gl_(new PerfGLES2Interface) {} | |
| 72 | |
| 73 bool BindToCurrentThread() override { return true; } | |
| 74 Capabilities ContextCapabilities() override { | |
| 75 Capabilities capabilities; | |
| 76 capabilities.gpu.image = true; | |
| 77 capabilities.gpu.sync_query = true; | |
| 78 return capabilities; | |
| 79 } | |
| 80 gpu::gles2::GLES2Interface* ContextGL() override { return context_gl_.get(); } | |
| 81 gpu::ContextSupport* ContextSupport() override { return &support_; } | |
| 82 class GrContext* GrContext() override { | |
| 83 if (gr_context_) | |
| 84 return gr_context_.get(); | |
| 85 | |
| 86 skia::RefPtr<const GrGLInterface> null_interface = | |
| 87 skia::AdoptRef(GrGLCreateNullInterface()); | |
| 88 gr_context_ = skia::AdoptRef(GrContext::Create( | |
| 89 kOpenGL_GrBackend, | |
| 90 reinterpret_cast<GrBackendContext>(null_interface.get()))); | |
| 91 return gr_context_.get(); | |
| 92 } | |
| 93 void SetupLock() override {} | |
| 94 base::Lock* GetLock() override { return &context_lock_; } | |
| 95 bool IsContextLost() override { return false; } | |
| 96 void VerifyContexts() override {} | |
| 97 void DeleteCachedResources() override {} | |
| 98 bool DestroyedOnMainThread() override { return false; } | |
| 99 void SetLostContextCallback(const LostContextCallback& cb) override {} | |
| 100 void SetMemoryPolicyChangedCallback( | |
| 101 const MemoryPolicyChangedCallback& cb) override {} | |
| 102 | |
| 103 private: | |
| 104 ~PerfContextProvider() override {} | |
| 105 | |
| 106 scoped_ptr<PerfGLES2Interface> context_gl_; | |
| 107 skia::RefPtr<class GrContext> gr_context_; | |
| 108 TestContextSupport support_; | |
| 109 base::Lock context_lock_; | |
| 110 }; | |
| 111 | |
| 112 enum TileTaskWorkerPoolType { | |
| 113 TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER, | |
| 114 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | |
| 115 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | |
| 116 TILE_TASK_WORKER_POOL_TYPE_GPU, | |
| 117 TILE_TASK_WORKER_POOL_TYPE_BITMAP | |
| 118 }; | |
| 119 | |
| 120 static const int kTimeLimitMillis = 2000; | |
| 121 static const int kWarmupRuns = 5; | |
| 122 static const int kTimeCheckInterval = 10; | |
| 123 | |
| 124 class PerfImageDecodeTaskImpl : public ImageDecodeTask { | |
| 125 public: | |
| 126 PerfImageDecodeTaskImpl() {} | |
| 127 | |
| 128 // Overridden from Task: | |
| 129 void RunOnWorkerThread() override {} | |
| 130 | |
| 131 // Overridden from TileTask: | |
| 132 void ScheduleOnOriginThread(TileTaskClient* client) override {} | |
| 133 void CompleteOnOriginThread(TileTaskClient* client) override {} | |
| 134 void RunReplyOnOriginThread() override { Reset(); } | |
| 135 | |
| 136 void Reset() { | |
| 137 did_run_ = false; | |
| 138 did_complete_ = false; | |
| 139 } | |
| 140 | |
| 141 protected: | |
| 142 ~PerfImageDecodeTaskImpl() override {} | |
| 143 | |
| 144 private: | |
| 145 DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl); | |
| 146 }; | |
| 147 | |
| 148 class PerfRasterTaskImpl : public RasterTask { | |
| 149 public: | |
| 150 PerfRasterTaskImpl(scoped_ptr<ScopedResource> resource, | |
| 151 ImageDecodeTask::Vector* dependencies) | |
| 152 : RasterTask(resource.get(), dependencies), resource_(resource.Pass()) {} | |
| 153 | |
| 154 // Overridden from Task: | |
| 155 void RunOnWorkerThread() override {} | |
| 156 | |
| 157 // Overridden from TileTask: | |
| 158 void ScheduleOnOriginThread(TileTaskClient* client) override { | |
| 159 raster_buffer_ = client->AcquireBufferForRaster(resource()); | |
| 160 } | |
| 161 void CompleteOnOriginThread(TileTaskClient* client) override { | |
| 162 client->ReleaseBufferForRaster(raster_buffer_.Pass()); | |
| 163 } | |
| 164 void RunReplyOnOriginThread() override { Reset(); } | |
| 165 | |
| 166 void Reset() { | |
| 167 did_run_ = false; | |
| 168 did_complete_ = false; | |
| 169 } | |
| 170 | |
| 171 protected: | |
| 172 ~PerfRasterTaskImpl() override {} | |
| 173 | |
| 174 private: | |
| 175 scoped_ptr<ScopedResource> resource_; | |
| 176 scoped_ptr<RasterBuffer> raster_buffer_; | |
| 177 | |
| 178 DISALLOW_COPY_AND_ASSIGN(PerfRasterTaskImpl); | |
| 179 }; | |
| 180 | |
| 181 class TileTaskWorkerPoolPerfTestBase { | |
| 182 public: | |
| 183 typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector; | |
| 184 | |
| 185 enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL }; | |
| 186 | |
| 187 TileTaskWorkerPoolPerfTestBase() | |
| 188 : context_provider_(make_scoped_refptr(new PerfContextProvider)), | |
| 189 task_runner_(new base::TestSimpleTaskRunner), | |
| 190 task_graph_runner_(new TaskGraphRunner), | |
| 191 timer_(kWarmupRuns, | |
| 192 base::TimeDelta::FromMilliseconds(kTimeLimitMillis), | |
| 193 kTimeCheckInterval) {} | |
| 194 | |
| 195 void CreateImageDecodeTasks(unsigned num_image_decode_tasks, | |
| 196 ImageDecodeTask::Vector* image_decode_tasks) { | |
| 197 for (unsigned i = 0; i < num_image_decode_tasks; ++i) | |
| 198 image_decode_tasks->push_back(new PerfImageDecodeTaskImpl); | |
| 199 } | |
| 200 | |
| 201 void CreateRasterTasks(unsigned num_raster_tasks, | |
| 202 const ImageDecodeTask::Vector& image_decode_tasks, | |
| 203 RasterTaskVector* raster_tasks) { | |
| 204 const gfx::Size size(1, 1); | |
| 205 | |
| 206 for (unsigned i = 0; i < num_raster_tasks; ++i) { | |
| 207 scoped_ptr<ScopedResource> resource( | |
| 208 ScopedResource::Create(resource_provider_.get())); | |
| 209 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | |
| 210 RGBA_8888); | |
| 211 | |
| 212 ImageDecodeTask::Vector dependencies = image_decode_tasks; | |
| 213 raster_tasks->push_back( | |
| 214 new PerfRasterTaskImpl(resource.Pass(), &dependencies)); | |
| 215 } | |
| 216 } | |
| 217 | |
| 218 void BuildTileTaskQueue(TileTaskQueue* queue, | |
| 219 const RasterTaskVector& raster_tasks) { | |
| 220 for (size_t i = 0u; i < raster_tasks.size(); ++i) { | |
| 221 bool required_for_activation = (i % 2) == 0; | |
| 222 TaskSetCollection task_set_collection; | |
| 223 task_set_collection[ALL] = true; | |
| 224 task_set_collection[REQUIRED_FOR_ACTIVATION] = required_for_activation; | |
| 225 queue->items.push_back( | |
| 226 TileTaskQueue::Item(raster_tasks[i].get(), task_set_collection)); | |
| 227 } | |
| 228 } | |
| 229 | |
| 230 protected: | |
| 231 scoped_refptr<ContextProvider> context_provider_; | |
| 232 FakeOutputSurfaceClient output_surface_client_; | |
| 233 scoped_ptr<FakeOutputSurface> output_surface_; | |
| 234 scoped_ptr<ResourceProvider> resource_provider_; | |
| 235 scoped_ptr<Rasterizer> rasterizer_; | |
| 236 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; | |
| 237 scoped_ptr<TaskGraphRunner> task_graph_runner_; | |
| 238 LapTimer timer_; | |
| 239 }; | |
| 240 | |
| 241 class TileTaskWorkerPoolPerfTest | |
| 242 : public TileTaskWorkerPoolPerfTestBase, | |
| 243 public testing::TestWithParam<TileTaskWorkerPoolType>, | |
| 244 public TileTaskRunnerClient { | |
| 245 public: | |
| 246 // Overridden from testing::Test: | |
| 247 void SetUp() override { | |
| 248 switch (GetParam()) { | |
| 249 case TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER: | |
| 250 Create3dOutputSurfaceAndResourceProvider(); | |
| 251 tile_task_worker_pool_ = PixelBufferTileTaskWorkerPool::Create( | |
| 252 task_runner_.get(), task_graph_runner_.get(), | |
| 253 context_provider_.get(), resource_provider_.get(), | |
| 254 std::numeric_limits<size_t>::max()); | |
| 255 break; | |
| 256 case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY: | |
| 257 Create3dOutputSurfaceAndResourceProvider(); | |
| 258 tile_task_worker_pool_ = ZeroCopyTileTaskWorkerPool::Create( | |
| 259 task_runner_.get(), task_graph_runner_.get(), | |
| 260 resource_provider_.get()); | |
| 261 break; | |
| 262 case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY: | |
| 263 Create3dOutputSurfaceAndResourceProvider(); | |
| 264 staging_resource_pool_ = ResourcePool::Create(resource_provider_.get(), | |
| 265 GL_TEXTURE_2D); | |
| 266 tile_task_worker_pool_ = OneCopyTileTaskWorkerPool::Create( | |
| 267 task_runner_.get(), task_graph_runner_.get(), | |
| 268 context_provider_.get(), resource_provider_.get(), | |
| 269 staging_resource_pool_.get()); | |
| 270 break; | |
| 271 case TILE_TASK_WORKER_POOL_TYPE_GPU: | |
| 272 Create3dOutputSurfaceAndResourceProvider(); | |
| 273 rasterizer_ = GpuRasterizer::Create( | |
| 274 context_provider_.get(), resource_provider_.get(), false, false, 0); | |
| 275 tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create( | |
| 276 task_runner_.get(), task_graph_runner_.get(), | |
| 277 static_cast<GpuRasterizer*>(rasterizer_.get())); | |
| 278 break; | |
| 279 case TILE_TASK_WORKER_POOL_TYPE_BITMAP: | |
| 280 CreateSoftwareOutputSurfaceAndResourceProvider(); | |
| 281 tile_task_worker_pool_ = BitmapTileTaskWorkerPool::Create( | |
| 282 task_runner_.get(), task_graph_runner_.get(), | |
| 283 resource_provider_.get()); | |
| 284 break; | |
| 285 } | |
| 286 | |
| 287 DCHECK(tile_task_worker_pool_); | |
| 288 tile_task_worker_pool_->AsTileTaskRunner()->SetClient(this); | |
| 289 } | |
| 290 void TearDown() override { | |
| 291 tile_task_worker_pool_->AsTileTaskRunner()->Shutdown(); | |
| 292 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); | |
| 293 } | |
| 294 | |
| 295 // Overriden from TileTaskRunnerClient: | |
| 296 void DidFinishRunningTileTasks(TaskSet task_set) override { | |
| 297 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); | |
| 298 } | |
| 299 TaskSetCollection TasksThatShouldBeForcedToComplete() const override { | |
| 300 return TaskSetCollection(); | |
| 301 } | |
| 302 | |
| 303 void RunMessageLoopUntilAllTasksHaveCompleted() { | |
| 304 task_graph_runner_->RunUntilIdle(); | |
| 305 task_runner_->RunUntilIdle(); | |
| 306 } | |
| 307 | |
| 308 void RunScheduleTasksTest(const std::string& test_name, | |
| 309 unsigned num_raster_tasks, | |
| 310 unsigned num_image_decode_tasks) { | |
| 311 ImageDecodeTask::Vector image_decode_tasks; | |
| 312 RasterTaskVector raster_tasks; | |
| 313 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | |
| 314 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); | |
| 315 | |
| 316 // Avoid unnecessary heap allocations by reusing the same queue. | |
| 317 TileTaskQueue queue; | |
| 318 | |
| 319 timer_.Reset(); | |
| 320 do { | |
| 321 queue.Reset(); | |
| 322 BuildTileTaskQueue(&queue, raster_tasks); | |
| 323 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&queue); | |
| 324 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); | |
| 325 timer_.NextLap(); | |
| 326 } while (!timer_.HasTimeLimitExpired()); | |
| 327 | |
| 328 TileTaskQueue empty; | |
| 329 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty); | |
| 330 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 331 | |
| 332 perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name, | |
| 333 timer_.LapsPerSecond(), "runs/s", true); | |
| 334 } | |
| 335 | |
| 336 void RunScheduleAlternateTasksTest(const std::string& test_name, | |
| 337 unsigned num_raster_tasks, | |
| 338 unsigned num_image_decode_tasks) { | |
| 339 const size_t kNumVersions = 2; | |
| 340 ImageDecodeTask::Vector image_decode_tasks[kNumVersions]; | |
| 341 RasterTaskVector raster_tasks[kNumVersions]; | |
| 342 for (size_t i = 0; i < kNumVersions; ++i) { | |
| 343 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]); | |
| 344 CreateRasterTasks(num_raster_tasks, image_decode_tasks[i], | |
| 345 &raster_tasks[i]); | |
| 346 } | |
| 347 | |
| 348 // Avoid unnecessary heap allocations by reusing the same queue. | |
| 349 TileTaskQueue queue; | |
| 350 | |
| 351 size_t count = 0; | |
| 352 timer_.Reset(); | |
| 353 do { | |
| 354 queue.Reset(); | |
| 355 BuildTileTaskQueue(&queue, raster_tasks[count % kNumVersions]); | |
| 356 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&queue); | |
| 357 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); | |
| 358 ++count; | |
| 359 timer_.NextLap(); | |
| 360 } while (!timer_.HasTimeLimitExpired()); | |
| 361 | |
| 362 TileTaskQueue empty; | |
| 363 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty); | |
| 364 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 365 | |
| 366 perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(), | |
| 367 test_name, timer_.LapsPerSecond(), "runs/s", true); | |
| 368 } | |
| 369 | |
| 370 void RunScheduleAndExecuteTasksTest(const std::string& test_name, | |
| 371 unsigned num_raster_tasks, | |
| 372 unsigned num_image_decode_tasks) { | |
| 373 ImageDecodeTask::Vector image_decode_tasks; | |
| 374 RasterTaskVector raster_tasks; | |
| 375 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | |
| 376 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); | |
| 377 | |
| 378 // Avoid unnecessary heap allocations by reusing the same queue. | |
| 379 TileTaskQueue queue; | |
| 380 | |
| 381 timer_.Reset(); | |
| 382 do { | |
| 383 queue.Reset(); | |
| 384 BuildTileTaskQueue(&queue, raster_tasks); | |
| 385 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&queue); | |
| 386 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 387 timer_.NextLap(); | |
| 388 } while (!timer_.HasTimeLimitExpired()); | |
| 389 | |
| 390 TileTaskQueue empty; | |
| 391 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty); | |
| 392 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 393 | |
| 394 perf_test::PrintResult("schedule_and_execute_tasks", TestModifierString(), | |
| 395 test_name, timer_.LapsPerSecond(), "runs/s", true); | |
| 396 } | |
| 397 | |
| 398 private: | |
| 399 void Create3dOutputSurfaceAndResourceProvider() { | |
| 400 output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass(); | |
| 401 CHECK(output_surface_->BindToClient(&output_surface_client_)); | |
| 402 resource_provider_ = ResourceProvider::Create(output_surface_.get(), NULL, | |
| 403 &gpu_memory_buffer_manager_, | |
| 404 NULL, 0, false, 1).Pass(); | |
| 405 } | |
| 406 | |
| 407 void CreateSoftwareOutputSurfaceAndResourceProvider() { | |
| 408 output_surface_ = FakeOutputSurface::CreateSoftware( | |
| 409 make_scoped_ptr(new SoftwareOutputDevice)); | |
| 410 CHECK(output_surface_->BindToClient(&output_surface_client_)); | |
| 411 resource_provider_ = | |
| 412 ResourceProvider::Create(output_surface_.get(), &shared_bitmap_manager_, | |
| 413 NULL, NULL, 0, false, 1).Pass(); | |
| 414 } | |
| 415 | |
| 416 std::string TestModifierString() const { | |
| 417 switch (GetParam()) { | |
| 418 case TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER: | |
| 419 return std::string("_pixel_tile_task_worker_pool"); | |
| 420 case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY: | |
| 421 return std::string("_zero_copy_tile_task_worker_pool"); | |
| 422 case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY: | |
| 423 return std::string("_one_copy_tile_task_worker_pool"); | |
| 424 case TILE_TASK_WORKER_POOL_TYPE_GPU: | |
| 425 return std::string("_gpu_tile_task_worker_pool"); | |
| 426 case TILE_TASK_WORKER_POOL_TYPE_BITMAP: | |
| 427 return std::string("_bitmap_tile_task_worker_pool"); | |
| 428 } | |
| 429 NOTREACHED(); | |
| 430 return std::string(); | |
| 431 } | |
| 432 | |
| 433 scoped_ptr<ResourcePool> staging_resource_pool_; | |
| 434 scoped_ptr<TileTaskWorkerPool> tile_task_worker_pool_; | |
| 435 TestGpuMemoryBufferManager gpu_memory_buffer_manager_; | |
| 436 TestSharedBitmapManager shared_bitmap_manager_; | |
| 437 }; | |
| 438 | |
| 439 TEST_P(TileTaskWorkerPoolPerfTest, ScheduleTasks) { | |
| 440 RunScheduleTasksTest("1_0", 1, 0); | |
| 441 RunScheduleTasksTest("32_0", 32, 0); | |
| 442 RunScheduleTasksTest("1_1", 1, 1); | |
| 443 RunScheduleTasksTest("32_1", 32, 1); | |
| 444 RunScheduleTasksTest("1_4", 1, 4); | |
| 445 RunScheduleTasksTest("32_4", 32, 4); | |
| 446 } | |
| 447 | |
| 448 TEST_P(TileTaskWorkerPoolPerfTest, ScheduleAlternateTasks) { | |
| 449 RunScheduleAlternateTasksTest("1_0", 1, 0); | |
| 450 RunScheduleAlternateTasksTest("32_0", 32, 0); | |
| 451 RunScheduleAlternateTasksTest("1_1", 1, 1); | |
| 452 RunScheduleAlternateTasksTest("32_1", 32, 1); | |
| 453 RunScheduleAlternateTasksTest("1_4", 1, 4); | |
| 454 RunScheduleAlternateTasksTest("32_4", 32, 4); | |
| 455 } | |
| 456 | |
| 457 TEST_P(TileTaskWorkerPoolPerfTest, ScheduleAndExecuteTasks) { | |
| 458 RunScheduleAndExecuteTasksTest("1_0", 1, 0); | |
| 459 RunScheduleAndExecuteTasksTest("32_0", 32, 0); | |
| 460 RunScheduleAndExecuteTasksTest("1_1", 1, 1); | |
| 461 RunScheduleAndExecuteTasksTest("32_1", 32, 1); | |
| 462 RunScheduleAndExecuteTasksTest("1_4", 1, 4); | |
| 463 RunScheduleAndExecuteTasksTest("32_4", 32, 4); | |
| 464 } | |
| 465 | |
| 466 INSTANTIATE_TEST_CASE_P( | |
| 467 TileTaskWorkerPoolPerfTests, | |
| 468 TileTaskWorkerPoolPerfTest, | |
| 469 ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER, | |
| 470 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | |
| 471 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | |
| 472 TILE_TASK_WORKER_POOL_TYPE_GPU, | |
| 473 TILE_TASK_WORKER_POOL_TYPE_BITMAP)); | |
| 474 | |
| 475 class TileTaskWorkerPoolCommonPerfTest : public TileTaskWorkerPoolPerfTestBase, | |
| 476 public testing::Test { | |
| 477 public: | |
| 478 // Overridden from testing::Test: | |
| 479 void SetUp() override { | |
| 480 output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass(); | |
| 481 CHECK(output_surface_->BindToClient(&output_surface_client_)); | |
| 482 resource_provider_ = | |
| 483 ResourceProvider::Create(output_surface_.get(), NULL, NULL, NULL, 0, | |
| 484 false, 1).Pass(); | |
| 485 } | |
| 486 | |
| 487 void RunBuildTileTaskQueueTest(const std::string& test_name, | |
| 488 unsigned num_raster_tasks, | |
| 489 unsigned num_image_decode_tasks) { | |
| 490 ImageDecodeTask::Vector image_decode_tasks; | |
| 491 RasterTaskVector raster_tasks; | |
| 492 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | |
| 493 CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); | |
| 494 | |
| 495 // Avoid unnecessary heap allocations by reusing the same queue. | |
| 496 TileTaskQueue queue; | |
| 497 | |
| 498 timer_.Reset(); | |
| 499 do { | |
| 500 queue.Reset(); | |
| 501 BuildTileTaskQueue(&queue, raster_tasks); | |
| 502 timer_.NextLap(); | |
| 503 } while (!timer_.HasTimeLimitExpired()); | |
| 504 | |
| 505 perf_test::PrintResult("build_raster_task_queue", "", test_name, | |
| 506 timer_.LapsPerSecond(), "runs/s", true); | |
| 507 } | |
| 508 }; | |
| 509 | |
| 510 TEST_F(TileTaskWorkerPoolCommonPerfTest, BuildTileTaskQueue) { | |
| 511 RunBuildTileTaskQueueTest("1_0", 1, 0); | |
| 512 RunBuildTileTaskQueueTest("32_0", 32, 0); | |
| 513 RunBuildTileTaskQueueTest("1_1", 1, 1); | |
| 514 RunBuildTileTaskQueueTest("32_1", 32, 1); | |
| 515 RunBuildTileTaskQueueTest("1_4", 1, 4); | |
| 516 RunBuildTileTaskQueueTest("32_4", 32, 4); | |
| 517 } | |
| 518 | |
| 519 } // namespace | |
| 520 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1057283003:
Remove parts of //cc we aren't using (Closed)
Base URL: git@github.com:domokit/mojo.git@master