cc: Add TileManager interface that allows LTHI to determine when to activate pending tree.

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 13 matching lines @@
 
 const char* kRasterThreadNamePrefix = "CompositorRaster";
 
 const int kMaxRasterThreads = 64;
 const int kDefaultNumberOfRasterThreads = 1;
 
 // Allow two pending raster tasks per thread. This keeps resource usage
 // 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) {

[enne (OOO), 2012/12/16 01:26:44]

This is a nice refactoring.

+
+  // 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;
+
+  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;
+
+  if (prio.time_to_needed_in_seconds() < prepainting_window_time_seconds)
+    return cc::SOON_BIN;
+
+  return cc::EVENTUALLY_BIN;
+}
+
 }  // namespace
 
 namespace cc {
 
 class RasterThread : public base::Thread {
  public:
   RasterThread(const std::string name)
       : base::Thread(name.c_str()),
         num_pending_tasks_(0) {
     Start();
@@ skipping 93 matching lines @@
       check_for_completed_set_pixels_pending_(false) {
   // Initialize all threads.
   const std::string thread_name_prefix = kRasterThreadNamePrefix;
   while (raster_threads_.size() < num_raster_threads) {
     int thread_number = raster_threads_.size() + 1;
     scoped_ptr<RasterThread> thread = make_scoped_ptr(
         new RasterThread(thread_name_prefix +
                          StringPrintf("Worker%d", thread_number).c_str()));
     raster_threads_.append(thread.Pass());
   }
+
+  ResetBinCounts();
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
   AssignGpuMemoryToTiles();
   // This should finish all pending raster tasks and release any
   // uninitialized resources.
   raster_threads_.clear();
@@ skipping 55 matching lines @@
     return;
   client_->ScheduleCheckForCompletedSetPixels();
   check_for_completed_set_pixels_pending_ = true;
 }
 
 class BinComparator {
 public:
   bool operator() (const Tile* a, const Tile* b) const {
     const ManagedTileState& ams = a->managed_state();
     const ManagedTileState& bms = b->managed_state();
-    if (ams.bin != bms.bin)
-      return ams.bin < bms.bin;
+    if (ams.raster_bin != bms.raster_bin)
+      return ams.raster_bin < bms.raster_bin;
 
     if (ams.resolution != bms.resolution)
       return ams.resolution < ams.resolution;
 
     return
       ams.time_to_needed_in_seconds <
       bms.time_to_needed_in_seconds;
   }
 };
 
 void TileManager::ManageTiles() {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
   manage_tiles_pending_ = false;
 
-  // 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 bool smoothness_takes_priority =
+      global_state_.smoothness_takes_priority;
 
-  const bool smoothness_takes_priority = global_state_.smoothness_takes_priority;
-
-  // Bin into three categories of tiles: things we need now, things we need soon, and eventually
+  // For each tree, bin into different categories of tiles.
   for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
+    mts.bin[ACTIVE_TREE] = BinFromTilePriority(tile->priority(ACTIVE_TREE));
+    mts.bin[PENDING_TREE] = BinFromTilePriority(tile->priority(PENDING_TREE));
+
     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();
-
-    if (mts.time_to_needed_in_seconds ==
-        std::numeric_limits<float>::max()) {
-      mts.bin = NEVER_BIN;
-      continue;
-    }
-
-    if (mts.resolution == NON_IDEAL_RESOLUTION) {
-      mts.bin = EVENTUALLY_BIN;
-      continue;
-    }
-
-    if (mts.time_to_needed_in_seconds == 0 ||
-        prio.distance_to_visible_in_pixels < backfling_guard_distance_pixels) {
-      mts.bin = NOW_BIN;
-      continue;
-    }
-
-    if (prio.time_to_needed_in_seconds() < prepainting_window_time_seconds) {
-      mts.bin = SOON_BIN;
-      continue;
-    }
-
-    mts.bin = EVENTUALLY_BIN;
+    mts.raster_bin = BinFromTilePriority(prio);
   }
 
   // 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) {
     bin_map[NOW_BIN] = NOW_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_PREPAINT_ONLY) {
     bin_map[NOW_BIN] = NOW_BIN;
     bin_map[SOON_BIN] = SOON_BIN;
     bin_map[EVENTUALLY_BIN] = NEVER_BIN;
     bin_map[NEVER_BIN] = NEVER_BIN;
   } else {
     bin_map[NOW_BIN] = NOW_BIN;
     bin_map[SOON_BIN] = SOON_BIN;
     bin_map[EVENTUALLY_BIN] = EVENTUALLY_BIN;
     bin_map[NEVER_BIN] = NEVER_BIN;
   }
   for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = *it;
-    TileManagerBin bin = bin_map[tile->managed_state().bin];
-    tile->managed_state().bin = bin;
+    ManagedTileState& mts = tile->managed_state();
+    mts.bin[ACTIVE_TREE] = bin_map[mts.bin[ACTIVE_TREE]];
+    mts.bin[PENDING_TREE] = bin_map[mts.bin[PENDING_TREE]];
+    mts.raster_bin = bin_map[mts.raster_bin];
+  }
+
+  // Update bin counts.
+  ResetBinCounts();
+  for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
+    Tile* tile = *it;
+    ManagedTileState& mts = tile->managed_state();
+    for (int i = 0; i < NUM_TREES; ++i)
+      tiles_in_bin_count_[mts.bin[i]][i]++;
+
+    // Increment drawable count if GetResourceId() doesn't return 0.
+    if (tile->GetResourceId()) {
+      for (int i = 0; i < NUM_TREES; ++i)
+        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.
   DispatchMoreTasks();
@@ skipping 15 matching lines @@
 
     // It's now safe to release the pixel buffer.
     resource_pool_->resource_provider()->releasePixelBuffer(
         tile->managed_state().resource->id());
 
     DidFinishTileInitialization(tile);
     tiles_with_pending_set_pixels_.pop();
   }
 }
 
