cc: GPU rasterize tiles synchronously in PrepareToDraw

cc/resources/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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 311 matching lines @@
 
       // When OOM, keep re-assigning memory until we reach a steady state
       // where top-priority tiles are initialized.
       if (all_tiles_that_need_to_be_rasterized_are_scheduled_ &&
           !memory_usage_above_limit)
         return;
 
       rasterizer_->CheckForCompletedTasks();
       did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
+      client_->BuildRasterQueue(&raster_priority_queue_,
+                                global_state_.tree_priority);
       TileVector tiles_that_need_to_be_rasterized;
-      AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
+      AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized,
+                             scheduled_raster_task_limit_);
+      raster_priority_queue_.Reset();
 
       // |tiles_that_need_to_be_rasterized| will be empty when we reach a
       // steady memory state. Keep scheduling tasks until we reach this state.
       if (!tiles_that_need_to_be_rasterized.empty()) {
         ScheduleTasks(tiles_that_need_to_be_rasterized);
         return;
       }
 
       FreeResourcesForReleasedTiles();
 
       resource_pool_->ReduceResourceUsage();
 
       // We don't reserve memory for required-for-activation tiles during
       // accelerated gestures, so we just postpone activation when we don't
       // have these tiles, and activate after the accelerated gesture.
       // Likewise if we don't allow any tiles (as is the case when we're
       // invisible), if we have tiles that aren't ready, then we shouldn't
       // activate as activation can cause checkerboards.
       bool allow_rasterize_on_demand =
           global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY &&
           global_state_.memory_limit_policy != ALLOW_NOTHING;
 
       // Use on-demand raster for any required-for-activation tiles that have
-      // not
-      // been been assigned memory after reaching a steady memory state. This
-      // ensures that we activate even when OOM. Note that we have to rebuilt
-      // the
-      // queue in case the last AssignGpuMemoryToTiles evicted some tiles that
-      // would otherwise not be picked up by the old raster queue.
+      // not been been assigned memory after reaching a steady memory
+      // state. This ensures that we activate even when OOM. Note that we have
+      // to rebuilt the queue in case the last AssignGpuMemoryToTiles evicted
+      // some tiles that would otherwise not be picked up by the old raster
+      // queue.
       client_->BuildRasterQueue(&raster_priority_queue_,
                                 global_state_.tree_priority);
       bool ready_to_activate = true;
       while (!raster_priority_queue_.IsEmpty()) {
         Tile* tile = raster_priority_queue_.Top();
         ManagedTileState& mts = tile->managed_state();
 
         if (tile->required_for_activation() && !mts.draw_info.IsReadyToDraw()) {
           // If we can't raster on demand, give up early (and don't activate).
           if (!allow_rasterize_on_demand) {
@@ skipping 18 matching lines @@
       ready_to_activate_check_notifier_.Schedule();
       return;
     case REQUIRED_FOR_DRAW:
       ready_to_draw_check_notifier_.Schedule();
       return;
   }
 
   NOTREACHED();
 }
 
+void TileManager::RasterizeTiles(
+    const GlobalStateThatImpactsTilePriority& state) {
+  TRACE_EVENT0("cc", "TileManager::RasterizeTiles");
+
+  global_state_ = state;
+
+  FreeResourcesForReleasedTiles();
+  CleanUpReleasedTiles();
+
+  client_->BuildRasterQueue(&raster_priority_queue_,
+                            global_state_.tree_priority);
+  TileVector tiles_that_need_to_be_rasterized;
+  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized,
+                         std::numeric_limits<size_t>::max());
+
+  // Build a new task queue containing all task currently needed.
+  raster_queue_.Reset();
+  for (auto& tile : tiles_that_need_to_be_rasterized) {
+    ManagedTileState& mts = tile->managed_state();
+
+    if (!mts.raster_task.get())
+      mts.raster_task = CreateRasterTask(tile);
+
+    TaskSetCollection task_sets;
+    if (tile->required_for_draw())
+      task_sets.set(REQUIRED_FOR_DRAW);
+    task_sets.set(ALL);
+    raster_queue_.items.push_back(
+        RasterTaskQueue::Item(mts.raster_task.get(), task_sets));
+  }
+
+  // We must reduce the amount of unused resoruces before calling
+  // RunTasks to prevent usage from rising above limits.
+  resource_pool_->ReduceResourceUsage();
+
+  // Run and complete all raster task synchronously.
+  rasterizer_->RunTasks(&raster_queue_);
+
+  // Use on-demand raster for any tiles that have not been been assigned
+  // memory. This ensures that we draw even when OOM.
+  while (!raster_priority_queue_.IsEmpty()) {

[vmpstr, 2014/11/20 18:40:59]

I think you still need to reset/rebuilt raster_priority_queue. The situation
where it's important is if we get less memory than we've been using but all the
tiles are done rasterizing. In that case, raster queue will be empty, but
eviction will evict some tiles, which won't appear in the raster queue unless we
rebuild it.

[vmiura, 2014/11/20 20:10:10]

Is it possible for some required_for_draw tiles to evict other required_for_draw
tiles?

+    Tile* tile = raster_priority_queue_.Top();
+    ManagedTileState& mts = tile->managed_state();
+
+    if (!mts.draw_info.IsReadyToDraw()) {
+      mts.draw_info.set_rasterize_on_demand();
+      client_->NotifyTileStateChanged(tile);
+    }
+    raster_priority_queue_.Pop();
+  }
+  raster_priority_queue_.Reset();
+
+  if (IsReadyToDraw())
+    client_->NotifyReadyToDraw();
+
+  TRACE_EVENT_INSTANT1("cc", "DidRasterize", TRACE_EVENT_SCOPE_THREAD, "state",
+                       BasicStateAsValue());
+
+  TRACE_COUNTER_ID1("cc", "unused_memory_bytes", this,
+                    resource_pool_->total_memory_usage_bytes() -
+                        resource_pool_->acquired_memory_usage_bytes());
+}
+
 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
 
   global_state_ = state;
 
   // We need to call CheckForCompletedTasks() once in-between each call
   // to ScheduleTasks() to prevent canceled tasks from being scheduled.
   if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
     rasterizer_->CheckForCompletedTasks();
     did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
   }
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
 
