WIP GPU scheduler + delayed activation / tile draw

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 348 matching lines @@
       more_tiles_need_prepare_check_notifier_(
           task_runner_,
           base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared,
                      base::Unretained(this))),
       signals_check_notifier_(task_runner_,
                               base::Bind(&TileManager::CheckAndIssueSignals,
                                          base::Unretained(this))),
       has_scheduled_tile_tasks_(false),
       prepare_tiles_count_(0u),
       next_tile_id_(0u),
-      task_set_finished_weak_ptr_factory_(this) {}
+      task_set_finished_weak_ptr_factory_(this),
+      weak_ptr_factory_(this) {}
 
 TileManager::~TileManager() {
   FinishTasksAndCleanUp();
 }
 
 void TileManager::FinishTasksAndCleanUp() {
   if (!tile_task_manager_)
     return;
 
   global_state_ = GlobalStateThatImpactsTilePriority();
@@ skipping 62 matching lines @@
   released_tiles_.swap(tiles_to_retain);
 }
 
 void TileManager::DidFinishRunningTileTasksRequiredForActivation() {
   TRACE_EVENT0("cc",
                "TileManager::DidFinishRunningTileTasksRequiredForActivation");
   TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state",
                                ScheduledTasksStateAsValue());
   // TODO(vmpstr): Temporary check to debug crbug.com/642927.
   CHECK(tile_task_manager_);
+
   signals_.ready_to_activate = true;
   signals_check_notifier_.Schedule();
 }
 
 void TileManager::DidFinishRunningTileTasksRequiredForDraw() {
   TRACE_EVENT0("cc", "TileManager::DidFinishRunningTileTasksRequiredForDraw");
   TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state",
                                ScheduledTasksStateAsValue());
   // TODO(vmpstr): Temporary check to debug crbug.com/642927.
   CHECK(tile_task_manager_);
+
   signals_.ready_to_draw = true;
   signals_check_notifier_.Schedule();
 }
 
 void TileManager::DidFinishRunningAllTileTasks() {
   TRACE_EVENT0("cc", "TileManager::DidFinishRunningAllTileTasks");
   TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this);
   DCHECK(resource_pool_);
   DCHECK(tile_task_manager_);
 
@@ skipping 60 matching lines @@
   TRACE_EVENT0("cc", "TileManager::Flush");
 
   if (!tile_task_manager_) {
     TRACE_EVENT_INSTANT0("cc", "Flush aborted", TRACE_EVENT_SCOPE_THREAD);
     return;
   }
 
   tile_task_manager_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
+  CheckRequiredForActivationTilesReadyToDraw();
+  CheckRequiredForDrawTilesReadyToDraw();
+
   TRACE_EVENT_INSTANT1("cc", "DidFlush", TRACE_EVENT_SCOPE_THREAD, "stats",
                        RasterTaskCompletionStatsAsValue(flush_stats_));
   flush_stats_ = RasterTaskCompletionStats();
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 TileManager::BasicStateAsValue() const {
   std::unique_ptr<base::trace_event::TracedValue> value(
       new base::trace_event::TracedValue());
   BasicStateAsValueInto(value.get());
@@ skipping 91 matching lines @@
   all_tiles_that_need_to_be_rasterized_are_scheduled_ = true;
   bool had_enough_memory_to_schedule_tiles_needed_now = true;
 
   MemoryUsage hard_memory_limit(global_state_.hard_memory_limit_in_bytes,
                                 global_state_.num_resources_limit);
   MemoryUsage soft_memory_limit(global_state_.soft_memory_limit_in_bytes,
                                 global_state_.num_resources_limit);
   MemoryUsage memory_usage(resource_pool_->memory_usage_bytes(),
                            resource_pool_->resource_count());
 
+  pending_required_for_activation_tiles_.clear();
+  pending_required_for_draw_tiles_.clear();
+
   std::unique_ptr<RasterTilePriorityQueue> raster_priority_queue(
       client_->BuildRasterQueue(global_state_.tree_priority,
                                 RasterTilePriorityQueue::Type::ALL));
   std::unique_ptr<EvictionTilePriorityQueue> eviction_priority_queue;
   PrioritizedWorkToSchedule work_to_schedule;
   for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
     const PrioritizedTile& prioritized_tile = raster_priority_queue->Top();
     Tile* tile = prioritized_tile.tile();
     TilePriority priority = prioritized_tile.priority();
 
@@ skipping 26 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;
     }
 
