cc: Improve TileManager::GetMemoryStats() performance.

Avoid iterating over all tiles each time GetMemoryStats() is called by
instead collecting necessary memory stats in GetTilesWithAssignedBins().

BUG=267516
TEST=cc_perftests

Review URL: https://chromiumcodereview.appspot.com/23447014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@222558 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 35 insertions, 38 deletions

diff --git a/cc/resources/managed_tile_state.cc b/cc/resources/managed_tile_state.cc
index 4583e53..8856d4f 100644
--- a/cc/resources/managed_tile_state.cc
+++ b/cc/resources/managed_tile_state.cc
@@ -48,7 +48,6 @@ scoped_ptr<base::Value> ManagedTileBinAsValue(ManagedTileBin bin) {
 ManagedTileState::ManagedTileState()
     : raster_mode(LOW_QUALITY_RASTER_MODE),
       bin(NEVER_BIN),
-      gpu_memmgr_stats_bin(NEVER_BIN),
       resolution(NON_IDEAL_RESOLUTION),
       required_for_activation(false),
       time_to_needed_in_seconds(std::numeric_limits<float>::infinity()),
@@ -97,8 +96,6 @@ scoped_ptr<base::Value> ManagedTileState::AsValue() const {
              ManagedTileBinAsValue(tree_bin[ACTIVE_TREE]).release());
   state->Set("tree_bin.1",
              ManagedTileBinAsValue(tree_bin[PENDING_TREE]).release());
-  state->Set("gpu_memmgr_stats_bin",
-      ManagedTileBinAsValue(gpu_memmgr_stats_bin).release());
   state->Set("resolution", TileResolutionAsValue(resolution).release());
   state->Set("time_to_needed_in_seconds",
       MathUtil::AsValueSafely(time_to_needed_in_seconds).release());
diff --git a/cc/resources/managed_tile_state.h b/cc/resources/managed_tile_state.h
index 467c4e7..35e4415 100644
--- a/cc/resources/managed_tile_state.h
+++ b/cc/resources/managed_tile_state.h
@@ -127,10 +127,6 @@ class CC_EXPORT ManagedTileState {
   ManagedTileBin bin;
   ManagedTileBin tree_bin[NUM_TREES];
 
-  // The bin that the tile would have if the GPU memory manager had
-  // a maximally permissive policy, send to the GPU memory manager
-  // to determine policy.
-  ManagedTileBin gpu_memmgr_stats_bin;
   TileResolution resolution;
   bool required_for_activation;
   float time_to_needed_in_seconds;
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 3d1ce0be..b845eaf 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -152,6 +152,8 @@ TileManager::TileManager(
       prioritized_tiles_dirty_(false),
       all_tiles_that_need_to_be_rasterized_have_memory_(true),
       all_tiles_required_for_activation_have_memory_(true),
+      memory_required_bytes_(0),
+      memory_nice_to_have_bytes_(0),
       bytes_releasable_(0),
       resources_releasable_(0),
       ever_exceeded_memory_budget_(false),
@@ -283,6 +285,10 @@ void TileManager::DidFinishRunningTasksRequiredForActivation() {
 void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) {
   TRACE_EVENT0("cc", "TileManager::GetTilesWithAssignedBins");
 
+  // Compute new stats to be return by GetMemoryStats().
+  memory_required_bytes_ = 0;
+  memory_nice_to_have_bytes_ = 0;
+
   const TileMemoryLimitPolicy memory_policy = global_state_.memory_limit_policy;
   const TreePriority tree_priority = global_state_.tree_priority;
 
@@ -291,7 +297,9 @@ void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) {
     Tile* tile = it->second;
     ManagedTileState& mts = tile->managed_state();
 
-    bool tile_is_ready_to_draw = tile->IsReadyToDraw();
+    const ManagedTileState::TileVersion& tile_version =
+        tile->GetTileVersionForDrawing();
+    bool tile_is_ready_to_draw = tile_version.IsReadyToDraw();
     bool tile_is_active =
         tile_is_ready_to_draw ||
         !mts.tile_versions[mts.raster_mode].raster_task_.is_null();
@@ -314,28 +322,39 @@ void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) {
                                                       tree_priority,
                                                       tile_is_ready_to_draw,
                                                       tile_is_active);
-    // Note that |gpu_memmgr_stats_bin| does not care about memory_policy, so we
-    // have to save it first.
-    mts.gpu_memmgr_stats_bin = combined_bin;
 
-    combined_bin = kBinPolicyMap[memory_policy][combined_bin];
+    // The bin that the tile would have if the GPU memory manager had
+    // a maximally permissive policy, send to the GPU memory manager
+    // to determine policy.
+    ManagedTileBin gpu_memmgr_stats_bin = NEVER_BIN;
 
     TilePriority* high_priority = NULL;
     switch (tree_priority) {
       case SAME_PRIORITY_FOR_BOTH_TREES:
-        mts.bin = combined_bin;
+        mts.bin = kBinPolicyMap[memory_policy][combined_bin];
+        gpu_memmgr_stats_bin = combined_bin;
         high_priority = &combined_priority;
         break;
       case SMOOTHNESS_TAKES_PRIORITY:
         mts.bin = mts.tree_bin[ACTIVE_TREE];
+        gpu_memmgr_stats_bin = active_bin;
         high_priority = &active_priority;
         break;
       case NEW_CONTENT_TAKES_PRIORITY:
         mts.bin = mts.tree_bin[PENDING_TREE];
+        gpu_memmgr_stats_bin = pending_bin;
         high_priority = &pending_priority;
         break;
     }
 
+    if (!tile_is_ready_to_draw || tile_version.requires_resource()) {
+      if ((gpu_memmgr_stats_bin == NOW_BIN) ||
+          (gpu_memmgr_stats_bin == NOW_AND_READY_TO_DRAW_BIN))
+        memory_required_bytes_ += tile->bytes_consumed_if_allocated();
+      if (gpu_memmgr_stats_bin != NEVER_BIN)
+        memory_nice_to_have_bytes_ += tile->bytes_consumed_if_allocated();
+    }
+
     // Bump up the priority if we determined it's NEVER_BIN on one tree,
     // but is still required on the other tree.
     bool is_in_never_bin_on_both_trees =
@@ -416,29 +435,10 @@ void TileManager::GetMemoryStats(
     size_t* memory_nice_to_have_bytes,
     size_t* memory_allocated_bytes,
     size_t* memory_used_bytes) const {
-  *memory_required_bytes = 0;
-  *memory_nice_to_have_bytes = 0;
+  *memory_required_bytes = memory_required_bytes_;
+  *memory_nice_to_have_bytes = memory_nice_to_have_bytes_;
   *memory_allocated_bytes = resource_pool_->total_memory_usage_bytes();
   *memory_used_bytes = resource_pool_->acquired_memory_usage_bytes();
-  for (TileMap::const_iterator it = tiles_.begin();
-       it != tiles_.end();
-       ++it) {
-    const Tile* tile = it->second;
-    const ManagedTileState& mts = tile->managed_state();
-
-    const ManagedTileState::TileVersion& tile_version =
-        tile->GetTileVersionForDrawing();
-    if (tile_version.IsReadyToDraw() &&
-        !tile_version.requires_resource())
-      continue;
-
-    size_t tile_bytes = tile->bytes_consumed_if_allocated();
-    if ((mts.gpu_memmgr_stats_bin == NOW_BIN) ||
-        (mts.gpu_memmgr_stats_bin == NOW_AND_READY_TO_DRAW_BIN))
-      *memory_required_bytes += tile_bytes;
-    if (mts.gpu_memmgr_stats_bin != NEVER_BIN)
-      *memory_nice_to_have_bytes += tile_bytes;
-  }
 }
 
 scoped_ptr<base::Value> TileManager::BasicStateAsValue() const {
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index 1ac2689..b9297c2 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -165,6 +165,9 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
   bool all_tiles_that_need_to_be_rasterized_have_memory_;
   bool all_tiles_required_for_activation_have_memory_;
 
+  size_t memory_required_bytes_;
+  size_t memory_nice_to_have_bytes_;
+
   size_t bytes_releasable_;
   size_t resources_releasable_;
 
diff --git a/cc/resources/tile_manager_perftest.cc b/cc/resources/tile_manager_perftest.cc
index 0a1d762..e0d130b 100644
--- a/cc/resources/tile_manager_perftest.cc
+++ b/cc/resources/tile_manager_perftest.cc
@@ -130,18 +130,19 @@ class TileManagerPerfTest : public testing::Test {
 
   void RunManageTilesTest(const std::string& test_name,
                           unsigned tile_count,
-                          unsigned priority_change_percent) {
+                          int priority_change_percent) {
     DCHECK_GE(tile_count, 100u);
-    DCHECK_LE(priority_change_percent, 100u);
+    DCHECK_GE(priority_change_percent, 0);
+    DCHECK_LE(priority_change_percent, 100);
     TileBinVector tiles;
     CreateTiles(tile_count, &tiles);
     timer_.Reset();
     do {
-      if (priority_change_percent) {
+      if (priority_change_percent > 0) {
         for (unsigned i = 0;
              i < tile_count;
              i += 100 / priority_change_percent) {
-          Tile* tile = tiles[i].first;
+          Tile* tile = tiles[i].first.get();
           ManagedTileBin bin = GetNextBin(tiles[i].second);
           tile->SetPriority(ACTIVE_TREE, GetTilePriorityFromBin(bin));
           tile->SetPriority(PENDING_TREE, GetTilePriorityFromBin(bin));