Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(307)

Side by Side Diff: cc/tiles/tile_manager.cc

Issue 1951193002: cc: Add mailbox support to ResourceProvider write locks. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@worker_context_stream
Patch Set: ericrk's review Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « cc/tiles/tile_manager.h ('k') | cc/tiles/tile_manager_unittest.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2012 The Chromium Authors. All rights reserved. 1 // Copyright 2012 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 "cc/tiles/tile_manager.h" 5 #include "cc/tiles/tile_manager.h"
6 6
7 #include <stddef.h> 7 #include <stddef.h>
8 #include <stdint.h> 8 #include <stdint.h>
9 9
10 #include <algorithm> 10 #include <algorithm>
(...skipping 329 matching lines...) Expand 10 before | Expand all | Expand 10 after
340 void TileManager::FinishTasksAndCleanUp() { 340 void TileManager::FinishTasksAndCleanUp() {
341 if (!tile_task_manager_) 341 if (!tile_task_manager_)
342 return; 342 return;
343 343
344 global_state_ = GlobalStateThatImpactsTilePriority(); 344 global_state_ = GlobalStateThatImpactsTilePriority();
345 345
346 // This cancels tasks if possible, finishes pending tasks, and release any 346 // This cancels tasks if possible, finishes pending tasks, and release any
347 // uninitialized resources. 347 // uninitialized resources.
348 tile_task_manager_->Shutdown(); 348 tile_task_manager_->Shutdown();
349 349
350 // Now that all tasks have been finished, we can clear any 350 raster_buffer_provider_->Shutdown();
351 // |orphan_tasks_|. 351
352 // Now that all tasks have been finished, we can clear any |orphan_tasks_|.
352 orphan_tasks_.clear(); 353 orphan_tasks_.clear();
353 354
354 tile_task_manager_->CheckForCompletedTasks(); 355 tile_task_manager_->CheckForCompletedTasks();
355 356
356 FreeResourcesForReleasedTiles(); 357 FreeResourcesForReleasedTiles();
357 CleanUpReleasedTiles(); 358 CleanUpReleasedTiles();
358 359
359 tile_task_manager_ = nullptr; 360 tile_task_manager_ = nullptr;
360 resource_pool_ = nullptr; 361 resource_pool_ = nullptr;
361 more_tiles_need_prepare_check_notifier_.Cancel(); 362 more_tiles_need_prepare_check_notifier_.Cancel();
362 signals_check_notifier_.Cancel(); 363 signals_check_notifier_.Cancel();
363 task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs(); 364 task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
364 365
365 for (auto& draw_image_pair : locked_images_) 366 for (auto& draw_image_pair : locked_images_)
366 image_decode_controller_->UnrefImage(draw_image_pair.first); 367 image_decode_controller_->UnrefImage(draw_image_pair.first);
367 locked_images_.clear(); 368 locked_images_.clear();
368 } 369 }
369 370
370 void TileManager::SetResources(ResourcePool* resource_pool, 371 void TileManager::SetResources(ResourcePool* resource_pool,
371 ImageDecodeController* image_decode_controller, 372 ImageDecodeController* image_decode_controller,
372 TileTaskManager* tile_task_manager, 373 TileTaskManager* tile_task_manager,
374 RasterBufferProvider* raster_buffer_provider,
373 size_t scheduled_raster_task_limit, 375 size_t scheduled_raster_task_limit,
374 bool use_gpu_rasterization) { 376 bool use_gpu_rasterization) {
375 DCHECK(!tile_task_manager_); 377 DCHECK(!tile_task_manager_);
376 DCHECK(tile_task_manager); 378 DCHECK(tile_task_manager);
377 379
378 use_gpu_rasterization_ = use_gpu_rasterization; 380 use_gpu_rasterization_ = use_gpu_rasterization;
379 scheduled_raster_task_limit_ = scheduled_raster_task_limit; 381 scheduled_raster_task_limit_ = scheduled_raster_task_limit;
380 resource_pool_ = resource_pool; 382 resource_pool_ = resource_pool;
381 image_decode_controller_ = image_decode_controller; 383 image_decode_controller_ = image_decode_controller;
382 tile_task_manager_ = tile_task_manager; 384 tile_task_manager_ = tile_task_manager;
385 raster_buffer_provider_ = raster_buffer_provider;
383 } 386 }
384 387
385 void TileManager::Release(Tile* tile) { 388 void TileManager::Release(Tile* tile) {
386 released_tiles_.push_back(tile); 389 released_tiles_.push_back(tile);
387 } 390 }
388 391
389 void TileManager::FreeResourcesForReleasedTiles() { 392 void TileManager::FreeResourcesForReleasedTiles() {
390 for (auto* tile : released_tiles_) 393 for (auto* tile : released_tiles_)
391 FreeResourcesForTile(tile); 394 FreeResourcesForTile(tile);
392 } 395 }
(...skipping 478 matching lines...) Expand 10 before | Expand all | Expand 10 after
871 graph_.edges.push_back(TaskGraph::Edge(task.get(), all_done_task.get())); 874 graph_.edges.push_back(TaskGraph::Edge(task.get(), all_done_task.get()));
872 } 875 }
873 } 876 }
874 877
875 for (auto& draw_image_pair : locked_images_) 878 for (auto& draw_image_pair : locked_images_)
876 image_decode_controller_->UnrefImage(draw_image_pair.first); 879 image_decode_controller_->UnrefImage(draw_image_pair.first);
877 // The old locked images have to stay around until past the ScheduleTasks call 880 // The old locked images have to stay around until past the ScheduleTasks call
878 // below, so we do a swap instead of a move. 881 // below, so we do a swap instead of a move.
879 locked_images_.swap(new_locked_images); 882 locked_images_.swap(new_locked_images);
880 883
884 // We must reduce the amount of unused resources before calling
885 // ScheduleTasks to prevent usage from rising above limits.
886 resource_pool_->ReduceResourceUsage();
887 image_decode_controller_->ReduceCacheUsage();
888
889 // Synchronize worker with compositor. If that fails do not schedule tasks.
vmpstr 2016/06/15 00:39:34 Can you expand this comment a little bit to mentio
sunnyps 2016/06/15 00:42:00 Calling task->OnTaskCompleted will free up resourc
sunnyps 2016/06/15 01:56:58 Done.
890 if (!raster_buffer_provider_->OrderingBarrier()) {
891 // Cancel tasks to appease DCHECKs in TileTask dtor.
892 for (auto& node : graph_.nodes) {
893 TileTask* task = static_cast<TileTask*>(node.task);
894 task->state().DidCancel();
895 task->OnTaskCompleted();
896 task->DidComplete();
897 }
898 graph_.Reset();
899 required_for_activate_count = 0;
900 required_for_draw_count = 0;
901 all_count = 0;
902 }
903
881 // Insert nodes for our task completion tasks. We enqueue these using 904 // Insert nodes for our task completion tasks. We enqueue these using
882 // NONCONCURRENT_FOREGROUND category this is the highest prioirty category and 905 // NONCONCURRENT_FOREGROUND category this is the highest prioirty category and
883 // we'd like to run these tasks as soon as possible. 906 // we'd like to run these tasks as soon as possible.
884 InsertNodeForTask(&graph_, required_for_activation_done_task.get(), 907 InsertNodeForTask(&graph_, required_for_activation_done_task.get(),
885 TASK_CATEGORY_NONCONCURRENT_FOREGROUND, 908 TASK_CATEGORY_NONCONCURRENT_FOREGROUND,
886 kRequiredForActivationDoneTaskPriority, 909 kRequiredForActivationDoneTaskPriority,
887 required_for_activate_count); 910 required_for_activate_count);
888 InsertNodeForTask(&graph_, required_for_draw_done_task.get(), 911 InsertNodeForTask(&graph_, required_for_draw_done_task.get(),
889 TASK_CATEGORY_NONCONCURRENT_FOREGROUND, 912 TASK_CATEGORY_NONCONCURRENT_FOREGROUND,
890 kRequiredForDrawDoneTaskPriority, required_for_draw_count); 913 kRequiredForDrawDoneTaskPriority, required_for_draw_count);
891 InsertNodeForTask(&graph_, all_done_task.get(), 914 InsertNodeForTask(&graph_, all_done_task.get(),
892 TASK_CATEGORY_NONCONCURRENT_FOREGROUND, 915 TASK_CATEGORY_NONCONCURRENT_FOREGROUND,
893 kAllDoneTaskPriority, all_count); 916 kAllDoneTaskPriority, all_count);
894 917
895 // We must reduce the amount of unused resoruces before calling
896 // ScheduleTasks to prevent usage from rising above limits.
897 resource_pool_->ReduceResourceUsage();
898 image_decode_controller_->ReduceCacheUsage();
899
900 // Schedule running of |raster_queue_|. This replaces any previously 918 // Schedule running of |raster_queue_|. This replaces any previously
901 // scheduled tasks and effectively cancels all tasks not present 919 // scheduled tasks and effectively cancels all tasks not present
902 // in |raster_queue_|. 920 // in |raster_queue_|.
903 tile_task_manager_->ScheduleTasks(&graph_); 921 tile_task_manager_->ScheduleTasks(&graph_);
904 922
905 // It's now safe to clean up orphan tasks as raster worker pool is not 923 // It's now safe to clean up orphan tasks as raster worker pool is not
906 // allowed to keep around unreferenced raster tasks after ScheduleTasks() has 924 // allowed to keep around unreferenced raster tasks after ScheduleTasks() has
907 // been called. 925 // been called.
908 orphan_tasks_.clear(); 926 orphan_tasks_.clear();
909 927
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
967 decode_tasks.push_back(task); 985 decode_tasks.push_back(task);
968 986
969 if (need_to_unref_when_finished) 987 if (need_to_unref_when_finished)
970 ++it; 988 ++it;
971 else 989 else
972 it = images.erase(it); 990 it = images.erase(it);
973 } 991 }
974 992
975 bool supports_concurrent_execution = !use_gpu_rasterization_; 993 bool supports_concurrent_execution = !use_gpu_rasterization_;
976 std::unique_ptr<RasterBuffer> raster_buffer = 994 std::unique_ptr<RasterBuffer> raster_buffer =
977 tile_task_manager_->GetRasterBufferProvider()->AcquireBufferForRaster( 995 raster_buffer_provider_->AcquireBufferForRaster(
978 resource, resource_content_id, tile->invalidated_id()); 996 resource, resource_content_id, tile->invalidated_id());
979 return make_scoped_refptr(new RasterTaskImpl( 997 return make_scoped_refptr(new RasterTaskImpl(
980 this, tile, resource, prioritized_tile.raster_source(), playback_settings, 998 this, tile, resource, prioritized_tile.raster_source(), playback_settings,
981 prioritized_tile.priority().resolution, prepare_tiles_count_, 999 prioritized_tile.priority().resolution, prepare_tiles_count_,
982 std::move(raster_buffer), &decode_tasks, supports_concurrent_execution)); 1000 std::move(raster_buffer), &decode_tasks, supports_concurrent_execution));
983 } 1001 }
984 1002
985 void TileManager::OnRasterTaskCompleted( 1003 void TileManager::OnRasterTaskCompleted(
986 std::unique_ptr<RasterBuffer> raster_buffer, 1004 std::unique_ptr<RasterBuffer> raster_buffer,
987 Tile* tile, 1005 Tile* tile,
988 Resource* resource, 1006 Resource* resource,
989 bool was_canceled) { 1007 bool was_canceled) {
990 DCHECK(tile); 1008 DCHECK(tile);
991 DCHECK(tiles_.find(tile->id()) != tiles_.end()); 1009 DCHECK(tiles_.find(tile->id()) != tiles_.end());
992 tile_task_manager_->GetRasterBufferProvider()->ReleaseBufferForRaster( 1010 raster_buffer_provider_->ReleaseBufferForRaster(std::move(raster_buffer));
993 std::move(raster_buffer));
994 1011
995 TileDrawInfo& draw_info = tile->draw_info(); 1012 TileDrawInfo& draw_info = tile->draw_info();
996 DCHECK(tile->raster_task_.get()); 1013 DCHECK(tile->raster_task_.get());
997 orphan_tasks_.push_back(tile->raster_task_); 1014 orphan_tasks_.push_back(tile->raster_task_);
998 tile->raster_task_ = nullptr; 1015 tile->raster_task_ = nullptr;
999 1016
1000 // Unref all the images. 1017 // Unref all the images.
1001 auto images_it = scheduled_draw_images_.find(tile->id()); 1018 auto images_it = scheduled_draw_images_.find(tile->id());
1002 const std::vector<DrawImage>& images = images_it->second; 1019 const std::vector<DrawImage>& images = images_it->second;
1003 for (const auto& image : images) 1020 for (const auto& image : images)
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
1039 1056
1040 tiles_[tile->id()] = tile.get(); 1057 tiles_[tile->id()] = tile.get();
1041 return tile; 1058 return tile;
1042 } 1059 }
1043 1060
1044 void TileManager::SetTileTaskManagerForTesting( 1061 void TileManager::SetTileTaskManagerForTesting(
1045 TileTaskManager* tile_task_manager) { 1062 TileTaskManager* tile_task_manager) {
1046 tile_task_manager_ = tile_task_manager; 1063 tile_task_manager_ = tile_task_manager;
1047 } 1064 }
1048 1065
1066 void TileManager::SetRasterBufferProviderForTesting(
1067 RasterBufferProvider* raster_buffer_provider) {
1068 raster_buffer_provider_ = raster_buffer_provider;
1069 }
1070
1049 bool TileManager::AreRequiredTilesReadyToDraw( 1071 bool TileManager::AreRequiredTilesReadyToDraw(
1050 RasterTilePriorityQueue::Type type) const { 1072 RasterTilePriorityQueue::Type type) const {
1051 std::unique_ptr<RasterTilePriorityQueue> raster_priority_queue( 1073 std::unique_ptr<RasterTilePriorityQueue> raster_priority_queue(
1052 client_->BuildRasterQueue(global_state_.tree_priority, type)); 1074 client_->BuildRasterQueue(global_state_.tree_priority, type));
1053 // It is insufficient to check whether the raster queue we constructed is 1075 // It is insufficient to check whether the raster queue we constructed is
1054 // empty. The reason for this is that there are situations (rasterize on 1076 // empty. The reason for this is that there are situations (rasterize on
1055 // demand) when the tile both needs raster and it's ready to draw. Hence, we 1077 // demand) when the tile both needs raster and it's ready to draw. Hence, we
1056 // have to iterate the queue to check whether the required tiles are ready to 1078 // have to iterate the queue to check whether the required tiles are ready to
1057 // draw. 1079 // draw.
1058 for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) { 1080 for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after
1208 Tile* tile = queue->Top().tile(); 1230 Tile* tile = queue->Top().tile();
1209 if (tile->draw_info().IsReadyToDraw()) 1231 if (tile->draw_info().IsReadyToDraw())
1210 continue; 1232 continue;
1211 tile->draw_info().set_oom(); 1233 tile->draw_info().set_oom();
1212 client_->NotifyTileStateChanged(tile); 1234 client_->NotifyTileStateChanged(tile);
1213 } 1235 }
1214 return true; 1236 return true;
1215 } 1237 }
1216 1238
1217 ResourceFormat TileManager::DetermineResourceFormat(const Tile* tile) const { 1239 ResourceFormat TileManager::DetermineResourceFormat(const Tile* tile) const {
1218 return tile_task_manager_->GetRasterBufferProvider()->GetResourceFormat( 1240 return raster_buffer_provider_->GetResourceFormat(!tile->is_opaque());
1241 }
1242
1243 bool TileManager::DetermineResourceRequiresSwizzle(const Tile* tile) const {
1244 return raster_buffer_provider_->GetResourceRequiresSwizzle(
1219 !tile->is_opaque()); 1245 !tile->is_opaque());
1220 } 1246 }
1221 1247
1222 bool TileManager::DetermineResourceRequiresSwizzle(const Tile* tile) const {
1223 return tile_task_manager_->GetRasterBufferProvider()
1224 ->GetResourceRequiresSwizzle(!tile->is_opaque());
1225 }
1226
1227 std::unique_ptr<base::trace_event::ConvertableToTraceFormat> 1248 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
1228 TileManager::ScheduledTasksStateAsValue() const { 1249 TileManager::ScheduledTasksStateAsValue() const {
1229 std::unique_ptr<base::trace_event::TracedValue> state( 1250 std::unique_ptr<base::trace_event::TracedValue> state(
1230 new base::trace_event::TracedValue()); 1251 new base::trace_event::TracedValue());
1231 state->BeginDictionary("tasks_pending"); 1252 state->BeginDictionary("tasks_pending");
1232 state->SetBoolean("ready_to_activate", signals_.ready_to_activate); 1253 state->SetBoolean("ready_to_activate", signals_.ready_to_activate);
1233 state->SetBoolean("ready_to_draw", signals_.ready_to_draw); 1254 state->SetBoolean("ready_to_draw", signals_.ready_to_draw);
1234 state->SetBoolean("all_tile_tasks_completed", 1255 state->SetBoolean("all_tile_tasks_completed",
1235 signals_.all_tile_tasks_completed); 1256 signals_.all_tile_tasks_completed);
1236 state->EndDictionary(); 1257 state->EndDictionary();
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after
1321 all_tile_tasks_completed = false; 1342 all_tile_tasks_completed = false;
1322 did_notify_all_tile_tasks_completed = false; 1343 did_notify_all_tile_tasks_completed = false;
1323 } 1344 }
1324 1345
1325 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default; 1346 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default;
1326 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule( 1347 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule(
1327 PrioritizedWorkToSchedule&& other) = default; 1348 PrioritizedWorkToSchedule&& other) = default;
1328 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default; 1349 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default;
1329 1350
1330 } // namespace cc 1351 } // namespace cc
OLDNEW
« no previous file with comments | « cc/tiles/tile_manager.h ('k') | cc/tiles/tile_manager_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698