+    if (tile->required_for_activation())
+      pending_required_for_activation_tiles_.push_back(tile);
+
+    if (tile->required_for_draw())
+      pending_required_for_draw_tiles_.push_back(tile);
+
+    // If tile already has a resource then its raster task has completed but
+    // we're still waiting on raster to complete on the service side.
+    // TODO(sunnyps): Mark such tiles as ready to draw if not in smoothness
+    // takes priority mode.
+    if (tile->draw_info().has_resource()) {
+      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 ||
            !tile->draw_info().IsReadyToDraw());
 
     // If the tile already has a raster_task, then the memory used by it is
     // already accounted for in memory_usage. Otherwise, we'll have to acquire
     // more memory to create a raster task.
     MemoryUsage memory_required_by_tile_to_be_scheduled;
-    if (!tile->raster_task_.get()) {
+    if (!tile->raster_task_) {
       memory_required_by_tile_to_be_scheduled = MemoryUsage::FromConfig(
           tile->desired_texture_size(), DetermineResourceFormat(tile));
     }
 
     // This is the memory limit that will be used by this tile. Depending on
     // the tile priority, it will be one of hard_memory_limit or
     // soft_memory_limit.
     MemoryUsage& tile_memory_limit =
         tile_is_needed_now ? hard_memory_limit : soft_memory_limit;
 
@@ skipping 41 matching lines @@
   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;
 
   TRACE_EVENT_END2("cc", "TileManager::AssignGpuMemoryToTiles",
                    "all_tiles_that_need_to_be_rasterized_are_scheduled",
                    all_tiles_that_need_to_be_rasterized_are_scheduled_,
                    "had_enough_memory_to_schedule_tiles_needed_now",
                    had_enough_memory_to_schedule_tiles_needed_now);
+
   return work_to_schedule;
 }
 
 void TileManager::FreeResourcesForTile(Tile* tile) {
   TileDrawInfo& draw_info = tile->draw_info();
-  if (draw_info.resource_) {
-    resource_pool_->ReleaseResource(draw_info.resource_);
-    draw_info.resource_ = nullptr;
+  if (draw_info.has_resource()) {
+    resource_pool_->ReleaseResource(draw_info.resource());
+    draw_info.set_resource(nullptr);
+    draw_info.set_ready_to_draw(false);
   }
 }
 
 void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(
     Tile* tile) {
   bool was_ready_to_draw = tile->draw_info().IsReadyToDraw();
   FreeResourcesForTile(tile);
   if (was_ready_to_draw)
     client_->NotifyTileStateChanged(tile);
 }
@@ skipping 174 matching lines @@
 
   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);
   }
 
+  tile->draw_info().set_use_resource();
+  DCHECK(!tile->draw_info().IsReadyToDraw());
+
   // 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.
   TileTask::Vector decode_tasks;
   std::vector<DrawImage>& images = scheduled_draw_images_[tile->id()];
   images.clear();
   if (!playback_settings.skip_images) {
@@ skipping 20 matching lines @@
       use_gpu_rasterization_));
 }
 
 void TileManager::OnRasterTaskCompleted(
     std::unique_ptr<RasterBuffer> raster_buffer,
     Tile* tile,
     Resource* resource,
     bool was_canceled) {
   DCHECK(tile);
   DCHECK(tiles_.find(tile->id()) != tiles_.end());
+
+  TRACE_EVENT1("cc", "TileManager::OnRasterTaskCompleted", "tile_id",
+               tile->id());
+
   raster_buffer_provider_->ReleaseBufferForRaster(std::move(raster_buffer));
 
-  TileDrawInfo& draw_info = tile->draw_info();
-  DCHECK(tile->raster_task_.get());
-  tile->raster_task_ = nullptr;
+  DCHECK(tile->raster_task_);
+  orphan_tasks_.push_back(std::move(tile->raster_task_));
 
   // 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;
 
-  draw_info.set_use_resource();
-  draw_info.resource_ = resource;
-  draw_info.contents_swizzled_ = DetermineResourceRequiresSwizzle(tile);
+  TileDrawInfo& draw_info = tile->draw_info();
+  draw_info.set_resource(resource);
+  draw_info.set_contents_swizzled(DetermineResourceRequiresSwizzle(tile));
+}
 