-void TileManager::renderingStats(RenderingStats* stats) {
+void TileManager::GetRenderingStats(RenderingStats* stats) {
   stats->totalRasterizeTimeInSeconds =
     rendering_stats_.totalRasterizeTimeInSeconds;
   stats->totalPixelsRasterized = rendering_stats_.totalPixelsRasterized;
 }
 
+int TileManager::GetTilesInBinCount(TileManagerBin bin, WhichTree tree) {
+  DCHECK(bin >= 0);
+  DCHECK(bin < NUM_BINS);
+  DCHECK(tree >= 0);
+  DCHECK(tree < NUM_TREES);
+  return tiles_in_bin_count_[bin][tree];
+}
+
+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::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;
   for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = *it;
     if (!tile->managed_state().can_be_freed)
       unreleasable_bytes += tile->bytes_consumed_if_allocated();
   }
 
@@ skipping 12 matching lines @@
   }
   tiles_with_image_decoding_tasks_.clear();
 
   size_t bytes_left = global_state_.memory_limit_in_bytes - unreleasable_bytes;
   for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = *it;
     size_t tile_bytes = tile->bytes_consumed_if_allocated();
     ManagedTileState& managed_tile_state = tile->managed_state();
     if (!managed_tile_state.can_be_freed)
       continue;
-    if (managed_tile_state.bin == NEVER_BIN) {
+    if (managed_tile_state.raster_bin == NEVER_BIN) {
       managed_tile_state.can_use_gpu_memory = false;
       FreeResourcesForTile(tile);
       continue;
     }
     if (tile_bytes > bytes_left) {
       managed_tile_state.can_use_gpu_memory = false;
       FreeResourcesForTile(tile);
       continue;
     }
     bytes_left -= tile_bytes;
@@ skipping 219 matching lines @@
     managed_tile_state.resource_is_being_initialized = false;
   }
   DispatchMoreTasks();
 }
 
 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]++;
 }
 
 }