cc: Optimize decode scheduling for checker-images.

cc/tiles/tile_manager.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/tiles/tile_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 663 matching lines @@
       }
     }
 
     // Prepaint tiles that are far away are only processed for images.
     if (!tile->required_for_activation() && !tile->required_for_draw() &&
         prioritized_tile.is_process_for_images_only()) {
       work_to_schedule.tiles_to_process_for_images.push_back(prioritized_tile);
       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_) {
       all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
       break;
     }
 
     tile->scheduled_priority_ = schedule_priority++;
 
     DCHECK(tile->draw_info().mode() == TileDrawInfo::OOM_MODE ||
@@ skipping 26 matching lines @@
     // If we couldn't fit the tile into our current memory limit, then we're
     // done.
     if (!memory_usage_is_within_limit) {
       if (tile_is_needed_now)
         had_enough_memory_to_schedule_tiles_needed_now = false;
       all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
       break;
     }
 
     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);
   }
 
   // Note that we should try and further reduce memory in case the above loop
   // didn't reduce memory. This ensures that we always release as many resources
   // as possible to stay within the memory limit.
   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;
 
   memory_stats_from_last_assign_.total_budget_in_bytes =
       global_state_.hard_memory_limit_in_bytes;
   memory_stats_from_last_assign_.total_bytes_used = memory_usage.memory_bytes();
   DCHECK_GE(memory_stats_from_last_assign_.total_bytes_used, 0);
   memory_stats_from_last_assign_.had_enough_memory =
       had_enough_memory_to_schedule_tiles_needed_now;
@@ skipping 16 matching lines @@
 }
 
 void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(
     Tile* tile) {
   bool was_ready_to_draw = tile->draw_info().IsReadyToDraw();
   FreeResourcesForTile(tile);
   if (was_ready_to_draw)
     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 =
       work_to_schedule.tiles_to_raster;
   TRACE_EVENT1("cc", "TileManager::ScheduleTasks", "count",
                tiles_that_need_to_be_rasterized.size());
 
   DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
 
   if (!has_scheduled_tile_tasks_) {
@@ skipping 29 matching lines @@
       CreateTaskSetFinishedTask(&TileManager::DidFinishRunningAllTileTasks);
 
   // Build a new task queue containing all task currently needed. Tasks
   // are added in order of priority, highest priority task first.
   for (auto& prioritized_tile : tiles_that_need_to_be_rasterized) {
     Tile* tile = prioritized_tile.tile();
 
     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();
 
     DCHECK(!task->HasCompleted());
 
     if (tile->required_for_activation()) {
       required_for_activate_count++;
       graph_.edges.push_back(
           TaskGraph::Edge(task, required_for_activation_done_task.get()));
     }
@@ skipping 31 matching lines @@
   }
 
   // TODO(vmpstr): SOON is misleading here, but these images can come from
   // several diffent tiles. Rethink what we actually want to trace here. Note
   // that I'm using SOON, since it can't be NOW (these are prepaint).
   ImageDecodeCache::TracingInfo tracing_info(prepare_tiles_count_,
                                              TilePriority::SOON);
   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) {
                                     return node.task == task.get();
                                   });
     // If this task is already in the graph, then we don't have to insert it.
     if (decode_it != graph_.nodes.end())
       continue;
 
     InsertNodeForDecodeTask(&graph_, task.get(), false, priority++);
@@ skipping 28 matching lines @@
                     kAllDoneTaskPriority, all_count);
 
   // Synchronize worker with compositor.
   raster_buffer_provider_->OrderingBarrier();
 
   // Schedule running of |raster_queue_|. This replaces any previously
   // scheduled tasks and effectively cancels all tasks not present
   // 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",
                                ScheduledTasksStateAsValue());
 }
 
 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;
   Resource* resource = nullptr;
   gfx::Rect invalidated_rect = tile->invalidated_content_rect();
   if (UsePartialRaster() && tile->invalidated_id()) {
     resource = resource_pool_->TryAcquireResourceForPartialRaster(
         tile->id(), tile->invalidated_content_rect(), tile->invalidated_id(),
         &invalidated_rect);
   }
 
   if (resource) {
     resource_content_id = tile->invalidated_id();
     DCHECK_EQ(DetermineResourceFormat(tile), resource->format());
   } else {
     resource = resource_pool_->AcquireResource(tile->desired_texture_size(),
                                                DetermineResourceFormat(tile),
                                                color_space);
   }
 
   // For LOW_RESOLUTION tiles, we don't draw or predecode images.
   RasterSource::PlaybackSettings playback_settings;
   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(
           resource, resource_content_id, tile->invalidated_id());
   return make_scoped_refptr(new RasterTaskImpl(
       this, tile, resource, prioritized_tile.raster_source(), playback_settings,
       prioritized_tile.priority().resolution, invalidated_rect,
       prepare_tiles_count_, std::move(raster_buffer), &decode_tasks,
       use_gpu_rasterization_));
 }
 
 void TileManager::ResetSignalsForTesting() {
   signals_.reset();
 }
 
 void TileManager::OnRasterTaskCompleted(
     std::unique_ptr<RasterBuffer> raster_buffer,
     Tile::Id tile_id,
     Resource* resource,
     bool was_canceled) {
   raster_buffer_provider_->ReleaseBufferForRaster(std::move(raster_buffer));
 
   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.
   auto images_it = scheduled_draw_images_.find(tile_id);
   image_controller_.UnrefImages(images_it->second);
   scheduled_draw_images_.erase(images_it);
 
   if (was_canceled) {
     ++flush_stats_.canceled_count;
     resource_pool_->ReleaseResource(resource);
     return;
   }
 
   resource_pool_->OnContentReplaced(resource->id(), tile_id);
   ++flush_stats_.completed_count;
 
   if (!tile) {
     resource_pool_->ReleaseResource(resource);
     return;
   }
 
   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
   // tile before setting it as ready to draw.
   if (global_state_.tree_priority == SMOOTHNESS_TAKES_PRIORITY &&
       !raster_buffer_provider_->IsResourceReadyToDraw(resource->id())) {
     pending_gpu_work_tiles_.insert(tile);
     return;
   }
 
@@ skipping 385 matching lines @@
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default;
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule(
     PrioritizedWorkToSchedule&& other) = default;
 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default;
 
 }  // namespace cc