-  DCHECK(draw_info.IsReadyToDraw());
+void TileManager::OnRequiredForActivationTilesReadyToDraw() {
+  signals_.ready_to_activate = true;
+  signals_check_notifier_.Schedule();
+}
+
+void TileManager::OnRequiredForDrawTilesReadyToDraw() {
+  signals_.ready_to_draw = true;
+  signals_check_notifier_.Schedule();
+}
+
+void TileManager::CheckRequiredForActivationTilesReadyToDraw() {
+  std::vector<Tile*> pending_tiles;
+  for (Tile* tile : pending_required_for_activation_tiles_) {
+    const Resource* resource = tile->draw_info().resource();
+    if (resource && raster_buffer_provider_->IsResourceReadyToDraw(resource)) {
+      OnTileReadyToDraw(tile);
+    } else {
+      pending_tiles.push_back(tile);
+    }
+  }
+  pending_required_for_activation_tiles_.swap(pending_tiles);
+
+  std::vector<const Resource*> resources;
+  for (Tile* tile : pending_required_for_activation_tiles_) {
+    const Resource* resource = tile->draw_info().resource();
+    if (resource)
+      resources.push_back(resource);
+  }
+
+  if (!resources.empty()) {
+    raster_buffer_provider_->SignalResourcesReadyToDraw(
+        resources,
+        base::Bind(&TileManager::OnRequiredForActivationTilesReadyToDraw,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+}
+
+void TileManager::CheckRequiredForDrawTilesReadyToDraw() {
+  std::vector<Tile*> pending_tiles;
+  for (Tile* tile : pending_required_for_draw_tiles_) {
+    const Resource* resource = tile->draw_info().resource();
+    if (resource && raster_buffer_provider_->IsResourceReadyToDraw(resource)) {
+      OnTileReadyToDraw(tile);
+    } else {
+      pending_tiles.push_back(tile);
+    }
+  }
+  pending_required_for_draw_tiles_.swap(pending_tiles);
+
+  std::vector<const Resource*> resources;
+  for (Tile* tile : pending_required_for_activation_tiles_) {
+    const Resource* resource = tile->draw_info().resource();
+    if (resource)
+      resources.push_back(resource);
+  }
+
+  if (!resources.empty()) {
+    raster_buffer_provider_->SignalResourcesReadyToDraw(
+        resources, base::Bind(&TileManager::OnRequiredForDrawTilesReadyToDraw,
+                              weak_ptr_factory_.GetWeakPtr()));
+  }
+}
+
+void TileManager::OnTileReadyToDraw(Tile* tile) {
+  TRACE_EVENT1("cc", "TileManager::OnTileReadyToDraw", "tile_id", tile->id());
+
+  TileDrawInfo& draw_info = tile->draw_info();
+  if (draw_info.IsReadyToDraw())
+    return;
+
+  DCHECK_EQ(TileDrawInfo::RESOURCE_MODE, draw_info.mode());
+  DCHECK(draw_info.has_resource());
+  draw_info.set_ready_to_draw(true);
   draw_info.set_was_ever_ready_to_draw();
 
   client_->NotifyTileStateChanged(tile);
 }
 
 ScopedTilePtr TileManager::CreateTile(const Tile::CreateInfo& info,
                                       int layer_id,
                                       int source_frame_number,
                                       int flags) {
   // We need to have a tile task worker pool to do anything meaningful with
@@ skipping 46 matching lines @@
 }
 
 void TileManager::CheckAndIssueSignals() {
   TRACE_EVENT0("cc", "TileManager::CheckAndIssueSignals");
   tile_task_manager_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   // Ready to activate.
   if (signals_.ready_to_activate && !signals_.did_notify_ready_to_activate) {
     signals_.ready_to_activate = false;
+    CheckRequiredForActivationTilesReadyToDraw();
     if (IsReadyToActivate()) {
       TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                    "TileManager::CheckAndIssueSignals - ready to activate");
       signals_.did_notify_ready_to_activate = true;
       client_->NotifyReadyToActivate();
     }
   }
 
   // Ready to draw.
   if (signals_.ready_to_draw && !signals_.did_notify_ready_to_draw) {
     signals_.ready_to_draw = false;
+    CheckRequiredForDrawTilesReadyToDraw();
     if (IsReadyToDraw()) {
       TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                    "TileManager::CheckAndIssueSignals - ready to draw");
       signals_.did_notify_ready_to_draw = true;
       client_->NotifyReadyToDraw();
     }
   }
 
   // All tile tasks completed.
   if (signals_.all_tile_tasks_completed &&
@@ skipping 210 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