| 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/raster/tile_task_worker_pool.h" | |
| 6 | |
| 7 #include <stddef.h> | |
| 8 #include <stdint.h> | |
| 9 | |
| 10 #include <algorithm> | |
| 11 #include <limits> | |
| 12 #include <vector> | |
| 13 | |
| 14 #include "base/cancelable_callback.h" | |
| 15 #include "base/location.h" | |
| 16 #include "base/macros.h" | |
| 17 #include "base/memory/ptr_util.h" | |
| 18 #include "base/single_thread_task_runner.h" | |
| 19 #include "base/thread_task_runner_handle.h" | |
| 20 #include "cc/base/unique_notifier.h" | |
| 21 #include "cc/raster/bitmap_tile_task_worker_pool.h" | |
| 22 #include "cc/raster/gpu_rasterizer.h" | |
| 23 #include "cc/raster/gpu_tile_task_worker_pool.h" | |
| 24 #include "cc/raster/one_copy_tile_task_worker_pool.h" | |
| 25 #include "cc/raster/synchronous_task_graph_runner.h" | |
| 26 #include "cc/raster/zero_copy_tile_task_worker_pool.h" | |
| 27 #include "cc/resources/resource_pool.h" | |
| 28 #include "cc/resources/resource_provider.h" | |
| 29 #include "cc/resources/scoped_resource.h" | |
| 30 #include "cc/test/fake_output_surface.h" | |
| 31 #include "cc/test/fake_output_surface_client.h" | |
| 32 #include "cc/test/fake_raster_source.h" | |
| 33 #include "cc/test/fake_resource_provider.h" | |
| 34 #include "cc/test/test_gpu_memory_buffer_manager.h" | |
| 35 #include "cc/test/test_shared_bitmap_manager.h" | |
| 36 #include "cc/test/test_web_graphics_context_3d.h" | |
| 37 #include "gpu/GLES2/gl2extchromium.h" | |
| 38 #include "testing/gtest/include/gtest/gtest.h" | |
| 39 | |
| 40 namespace cc { | |
| 41 namespace { | |
| 42 | |
| 43 const size_t kMaxBytesPerCopyOperation = 1000U; | |
| 44 const size_t kMaxStagingBuffers = 32U; | |
| 45 | |
| 46 enum TileTaskWorkerPoolType { | |
| 47 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | |
| 48 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | |
| 49 TILE_TASK_WORKER_POOL_TYPE_GPU, | |
| 50 TILE_TASK_WORKER_POOL_TYPE_BITMAP | |
| 51 }; | |
| 52 | |
| 53 class TestRasterTaskImpl : public TileTask { | |
| 54 public: | |
| 55 typedef base::Callback<void(bool was_canceled)> Reply; | |
| 56 | |
| 57 TestRasterTaskImpl(const Resource* resource, | |
| 58 const Reply& reply, | |
| 59 TileTask::Vector* dependencies) | |
| 60 : TileTask(true, dependencies), | |
| 61 resource_(resource), | |
| 62 reply_(reply), | |
| 63 raster_source_(FakeRasterSource::CreateFilled(gfx::Size(1, 1))) {} | |
| 64 | |
| 65 // Overridden from Task: | |
| 66 void RunOnWorkerThread() override { | |
| 67 uint64_t new_content_id = 0; | |
| 68 raster_buffer_->Playback(raster_source_.get(), gfx::Rect(1, 1), | |
| 69 gfx::Rect(1, 1), new_content_id, 1.f, | |
| 70 RasterSource::PlaybackSettings()); | |
| 71 } | |
| 72 | |
| 73 // Overridden from TileTask: | |
| 74 void ScheduleOnOriginThread(RasterBufferProvider* provider) override { | |
| 75 // The raster buffer has no tile ids associated with it for partial update, | |
| 76 // so doesn't need to provide a valid dirty rect. | |
| 77 raster_buffer_ = provider->AcquireBufferForRaster(resource_, 0, 0); | |
| 78 } | |
| 79 void CompleteOnOriginThread(RasterBufferProvider* provider) override { | |
| 80 provider->ReleaseBufferForRaster(std::move(raster_buffer_)); | |
| 81 reply_.Run(!state().IsFinished()); | |
| 82 } | |
| 83 | |
| 84 protected: | |
| 85 ~TestRasterTaskImpl() override {} | |
| 86 | |
| 87 private: | |
| 88 const Resource* resource_; | |
| 89 const Reply reply_; | |
| 90 std::unique_ptr<RasterBuffer> raster_buffer_; | |
| 91 scoped_refptr<RasterSource> raster_source_; | |
| 92 | |
| 93 DISALLOW_COPY_AND_ASSIGN(TestRasterTaskImpl); | |
| 94 }; | |
| 95 | |
| 96 class BlockingTestRasterTaskImpl : public TestRasterTaskImpl { | |
| 97 public: | |
| 98 BlockingTestRasterTaskImpl(const Resource* resource, | |
| 99 const Reply& reply, | |
| 100 base::Lock* lock, | |
| 101 TileTask::Vector* dependencies) | |
| 102 : TestRasterTaskImpl(resource, reply, dependencies), lock_(lock) {} | |
| 103 | |
| 104 // Overridden from Task: | |
| 105 void RunOnWorkerThread() override { | |
| 106 base::AutoLock lock(*lock_); | |
| 107 TestRasterTaskImpl::RunOnWorkerThread(); | |
| 108 } | |
| 109 | |
| 110 protected: | |
| 111 ~BlockingTestRasterTaskImpl() override {} | |
| 112 | |
| 113 private: | |
| 114 base::Lock* lock_; | |
| 115 | |
| 116 DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterTaskImpl); | |
| 117 }; | |
| 118 | |
| 119 class TileTaskWorkerPoolTest | |
| 120 : public testing::TestWithParam<TileTaskWorkerPoolType> { | |
| 121 public: | |
| 122 struct RasterTaskResult { | |
| 123 unsigned id; | |
| 124 bool canceled; | |
| 125 }; | |
| 126 | |
| 127 typedef std::vector<scoped_refptr<TileTask>> RasterTaskVector; | |
| 128 | |
| 129 enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL }; | |
| 130 | |
| 131 TileTaskWorkerPoolTest() | |
| 132 : context_provider_(TestContextProvider::Create()), | |
| 133 worker_context_provider_(TestContextProvider::CreateWorker()), | |
| 134 all_tile_tasks_finished_( | |
| 135 base::ThreadTaskRunnerHandle::Get() | |
| 136 .get(), | |
| 137 base::Bind(&TileTaskWorkerPoolTest::AllTileTasksFinished, | |
| 138 base::Unretained(this))), | |
| 139 timeout_seconds_(5), | |
| 140 timed_out_(false) {} | |
| 141 | |
| 142 // Overridden from testing::Test: | |
| 143 void SetUp() override { | |
| 144 switch (GetParam()) { | |
| 145 case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY: | |
| 146 Create3dOutputSurfaceAndResourceProvider(); | |
| 147 tile_task_worker_pool_ = ZeroCopyTileTaskWorkerPool::Create( | |
| 148 base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_, | |
| 149 resource_provider_.get(), PlatformColor::BestTextureFormat()); | |
| 150 break; | |
| 151 case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY: | |
| 152 Create3dOutputSurfaceAndResourceProvider(); | |
| 153 tile_task_worker_pool_ = OneCopyTileTaskWorkerPool::Create( | |
| 154 base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_, | |
| 155 context_provider_.get(), resource_provider_.get(), | |
| 156 kMaxBytesPerCopyOperation, false, kMaxStagingBuffers, | |
| 157 PlatformColor::BestTextureFormat()); | |
| 158 break; | |
| 159 case TILE_TASK_WORKER_POOL_TYPE_GPU: | |
| 160 Create3dOutputSurfaceAndResourceProvider(); | |
| 161 tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create( | |
| 162 base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_, | |
| 163 context_provider_.get(), resource_provider_.get(), false, 0); | |
| 164 break; | |
| 165 case TILE_TASK_WORKER_POOL_TYPE_BITMAP: | |
| 166 CreateSoftwareOutputSurfaceAndResourceProvider(); | |
| 167 tile_task_worker_pool_ = BitmapTileTaskWorkerPool::Create( | |
| 168 base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_, | |
| 169 resource_provider_.get()); | |
| 170 break; | |
| 171 } | |
| 172 | |
| 173 DCHECK(tile_task_worker_pool_); | |
| 174 } | |
| 175 | |
| 176 void TearDown() override { | |
| 177 tile_task_worker_pool_->Shutdown(); | |
| 178 tile_task_worker_pool_->CheckForCompletedTasks(); | |
| 179 } | |
| 180 | |
| 181 void AllTileTasksFinished() { | |
| 182 tile_task_worker_pool_->CheckForCompletedTasks(); | |
| 183 base::MessageLoop::current()->QuitWhenIdle(); | |
| 184 } | |
| 185 | |
| 186 void RunMessageLoopUntilAllTasksHaveCompleted() { | |
| 187 task_graph_runner_.RunUntilIdle(); | |
| 188 tile_task_worker_pool_->CheckForCompletedTasks(); | |
| 189 } | |
| 190 | |
| 191 void ScheduleTasks() { | |
| 192 graph_.Reset(); | |
| 193 | |
| 194 size_t priority = 0; | |
| 195 | |
| 196 for (RasterTaskVector::const_iterator it = tasks_.begin(); | |
| 197 it != tasks_.end(); ++it) { | |
| 198 graph_.nodes.emplace_back(it->get(), 0 /* group */, priority++, | |
| 199 0 /* dependencies */); | |
| 200 } | |
| 201 | |
| 202 tile_task_worker_pool_->ScheduleTasks(&graph_); | |
| 203 } | |
| 204 | |
| 205 void AppendTask(unsigned id, const gfx::Size& size) { | |
| 206 std::unique_ptr<ScopedResource> resource( | |
| 207 ScopedResource::Create(resource_provider_.get())); | |
| 208 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | |
| 209 RGBA_8888); | |
| 210 const Resource* const_resource = resource.get(); | |
| 211 | |
| 212 TileTask::Vector empty; | |
| 213 tasks_.push_back(new TestRasterTaskImpl( | |
| 214 const_resource, | |
| 215 base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted, | |
| 216 base::Unretained(this), base::Passed(&resource), id), | |
| 217 &empty)); | |
| 218 } | |
| 219 | |
| 220 void AppendTask(unsigned id) { AppendTask(id, gfx::Size(1, 1)); } | |
| 221 | |
| 222 void AppendBlockingTask(unsigned id, base::Lock* lock) { | |
| 223 const gfx::Size size(1, 1); | |
| 224 | |
| 225 std::unique_ptr<ScopedResource> resource( | |
| 226 ScopedResource::Create(resource_provider_.get())); | |
| 227 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | |
| 228 RGBA_8888); | |
| 229 const Resource* const_resource = resource.get(); | |
| 230 | |
| 231 TileTask::Vector empty; | |
| 232 tasks_.push_back(new BlockingTestRasterTaskImpl( | |
| 233 const_resource, | |
| 234 base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted, | |
| 235 base::Unretained(this), base::Passed(&resource), id), | |
| 236 lock, &empty)); | |
| 237 } | |
| 238 | |
| 239 const std::vector<RasterTaskResult>& completed_tasks() const { | |
| 240 return completed_tasks_; | |
| 241 } | |
| 242 | |
| 243 void LoseContext(ContextProvider* context_provider) { | |
| 244 if (!context_provider) | |
| 245 return; | |
| 246 context_provider->ContextGL()->LoseContextCHROMIUM( | |
| 247 GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB); | |
| 248 context_provider->ContextGL()->Flush(); | |
| 249 } | |
| 250 | |
| 251 private: | |
| 252 void Create3dOutputSurfaceAndResourceProvider() { | |
| 253 output_surface_ = FakeOutputSurface::Create3d(context_provider_, | |
| 254 worker_context_provider_); | |
| 255 CHECK(output_surface_->BindToClient(&output_surface_client_)); | |
| 256 TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d(); | |
| 257 context3d->set_support_sync_query(true); | |
| 258 resource_provider_ = FakeResourceProvider::Create( | |
| 259 output_surface_.get(), nullptr, &gpu_memory_buffer_manager_); | |
| 260 } | |
| 261 | |
| 262 void CreateSoftwareOutputSurfaceAndResourceProvider() { | |
| 263 output_surface_ = FakeOutputSurface::CreateSoftware( | |
| 264 base::WrapUnique(new SoftwareOutputDevice)); | |
| 265 CHECK(output_surface_->BindToClient(&output_surface_client_)); | |
| 266 resource_provider_ = FakeResourceProvider::Create( | |
| 267 output_surface_.get(), &shared_bitmap_manager_, nullptr); | |
| 268 } | |
| 269 | |
| 270 void OnTaskCompleted(std::unique_ptr<ScopedResource> resource, | |
| 271 unsigned id, | |
| 272 bool was_canceled) { | |
| 273 RasterTaskResult result; | |
| 274 result.id = id; | |
| 275 result.canceled = was_canceled; | |
| 276 completed_tasks_.push_back(result); | |
| 277 } | |
| 278 | |
| 279 void OnTimeout() { | |
| 280 timed_out_ = true; | |
| 281 base::MessageLoop::current()->QuitWhenIdle(); | |
| 282 } | |
| 283 | |
| 284 protected: | |
| 285 scoped_refptr<TestContextProvider> context_provider_; | |
| 286 scoped_refptr<TestContextProvider> worker_context_provider_; | |
| 287 FakeOutputSurfaceClient output_surface_client_; | |
| 288 std::unique_ptr<FakeOutputSurface> output_surface_; | |
| 289 std::unique_ptr<ResourceProvider> resource_provider_; | |
| 290 std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool_; | |
| 291 TestGpuMemoryBufferManager gpu_memory_buffer_manager_; | |
| 292 TestSharedBitmapManager shared_bitmap_manager_; | |
| 293 SynchronousTaskGraphRunner task_graph_runner_; | |
| 294 base::CancelableClosure timeout_; | |
| 295 UniqueNotifier all_tile_tasks_finished_; | |
| 296 int timeout_seconds_; | |
| 297 bool timed_out_; | |
| 298 RasterTaskVector tasks_; | |
| 299 std::vector<RasterTaskResult> completed_tasks_; | |
| 300 TaskGraph graph_; | |
| 301 }; | |
| 302 | |
| 303 TEST_P(TileTaskWorkerPoolTest, Basic) { | |
| 304 AppendTask(0u); | |
| 305 AppendTask(1u); | |
| 306 ScheduleTasks(); | |
| 307 | |
| 308 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 309 | |
| 310 ASSERT_EQ(2u, completed_tasks().size()); | |
| 311 EXPECT_FALSE(completed_tasks()[0].canceled); | |
| 312 EXPECT_FALSE(completed_tasks()[1].canceled); | |
| 313 } | |
| 314 | |
| 315 TEST_P(TileTaskWorkerPoolTest, FailedMapResource) { | |
| 316 if (GetParam() == TILE_TASK_WORKER_POOL_TYPE_BITMAP) | |
| 317 return; | |
| 318 | |
| 319 TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d(); | |
| 320 context3d->set_times_map_buffer_chromium_succeeds(0); | |
| 321 AppendTask(0u); | |
| 322 ScheduleTasks(); | |
| 323 | |
| 324 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 325 | |
| 326 ASSERT_EQ(1u, completed_tasks().size()); | |
| 327 EXPECT_FALSE(completed_tasks()[0].canceled); | |
| 328 } | |
| 329 | |
| 330 // This test checks that replacing a pending raster task with another does | |
| 331 // not prevent the DidFinishRunningTileTasks notification from being sent. | |
| 332 TEST_P(TileTaskWorkerPoolTest, FalseThrottling) { | |
| 333 base::Lock lock; | |
| 334 | |
| 335 // Schedule a task that is prevented from completing with a lock. | |
| 336 lock.Acquire(); | |
| 337 AppendBlockingTask(0u, &lock); | |
| 338 ScheduleTasks(); | |
| 339 | |
| 340 // Schedule another task to replace the still-pending task. Because the old | |
| 341 // task is not a throttled task in the new task set, it should not prevent | |
| 342 // DidFinishRunningTileTasks from getting signaled. | |
| 343 RasterTaskVector tasks; | |
| 344 tasks.swap(tasks_); | |
| 345 AppendTask(1u); | |
| 346 ScheduleTasks(); | |
| 347 | |
| 348 // Unblock the first task to allow the second task to complete. | |
| 349 lock.Release(); | |
| 350 | |
| 351 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 352 } | |
| 353 | |
| 354 TEST_P(TileTaskWorkerPoolTest, LostContext) { | |
| 355 LoseContext(output_surface_->context_provider()); | |
| 356 LoseContext(output_surface_->worker_context_provider()); | |
| 357 | |
| 358 AppendTask(0u); | |
| 359 AppendTask(1u); | |
| 360 ScheduleTasks(); | |
| 361 | |
| 362 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 363 | |
| 364 ASSERT_EQ(2u, completed_tasks().size()); | |
| 365 EXPECT_FALSE(completed_tasks()[0].canceled); | |
| 366 EXPECT_FALSE(completed_tasks()[1].canceled); | |
| 367 } | |
| 368 | |
| 369 INSTANTIATE_TEST_CASE_P(TileTaskWorkerPoolTests, | |
| 370 TileTaskWorkerPoolTest, | |
| 371 ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | |
| 372 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | |
| 373 TILE_TASK_WORKER_POOL_TYPE_GPU, | |
| 374 TILE_TASK_WORKER_POOL_TYPE_BITMAP)); | |
| 375 | |
| 376 } // namespace | |
| 377 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1910213005:
cc: Refactor TileTaskWorkerPool. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@task_states