Send memory management policies to the tile manager

cc/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/tile_manager.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 20 matching lines @@
 // low while making sure raster threads aren't unnecessarily idle.
 const int kNumPendingRasterTasksPerThread = 2;
 
 // Determine bin based on three categories of tiles: things we need now,
 // things we need soon, and eventually.
 cc::TileManagerBin BinFromTilePriority(const cc::TilePriority& prio) {
 
   // The amount of time for which we want to have prepainting coverage.
   const double prepainting_window_time_seconds = 1.0;
   const double backfling_guard_distance_pixels = 314.0;
+  const double maximum_paint_distance_pixels = 4096.0;
 
   if (prio.time_to_needed_in_seconds() == std::numeric_limits<float>::max())
     return cc::NEVER_BIN;
 
+  if (prio.distance_to_visible_in_pixels > maximum_paint_distance_pixels)

[ccameron, 2012/12/26 23:55:54]

I discussed this with Nat earlier. If we allow the renderer to use, say, 1GB of
memory, and the page is really long, the tile manager will go ahead and burn
through all of that. This prevents any of that sort of insanity.

There are other options here (like, allow 4k pixels of low-res and 2k pixels of
high-res), or something like that. Let me know if that's preferred.

[enne (OOO), 2012/12/27 22:06:39]

This seems pretty reasonable to me for the moment.  We don't even have low res
tiles being generated by default yet (ack).  I think this is something that will
probably need tuning in the future, so am fine with an initial heuristic.

+    return cc::NEVER_BIN;
+
   if (prio.resolution == cc::NON_IDEAL_RESOLUTION)
     return cc::EVENTUALLY_BIN;
 
   if (prio.time_to_needed_in_seconds() == 0 ||
       prio.distance_to_visible_in_pixels < backfling_guard_distance_pixels)
     return cc::NOW_BIN;
 
   if (prio.time_to_needed_in_seconds() < prepainting_window_time_seconds)
     return cc::SOON_BIN;
 
@@ skipping 85 matching lines @@
   int num_pending_tasks_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterThread);
 };
 
 ManagedTileState::ManagedTileState()
     : can_use_gpu_memory(false),
       can_be_freed(true),
       resource_is_being_initialized(false),
       contents_swizzled(false),