+  client_->BuildRasterQueue(&raster_priority_queue_,
+                            global_state_.tree_priority);
   TileVector tiles_that_need_to_be_rasterized;
-  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
+  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized,
+                         scheduled_raster_task_limit_);
+  raster_priority_queue_.Reset();
 
   // Finally, schedule rasterizer tasks.
   ScheduleTasks(tiles_that_need_to_be_rasterized);
 
   TRACE_EVENT_INSTANT1("cc",
                        "DidManage",
                        TRACE_EVENT_SCOPE_THREAD,
                        "state",
                        BasicStateAsValue());
 
@@ skipping 96 matching lines @@
       return priority.priority_bin > TilePriority::SOON;
     case ALLOW_ANYTHING:
       return priority.distance_to_visible ==
              std::numeric_limits<float>::infinity();
   }
   NOTREACHED();
   return true;
 }
 
 void TileManager::AssignGpuMemoryToTiles(
-    TileVector* tiles_that_need_to_be_rasterized) {
+    TileVector* tiles_that_need_to_be_rasterized,
+    size_t scheduled_raster_task_limit) {
   TRACE_EVENT_BEGIN0("cc", "TileManager::AssignGpuMemoryToTiles");
 
   // Maintain the list of released resources that can potentially be re-used
   // or deleted.
   // If this operation becomes expensive too, only do this after some
   // resource(s) was returned. Note that in that case, one also need to
   // invalidate when releasing some resource from the pool.
   resource_pool_->CheckBusyResources(false);
 
   // Now give memory out to the tiles until we're out, and build
   // the needs-to-be-rasterized queue.
   unsigned schedule_priority = 1u;
   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_->acquired_memory_usage_bytes(),
                            resource_pool_->acquired_resource_count());
 
   eviction_priority_queue_is_up_to_date_ = false;
-  client_->BuildRasterQueue(&raster_priority_queue_,

[vmpstr, 2014/11/20 18:40:59]

What's the motivation for pulling this out of this function?

-                            global_state_.tree_priority);
 
   while (!raster_priority_queue_.IsEmpty()) {
     Tile* tile = raster_priority_queue_.Top();
     TilePriority priority = tile->combined_priority();
 
     if (TilePriorityViolatesMemoryPolicy(priority)) {
       TRACE_EVENT_INSTANT0(
           "cc",
           "TileManager::AssignGpuMemory tile violates memory policy",
           TRACE_EVENT_SCOPE_THREAD);
       break;
     }
 
     // We won't be able to schedule this tile, so break out early.
     if (tiles_that_need_to_be_rasterized->size() >=
-        scheduled_raster_task_limit_) {
+        scheduled_raster_task_limit) {
       all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
       break;
     }
 
     ManagedTileState& mts = tile->managed_state();
     mts.scheduled_priority = schedule_priority++;
     mts.resolution = priority.resolution;
 
     DCHECK(mts.draw_info.mode() ==
                ManagedTileState::DrawInfo::PICTURE_PILE_MODE ||
@@ skipping 44 matching lines @@
   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();
   memory_stats_from_last_assign_.had_enough_memory =
       had_enough_memory_to_schedule_tiles_needed_now;
 
-  raster_priority_queue_.Reset();
-
   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);
 }
 
 void TileManager::FreeResourcesForTile(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
@@ skipping 288 matching lines @@
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
   return memory_bytes_ > limit.memory_bytes_ ||
          resource_count_ > limit.resource_count_;
 }
 
 }  // namespace cc