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 21 matching lines @@
 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;
 
+  // Explicitly limit how far ahead we will prepaint for low and non-low res.
+  const double max_lores_paint_distance_pixels = 8192.0;
+  const double max_hires_paint_distance_pixels = 4096.0;
+  if (prio.resolution == cc::LOW_RESOLUTION) {
+    if (prio.distance_to_visible_in_pixels > max_lores_paint_distance_pixels)
+      return cc::NEVER_BIN;
+  }
+  else {
+    if (prio.distance_to_visible_in_pixels > max_hires_paint_distance_pixels)
+      return cc::NEVER_BIN;
+  }
+
   if (prio.time_to_needed_in_seconds() == std::numeric_limits<float>::max())
     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;
 
@@ skipping 88 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 118 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());
   }
 
   // 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 34 matching lines @@
         drawable_tiles_in_bin_count_[mts.bin[i]][i]++;
     }
   }
 
   // Sort by bin.
   std::sort(tiles_.begin(), tiles_.end(), BinComparator());
 
   // Assign gpu memory and determine what tiles need to be rasterized.
   AssignGpuMemoryToTiles();
 
-  // Finally, kick the rasterizer.
+  // Kick the rasterizer.
   DispatchMoreTasks();
+
+  // Finally, send the new managed memory statistics to the GPU memory manager
+  SendManagedMemoryStats();
 }
 
 void TileManager::CheckForCompletedSetPixels() {
   check_for_completed_set_pixels_pending_ = false;
 
   while (!tiles_with_pending_set_pixels_.empty()) {
     Tile* tile = tiles_with_pending_set_pixels_.front();
     DCHECK(tile->managed_state().resource);
 
     // Set pixel tasks complete in the order they are posted.
@@ skipping 37 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::SendManagedMemoryStats() {
+  size_t memoryRequiredBytes = 0;
+  size_t memoryNiceToHaveBytes = 0;
+  size_t memoryUsedBytes = 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)
+      memoryRequiredBytes += tile_bytes;
+    if (mts.gpu_memmgr_stats_bin != NEVER_BIN)
+      memoryNiceToHaveBytes += tile_bytes;
+    if (mts.can_use_gpu_memory)
+      memoryUsedBytes += tile_bytes;
+  }
+  client_->SendTileManagerMemoryStats(
+      memoryRequiredBytes,
+      memoryNiceToHaveBytes,
+      memoryUsedBytes);
+}
+
 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]++;
 }
 
 }