cc: Make eviction queue building consistent with raster.

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 222 matching lines @@
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToActivate,
                      base::Unretained(this))),
       ready_to_draw_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToDraw, base::Unretained(this))),
       more_tiles_need_prepare_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared,
                      base::Unretained(this))),
-      eviction_priority_queue_is_up_to_date_(false),
       did_notify_ready_to_activate_(false),
       did_notify_ready_to_draw_(false) {
   tile_task_runner_->SetClient(this);
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
 
@@ skipping 113 matching lines @@
     AssignGpuMemoryToTiles(&raster_priority_queue, scheduled_raster_task_limit_,
                            &tiles_that_need_to_be_rasterized);
 
     // Schedule tile tasks.
     ScheduleTasks(tiles_that_need_to_be_rasterized);
 
     did_notify_ready_to_activate_ = false;
     did_notify_ready_to_draw_ = false;
   } else {
     if (global_state_.hard_memory_limit_in_bytes == 0) {
-      // TODO(vmpstr): Add a function to unconditionally create an eviction
-      // queue and guard the rest of the calls sites with this flag, instead of
-      // clearing here and building, which is a bit awkward.
-      eviction_priority_queue_is_up_to_date_ = false;
       resource_pool_->CheckBusyResources(false);
       MemoryUsage memory_limit(0, 0);
       MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
                                resource_pool_->acquired_resource_count());
       FreeTileResourcesUntilUsageIsWithinLimit(memory_limit, &memory_usage);
+      eviction_priority_queue_.reset();
     }
 
     did_notify_ready_to_activate_ = false;
     did_notify_ready_to_draw_ = false;
     ready_to_activate_notifier_.Schedule();
     ready_to_draw_notifier_.Schedule();
   }
 
   TRACE_EVENT_INSTANT1("cc", "DidPrepareTiles", TRACE_EVENT_SCOPE_THREAD,
                        "state", BasicStateAsValue());
@@ skipping 90 matching lines @@
 
 void TileManager::BasicStateAsValueInto(base::debug::TracedValue* state) const {
   state->SetInteger("tile_count", tiles_.size());
   state->SetBoolean("did_oom_on_last_assign", did_oom_on_last_assign_);
   state->BeginDictionary("global_state");
   global_state_.AsValueInto(state);
   state->EndDictionary();
 }
 
 void TileManager::RebuildEvictionQueueIfNeeded() {
-  TRACE_EVENT1("cc",
-               "TileManager::RebuildEvictionQueueIfNeeded",
-               "eviction_priority_queue_is_up_to_date",
-               eviction_priority_queue_is_up_to_date_);
-  if (eviction_priority_queue_is_up_to_date_)
+  TRACE_EVENT0("cc", "TileManager::RebuildEvictionQueueIfNeeded");
+  if (eviction_priority_queue_)
     return;
 
-  eviction_priority_queue_.Reset();
-  client_->BuildEvictionQueue(&eviction_priority_queue_,
-                              global_state_.tree_priority);
-  eviction_priority_queue_is_up_to_date_ = true;
+  eviction_priority_queue_ =
+      client_->BuildEvictionQueue(global_state_.tree_priority);
 }
 
 bool TileManager::FreeTileResourcesUntilUsageIsWithinLimit(
     const MemoryUsage& limit,
     MemoryUsage* usage) {
   while (usage->Exceeds(limit)) {
     RebuildEvictionQueueIfNeeded();
-    if (eviction_priority_queue_.IsEmpty())
+    if (eviction_priority_queue_->IsEmpty())
       return false;
 
-    Tile* tile = eviction_priority_queue_.Top();
+    Tile* tile = eviction_priority_queue_->Top();
     *usage -= MemoryUsage::FromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
-    eviction_priority_queue_.Pop();
+    eviction_priority_queue_->Pop();
   }
   return true;
 }
 
 bool TileManager::FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
     const MemoryUsage& limit,
     const TilePriority& other_priority,
     MemoryUsage* usage) {
   while (usage->Exceeds(limit)) {
     RebuildEvictionQueueIfNeeded();
-    if (eviction_priority_queue_.IsEmpty())
+    if (eviction_priority_queue_->IsEmpty())
       return false;
 
-    Tile* tile = eviction_priority_queue_.Top();
+    Tile* tile = eviction_priority_queue_->Top();
     if (!other_priority.IsHigherPriorityThan(tile->combined_priority()))
       return false;
 
     *usage -= MemoryUsage::FromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
-    eviction_priority_queue_.Pop();
+    eviction_priority_queue_->Pop();
   }
   return true;
 }
 
 bool TileManager::TilePriorityViolatesMemoryPolicy(
     const TilePriority& priority) {
   switch (global_state_.memory_limit_policy) {
     case ALLOW_NOTHING:
       return true;
     case ALLOW_ABSOLUTE_MINIMUM:
@@ skipping 26 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_->acquired_memory_usage_bytes(),
                            resource_pool_->acquired_resource_count());
 
-  eviction_priority_queue_is_up_to_date_ = false;
+  DCHECK(!eviction_priority_queue_);
   for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
     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;
     }
@@ skipping 44 matching lines @@
 
     memory_usage += memory_required_by_tile_to_be_scheduled;
     tiles_that_need_to_be_rasterized->push_back(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.
   FreeTileResourcesUntilUsageIsWithinLimit(hard_memory_limit, &memory_usage);
 
+  eviction_priority_queue_.reset();

[danakj, 2015/01/22 23:12:23]

Can you explain this? There's a DCHECK above that it's null. What in between
will make a queue?

[vmpstr, 2015/01/22 23:45:03]

Since creating an eviction queue might be expensive, we only create it if we
need it in FreeTileResources* function call. Since that eviction queue becomes
stale at the end of this call, I reset it so in the future we know to create a
new one (and that's what the DCHECK is checking). I've added a comment similar
to this. Please see if it's more clear.

I could also basically replace each call of
"eviction_priority_queue_is_up_to_date_" to eviction_priority_queue_.reset() if
that's cleaner. I kind of decided to do it after, instead of before the loop but
it shouldn't matter in practice.

+
   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;
 
@@ skipping 381 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