-      need_to_gather_pixel_refs(true) {
+      need_to_gather_pixel_refs(true),
+      gpu_memmgr_stats_bin(NEVER_BIN) {
 }
 
 ManagedTileState::~ManagedTileState() {
   DCHECK(!resource);
   DCHECK(!resource_is_being_initialized);
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
@@ skipping 24 matching lines @@
   // This should finish all pending raster tasks and release any
   // uninitialized resources.
   raster_threads_.clear();
   ManageTiles();
   DCHECK(tiles_.size() == 0);
 }
 
 void TileManager::SetGlobalState(const GlobalStateThatImpactsTilePriority& global_state) {
   global_state_ = global_state;
   resource_pool_->SetMaxMemoryUsageBytes(global_state_.memory_limit_in_bytes);
-  ScheduleManageTiles();
+  ManageTiles();

[ccameron, 2012/12/26 23:55:54]

Be sure to verify whether or not this change is acceptable. This makes it so
that if we say "change your memory policy", then that call immediately has an
effect.

After being told "change your memory policy", we report the statistics of the
new policy to the GPU memory manager -- without doing this change immediately,
we will just report the old statistics (confusing everyone).

[enne (OOO), 2012/12/27 22:06:39]

This feels a little heavy handed.  I think I would expect this to
ScheduleManageTiles but not to ManageTiles.    Is there a better place to be
sending stats from in impl-side painting?

[ccameron, 2012/12/27 22:42:59]

Yes, this wasn't the right way to do it. I changed it to add a "send stats"
method to the tile manager's proxy, so we can send stats (if sufficiently
changed) automatically after ManageTiles gets executed, and I changed the other
send-stats function to early-out if there exists a tile manager.

[enne (OOO), 2012/12/27 23:02:00]

That sounds a lot better.  :)

 }
 
 void TileManager::RegisterTile(Tile* tile) {
   tiles_.push_back(tile);
   ScheduleManageTiles();
 }
 
 void TileManager::UnregisterTile(Tile* tile) {
   for (TileList::iterator it = tiles_with_image_decoding_tasks_.begin();
        it != tiles_with_image_decoding_tasks_.end(); it++) {
@@ skipping 73 matching lines @@
 
     TilePriority prio;
     if (smoothness_takes_priority)
       prio = tile->priority(ACTIVE_TREE);
     else
       prio = tile->combined_priority();
 
     mts.resolution = prio.resolution;
     mts.time_to_needed_in_seconds = prio.time_to_needed_in_seconds();
     mts.raster_bin = BinFromTilePriority(prio);
+    mts.gpu_memmgr_stats_bin = BinFromTilePriority(tile->combined_priority());

[ccameron, 2012/12/26 23:55:54]

I keep this bin around permanently so that we may compute statistics from it --
this is the behavior if the GPU memory manager were maximally permissive.

   }
 
   // Memory limit policy works by mapping some bin states to the NEVER bin.
   TileManagerBin bin_map[NUM_BINS];
   if (global_state_.memory_limit_policy == ALLOW_NOTHING) {
     bin_map[NOW_BIN] = NEVER_BIN;
     bin_map[SOON_BIN] = NEVER_BIN;
     bin_map[EVENTUALLY_BIN] = NEVER_BIN;
     bin_map[NEVER_BIN] = NEVER_BIN;
   } else if (global_state_.memory_limit_policy == ALLOW_ABSOLUTE_MINIMUM) {
@@ skipping 93 matching lines @@
 
 int TileManager::GetDrawableTilesInBinCount(
     TileManagerBin bin, WhichTree tree) {
   DCHECK(bin >= 0);
   DCHECK(bin < NUM_BINS);
   DCHECK(tree >= 0);
   DCHECK(tree < NUM_TREES);
   return drawable_tiles_in_bin_count_[bin][tree];
 }
 
+void TileManager::GetManagedMemoryStats(
+    size_t* memoryVisibleBytes,
+    size_t* memoryVisibleAndNearbyBytes,
+    size_t* memoryAllocated) {
+  *memoryVisibleBytes = 0;
+  *memoryVisibleAndNearbyBytes = 0;
+  *memoryAllocated = 0;
+  for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
+    Tile* tile = *it;
+    ManagedTileState& mts = tile->managed_state();
+    size_t tile_bytes = tile->bytes_consumed_if_allocated();
+    if (mts.gpu_memmgr_stats_bin == NOW_BIN)
+      *memoryVisibleBytes += tile_bytes;
+    if (mts.gpu_memmgr_stats_bin != NEVER_BIN)
+      *memoryVisibleAndNearbyBytes += tile_bytes;
+    if (mts.can_use_gpu_memory)
+      *memoryAllocated += tile_bytes;
+  }
+}
+
 void TileManager::ResetBinCounts() {
   for (int i = 0; i < NUM_BINS; ++i)
     for (int j = 0; j < NUM_TREES; ++j)
       tiles_in_bin_count_[i][j] = drawable_tiles_in_bin_count_[i][j] = 0;
 }
 
 void TileManager::AssignGpuMemoryToTiles() {
   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
   // Some memory cannot be released. Figure out which.
   size_t unreleasable_bytes = 0;
@@ skipping 273 matching lines @@
 void TileManager::DidFinishTileInitialization(Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.resource);
   managed_tile_state.resource_is_being_initialized = false;
   managed_tile_state.can_be_freed = true;
   for (int i = 0; i < NUM_TREES; ++i)
     drawable_tiles_in_bin_count_[managed_tile_state.bin[i]][i]++;
 }
 
 }