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

Unified Diff: cc/tiles/tile_manager.cc

Issue 2726343004: cc: Optimize decode scheduling for checker-images. (Closed)
Patch Set: addressed comments Created 3 years, 9 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 side-by-side diff with in-line comments
Download patch
« no previous file with comments | « cc/tiles/tile_manager.h ('k') | cc/tiles/tiling_set_raster_queue_all.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/tiles/tile_manager.cc
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index 9916918d96ce14d636b40f0b846acd4fa3b8f952..b6e9cecf260a24961b85043eb678db676c0ff0ea 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -681,6 +681,21 @@ TileManager::PrioritizedWorkToSchedule TileManager::AssignGpuMemoryToTiles() {
continue;
}
+ // Tiles in the raster queue should either require raster or decode for
+ // checker-images. If this tile does not need raster, process it only to
+ // build the decode queue for checkered images.
+ // Note that performing this check after the solif color analysis is not
+ // necessary for correctness.
+ if (!tile->draw_info().NeedsRaster()) {
+ DCHECK(tile->draw_info().is_checker_imaged());
+ DCHECK(tile->is_image_analysis_performed());
+
+ work_to_schedule.checker_image_decode_queue.insert(
+ work_to_schedule.checker_image_decode_queue.end(),
+ tile->images_to_checker().begin(), tile->images_to_checker().end());
+ continue;
+ }
+
// We won't be able to schedule this tile, so break out early.
if (work_to_schedule.tiles_to_raster.size() >=
scheduled_raster_task_limit_) {
@@ -727,6 +742,27 @@ TileManager::PrioritizedWorkToSchedule TileManager::AssignGpuMemoryToTiles() {
}
memory_usage += memory_required_by_tile_to_be_scheduled;
+
+ // If the tile has a scheduled task that will rasterize a resource with
+ // checker-imaged content, add those images to the decode queue. Note that
+ // we add all images as we process the raster priority queue to ensure that
+ // images are added to the decode queue in raster priority order.
+ if (tile->HasRasterTask()) {
+ DCHECK(tile->is_image_analysis_performed());
+
+ if (tile->raster_task_scheduled_with_checker_images()) {
+ work_to_schedule.checker_image_decode_queue.insert(
+ work_to_schedule.checker_image_decode_queue.end(),
+ tile->images_to_checker().begin(), tile->images_to_checker().end());
+ }
+ } else {
+ // Creating the raster task here will acquire resources, but
+ // this resource usage has already been accounted for above.
+ tile->raster_task_ =
+ CreateRasterTask(prioritized_tile, client_->GetRasterColorSpace(),
+ &work_to_schedule.checker_image_decode_queue);
+ }
+
work_to_schedule.tiles_to_raster.push_back(prioritized_tile);
}
@@ -736,6 +772,22 @@ TileManager::PrioritizedWorkToSchedule TileManager::AssignGpuMemoryToTiles() {
eviction_priority_queue = FreeTileResourcesUntilUsageIsWithinLimit(
std::move(eviction_priority_queue), hard_memory_limit, &memory_usage);
+ // At this point if we still have a tile that is holding onto a resource with
+ // checker-imaged content, add it to the decode queue to ensure that the
+ // resource is eventually invalidated.
+ while (!raster_priority_queue->IsEmpty()) {
+ const PrioritizedTile& prioritized_tile = raster_priority_queue->Top();
+ Tile* tile = prioritized_tile.tile();
+ if (tile->draw_info().is_checker_imaged() ||
+ tile->raster_task_scheduled_with_checker_images()) {
Khushal 2017/03/31 04:31:01 This part still needs to be worked out.
+ std::vector<DrawImage> images_in_tile;
+ prioritized_tile.raster_source()->GetDiscardableImagesInRect(
+ tile->enclosing_layer_rect(), tile->contents_scale(),
+ &images_in_tile);
+ }
+ raster_priority_queue->Pop();
+ }
+
UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget",
!had_enough_memory_to_schedule_tiles_needed_now);
did_oom_on_last_assign_ = !had_enough_memory_to_schedule_tiles_needed_now;
@@ -772,6 +824,29 @@ void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(
client_->NotifyTileStateChanged(tile);
}
+void TileManager::EnsureImageAnalysisPerformed(
+ const PrioritizedTile& prioritized_tile) {
+ Tile* tile = prioritized_tile.tile();
+ if (tile->is_image_analysis_performed())
+ return;
+
+ std::vector<DrawImage> images_in_tile;
+ prioritized_tile.raster_source()->GetDiscardableImagesInRect(
+ tile->enclosing_layer_rect(), tile->contents_scale(), &images_in_tile);
+ WhichTree tree = tile->tiling()->tree();
+
+ std::vector<DrawImage> images_to_decode_before_raster;
+ std::vector<sk_sp<const SkImage>> images_to_checker;
+ for (auto& draw_image : images_in_tile) {
+ if (checker_image_tracker_.ShouldCheckerImage(draw_image.image(), tree))
+ images_to_checker.push_back(draw_image.image());
+ else
+ images_to_decode_before_raster.push_back(draw_image);
+ }
+ tile->SetImageAnalysisResult(std::move(images_to_decode_before_raster),
+ std::move(images_to_checker));
+}
+
void TileManager::ScheduleTasks(
const PrioritizedWorkToSchedule& work_to_schedule) {
const std::vector<PrioritizedTile>& tiles_that_need_to_be_rasterized =
@@ -821,10 +896,8 @@ void TileManager::ScheduleTasks(
DCHECK(tile->draw_info().requires_resource());
DCHECK(!tile->draw_info().resource());
- if (!tile->raster_task_) {
- tile->raster_task_ =
- CreateRasterTask(prioritized_tile, raster_color_space);
- }
+ // Raster task for these tiles should be created in AssignGpuMemoryToTiles.
+ DCHECK(tile->HasRasterTask());
TileTask* task = tile->raster_task_.get();
@@ -876,7 +949,6 @@ void TileManager::ScheduleTasks(
std::vector<scoped_refptr<TileTask>> new_locked_image_tasks =
image_controller_.SetPredecodeImages(std::move(new_locked_images),
tracing_info);
-
for (auto& task : new_locked_image_tasks) {
auto decode_it = std::find_if(graph_.nodes.begin(), graph_.nodes.end(),
[&task](const TaskGraph::Node& node) {
@@ -925,6 +997,12 @@ void TileManager::ScheduleTasks(
// in |raster_queue_|.
tile_task_manager_->ScheduleTasks(&graph_);
+ // Schedule running of the checker-image decode queue. This replaces the
+ // previously scheduled queue and effectively cancels image decodes from the
+ // previous queue, if not already started.
+ checker_image_tracker_.ScheduleImageDecodeQueue(
+ std::move(work_to_schedule.checker_image_decode_queue));
+
did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state",
@@ -933,8 +1011,11 @@ void TileManager::ScheduleTasks(
scoped_refptr<TileTask> TileManager::CreateRasterTask(
const PrioritizedTile& prioritized_tile,
- const gfx::ColorSpace& color_space) {
+ const gfx::ColorSpace& color_space,
+ CheckerImageTracker::ImageDecodeQueue* checker_image_decode_queue) {
Tile* tile = prioritized_tile.tile();
+ TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+ "TileManager::CreateRasterTask", "Tile", tile->id());
// Get the resource.
uint64_t resource_content_id = 0;
@@ -960,29 +1041,37 @@ scoped_refptr<TileTask> TileManager::CreateRasterTask(
playback_settings.skip_images =
prioritized_tile.priority().resolution == LOW_RESOLUTION;
- // Create and queue all image decode tasks that this tile depends on.
+ // Create and queue all image decode tasks that this tile depends on. Note
+ // that we need to store the images for decode tasks in
+ // |scheduled_draw_images_| since the tile might have been destroyed by the
+ // time the raster task finishes.
TileTask::Vector decode_tasks;
- std::vector<DrawImage>& images = scheduled_draw_images_[tile->id()];
- ImageIdFlatSet images_to_skip;
- images.clear();
+ std::vector<DrawImage>& images_to_decode_for_raster =
+ scheduled_draw_images_[tile->id()];
+ images_to_decode_for_raster.clear();
if (!playback_settings.skip_images) {
- prioritized_tile.raster_source()->GetDiscardableImagesInRect(
- tile->enclosing_layer_rect(), tile->contents_scale(), &images);
- checker_image_tracker_.FilterImagesForCheckeringForTile(
- &images, &images_to_skip, prioritized_tile.tile()->tiling()->tree());
+ EnsureImageAnalysisPerformed(prioritized_tile);
+ images_to_decode_for_raster = tile->images_to_decode_before_raster();
+ for (const auto& image : tile->images_to_checker()) {
+ ImageId image_id = image->uniqueID();
+ playback_settings.images_to_skip.insert(image_id);
+ checker_image_decode_queue->push_back(image);
+ }
}
// We can skip the image hijack canvas if we have no images, or no images to
// skip during raster.
playback_settings.use_image_hijack_canvas =
- !images.empty() || !images_to_skip.empty();
- playback_settings.images_to_skip = std::move(images_to_skip);
+ !images_to_decode_for_raster.empty() ||
+ !playback_settings.images_to_skip.empty();
+ tile->set_raster_task_scheduled_with_checker_images(
+ !playback_settings.images_to_skip.empty());
// Get the tasks for the required images.
ImageDecodeCache::TracingInfo tracing_info(
prepare_tiles_count_, prioritized_tile.priority().priority_bin);
- image_controller_.GetTasksForImagesAndRef(&images, &decode_tasks,
- tracing_info);
+ image_controller_.GetTasksForImagesAndRef(&images_to_decode_for_raster,
+ &decode_tasks, tracing_info);
std::unique_ptr<RasterBuffer> raster_buffer =
raster_buffer_provider_->AcquireBufferForRaster(
@@ -1007,10 +1096,13 @@ void TileManager::OnRasterTaskCompleted(
auto found = tiles_.find(tile_id);
Tile* tile = nullptr;
+ bool raster_task_was_scheduled_with_checker_images = false;
if (found != tiles_.end()) {
tile = found->second;
DCHECK(tile->raster_task_.get());
tile->raster_task_ = nullptr;
+ raster_task_was_scheduled_with_checker_images =
+ tile->set_raster_task_scheduled_with_checker_images(false);
}
// Unref all the images.
@@ -1033,7 +1125,8 @@ void TileManager::OnRasterTaskCompleted(
}
TileDrawInfo& draw_info = tile->draw_info();
- draw_info.set_resource(resource);
+ draw_info.set_resource(resource,
+ raster_task_was_scheduled_with_checker_images);
draw_info.contents_swizzled_ = DetermineResourceRequiresSwizzle(tile);
// In SMOOTHNESS_TAKES_PRIORITY mode, we wait for GPU work to complete for a
« no previous file with comments | « cc/tiles/tile_manager.h ('k') | cc/tiles/tiling_set_raster_queue_all.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698