cc: Speed up CleanUpImageDecodeTasks a bit.

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 172 matching lines @@
       global_state_.memory_limit_in_bytes,
       global_state_.unused_memory_limit_in_bytes,
       global_state_.num_resources_limit);
 }
 
 void TileManager::RegisterTile(Tile* tile) {
   DCHECK(!tile->required_for_activation());
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile;
+  used_layer_counts_[tile->layer_id()]++;
   prioritized_tiles_dirty_ = true;
 }
 
 void TileManager::UnregisterTile(Tile* tile) {
   FreeResourcesForTile(tile);
 
   DCHECK(tiles_.find(tile->id()) != tiles_.end());
   tiles_.erase(tile->id());
+
+  DCHECK_GT(used_layer_counts_[tile->layer_id()], 0);
+  used_layer_counts_[tile->layer_id()]--;
+
   prioritized_tiles_dirty_ = true;
 }
 
 void TileManager::DidChangeTilePriority(Tile* tile) {
   prioritized_tiles_dirty_ = true;
 }
 
 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
   return GlobalState().tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 }
@@ skipping 402 matching lines @@
   memory_stats_from_last_assign_.total_budget_in_bytes =
       global_state_.memory_limit_in_bytes;
   memory_stats_from_last_assign_.bytes_allocated =
       bytes_allocatable - bytes_left;
   memory_stats_from_last_assign_.bytes_unreleasable =
       bytes_allocatable - bytes_releasable_;
   memory_stats_from_last_assign_.bytes_over =
       bytes_that_exceeded_memory_budget;
 }
 
 void TileManager::CleanUpUnusedImageDecodeTasks() {

[reveman, 2013/09/04 18:18:52]

can we clean up this function somehow? I find it hard to follow what is done
here after this change.

[vmpstr, 2013/09/04 19:36:40]

Done.

   if (image_decode_tasks_.empty())
     return;
 
-  // Calculate a set of layers that are used by at least one tile.
-  base::hash_set<int> used_layers;
-  for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-    used_layers.insert(it->second->layer_id());
+  std::vector<int> unused_layers;
+  for (LayerCountMap::iterator it = used_layer_counts_.begin();
+       it != used_layer_counts_.end();
+       ++it) {
+    if (it->second == 0)
+      unused_layers.push_back(it->first);
+  }
 
   // Now calculate the set of layers in |image_decode_tasks_| that are not used
   // by any tile.
-  std::vector<int> unused_layers;
   for (LayerPixelRefTaskMap::iterator it = image_decode_tasks_.begin();
        it != image_decode_tasks_.end();
        ++it) {

[reveman, 2013/09/04 18:18:52]

do we need this loop at all?

[tomhudson, 2013/09/04 18:38:34]

Is it there just for safety? (If we somehow have a task whose layer isn't in the
used_layer_counts_ list at all...)

It'd be less necessary insurance if we didn't do the used_layer_counts_.erase()
in 654, but if the set of layer IDs can get large that's no good.

[vmpstr, 2013/09/04 19:36:40]

Yeah I think this was just insurance. The layer ids in used_layer_counts
contains all of the layer ids in image_decode_tasks (and possibly then some). So
it's sufficient to just check the "refcount" on the layer counts to determine if
the layer is not used. If it isn't, we can delete it from both maps.

-    if (used_layers.find(it->first) == used_layers.end())
+    if (used_layer_counts_.find(it->first) == used_layer_counts_.end())
       unused_layers.push_back(it->first);
   }
 
   // Erase unused layers from |image_decode_tasks_|.

[tomhudson, 2013/09/04 18:38:34]

Nit: comment now incomplete.

[vmpstr, 2013/09/04 19:36:40]

Done.

   for (std::vector<int>::iterator it = unused_layers.begin();
        it != unused_layers.end();
        ++it) {
     image_decode_tasks_.erase(*it);
+    used_layer_counts_.erase(*it);
   }
 }
 
 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) {
   ManagedTileState& mts = tile->managed_state();
   if (mts.tile_versions[mode].resource_) {
     resource_pool_->ReleaseResource(
         mts.tile_versions[mode].resource_.Pass());
 
     DCHECK_GE(bytes_releasable_, tile->bytes_consumed_if_allocated());
@@ skipping 189 matching lines @@
     bytes_releasable_ += tile->bytes_consumed_if_allocated();
     ++resources_releasable_;
   }
 
   FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
 }
 
 }  // namespace cc