src/cc/resources/tile_manager.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/resources/tile_manager.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9 #include <string>
  10
  11 #include "base/bind.h"
  12 #include "base/json/json_writer.h"
  13 #include "base/logging.h"
  14 #include "base/metrics/histogram.h"
  15 #include "cc/debug/traced_value.h"
  16 #include "cc/resources/direct_raster_worker_pool.h"
  17 #include "cc/resources/image_raster_worker_pool.h"
  18 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
  19 #include "cc/resources/raster_worker_pool_delegate.h"
  20 #include "cc/resources/tile.h"
  21 #include "ui/gfx/rect_conversions.h"
  22
  23 namespace cc {
  24 namespace {
  25
  26 // Memory limit policy works by mapping some bin states to the NEVER bin.
  27 const ManagedTileBin kBinPolicyMap[NUM_TILE_MEMORY_LIMIT_POLICIES][NUM_BINS] = {
  28     // [ALLOW_NOTHING]
  29     {NEVER_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
  30      NEVER_BIN,  // [NOW_BIN]
  31      NEVER_BIN,  // [SOON_BIN]
  32      NEVER_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
  33      NEVER_BIN,  // [EVENTUALLY_BIN]
  34      NEVER_BIN,  // [AT_LAST_AND_ACTIVE_BIN]
  35      NEVER_BIN,  // [AT_LAST_BIN]
  36      NEVER_BIN   // [NEVER_BIN]
  37     },
  38     // [ALLOW_ABSOLUTE_MINIMUM]
  39     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
  40      NOW_BIN,                    // [NOW_BIN]
  41      NEVER_BIN,                  // [SOON_BIN]
  42      NEVER_BIN,                  // [EVENTUALLY_AND_ACTIVE_BIN]
  43      NEVER_BIN,                  // [EVENTUALLY_BIN]
  44      NEVER_BIN,                  // [AT_LAST_AND_ACTIVE_BIN]
  45      NEVER_BIN,                  // [AT_LAST_BIN]
  46      NEVER_BIN                   // [NEVER_BIN]
  47     },
  48     // [ALLOW_PREPAINT_ONLY]
  49     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
  50      NOW_BIN,                    // [NOW_BIN]
  51      SOON_BIN,                   // [SOON_BIN]
  52      NEVER_BIN,                  // [EVENTUALLY_AND_ACTIVE_BIN]
  53      NEVER_BIN,                  // [EVENTUALLY_BIN]
  54      NEVER_BIN,                  // [AT_LAST_AND_ACTIVE_BIN]
  55      NEVER_BIN,                  // [AT_LAST_BIN]
  56      NEVER_BIN                   // [NEVER_BIN]
  57     },
  58     // [ALLOW_ANYTHING]
  59     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
  60      NOW_BIN,                    // [NOW_BIN]
  61      SOON_BIN,                   // [SOON_BIN]
  62      EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
  63      EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
  64      AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
  65      AT_LAST_BIN,                // [AT_LAST_BIN]
  66      NEVER_BIN                   // [NEVER_BIN]
  67     }};
  68
  69 // Ready to draw works by mapping NOW_BIN to NOW_AND_READY_TO_DRAW_BIN.
  70 const ManagedTileBin kBinReadyToDrawMap[2][NUM_BINS] = {
  71     // Not ready
  72     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
  73      NOW_BIN,                    // [NOW_BIN]
  74      SOON_BIN,                   // [SOON_BIN]
  75      EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
  76      EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
  77      AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
  78      AT_LAST_BIN,                // [AT_LAST_BIN]
  79      NEVER_BIN                   // [NEVER_BIN]
  80     },
  81     // Ready
  82     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
  83      NOW_AND_READY_TO_DRAW_BIN,  // [NOW_BIN]
  84      SOON_BIN,                   // [SOON_BIN]
  85      EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
  86      EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
  87      AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
  88      AT_LAST_BIN,                // [AT_LAST_BIN]
  89      NEVER_BIN                   // [NEVER_BIN]
  90     }};
  91
  92 // Active works by mapping some bin stats to equivalent _ACTIVE_BIN state.
  93 const ManagedTileBin kBinIsActiveMap[2][NUM_BINS] = {
  94     // Inactive
  95     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
  96      NOW_BIN,                    // [NOW_BIN]
  97      SOON_BIN,                   // [SOON_BIN]
  98      EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
  99      EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
 100      AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
 101      AT_LAST_BIN,                // [AT_LAST_BIN]
 102      NEVER_BIN                   // [NEVER_BIN]
 103     },
 104     // Active
 105     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
 106      NOW_BIN,                    // [NOW_BIN]
 107      SOON_BIN,                   // [SOON_BIN]
 108      EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
 109      EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_BIN]
 110      AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
 111      AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_BIN]
 112      NEVER_BIN                   // [NEVER_BIN]
 113     }};
 114
 115 // Determine bin based on three categories of tiles: things we need now,
 116 // things we need soon, and eventually.
 117 inline ManagedTileBin BinFromTilePriority(const TilePriority& prio) {
 118   const float kBackflingGuardDistancePixels = 314.0f;
 119
 120   if (prio.priority_bin == TilePriority::NOW)
 121     return NOW_BIN;
 122
 123   if (prio.priority_bin == TilePriority::SOON ||
 124       prio.distance_to_visible < kBackflingGuardDistancePixels)
 125     return SOON_BIN;
 126
 127   if (prio.distance_to_visible == std::numeric_limits<float>::infinity())
 128     return NEVER_BIN;
 129
 130   return EVENTUALLY_BIN;
 131 }
 132
 133 }  // namespace
 134
 135 RasterTaskCompletionStats::RasterTaskCompletionStats()
 136     : completed_count(0u), canceled_count(0u) {}
 137
 138 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
 139     const RasterTaskCompletionStats& stats) {
 140   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
 141   state->SetInteger("completed_count", stats.completed_count);
 142   state->SetInteger("canceled_count", stats.canceled_count);
 143   return state.PassAs<base::Value>();
 144 }
 145
 146 // static
 147 scoped_ptr<TileManager> TileManager::Create(
 148     TileManagerClient* client,
 149     ResourceProvider* resource_provider,
 150     ContextProvider* context_provider,
 151     RenderingStatsInstrumentation* rendering_stats_instrumentation,
 152     bool use_map_image,
 153     bool use_rasterize_on_demand,
 154     size_t max_transfer_buffer_usage_bytes,
 155     size_t max_raster_usage_bytes,
 156     unsigned map_image_texture_target) {
 157   return make_scoped_ptr(new TileManager(
 158       client,
 159       resource_provider,
 160       context_provider,
 161       use_map_image ? ImageRasterWorkerPool::Create(resource_provider,
 162                                                     map_image_texture_target)
 163                     : PixelBufferRasterWorkerPool::Create(
 164                           resource_provider, max_transfer_buffer_usage_bytes),
 165       DirectRasterWorkerPool::Create(resource_provider, context_provider),
 166       max_raster_usage_bytes,
 167       rendering_stats_instrumentation,
 168       use_rasterize_on_demand));
 169 }
 170
 171 TileManager::TileManager(
 172     TileManagerClient* client,
 173     ResourceProvider* resource_provider,
 174     ContextProvider* context_provider,
 175     scoped_ptr<RasterWorkerPool> raster_worker_pool,
 176     scoped_ptr<RasterWorkerPool> direct_raster_worker_pool,
 177     size_t max_raster_usage_bytes,
 178     RenderingStatsInstrumentation* rendering_stats_instrumentation,
 179     bool use_rasterize_on_demand)
 180     : client_(client),
 181       context_provider_(context_provider),
 182       resource_pool_(
 183           ResourcePool::Create(resource_provider,
 184                                raster_worker_pool->GetResourceTarget(),
 185                                raster_worker_pool->GetResourceFormat())),
 186       raster_worker_pool_(raster_worker_pool.Pass()),
 187       direct_raster_worker_pool_(direct_raster_worker_pool.Pass()),
 188       prioritized_tiles_dirty_(false),
 189       all_tiles_that_need_to_be_rasterized_have_memory_(true),
 190       all_tiles_required_for_activation_have_memory_(true),
 191       memory_required_bytes_(0),
 192       memory_nice_to_have_bytes_(0),
 193       bytes_releasable_(0),
 194       resources_releasable_(0),
 195       max_raster_usage_bytes_(max_raster_usage_bytes),
 196       ever_exceeded_memory_budget_(false),
 197       rendering_stats_instrumentation_(rendering_stats_instrumentation),
 198       did_initialize_visible_tile_(false),
 199       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
 200       use_rasterize_on_demand_(use_rasterize_on_demand) {
 201   RasterWorkerPool* raster_worker_pools[NUM_RASTER_WORKER_POOL_TYPES] = {
 202       raster_worker_pool_.get(),        // RASTER_WORKER_POOL_TYPE_DEFAULT
 203       direct_raster_worker_pool_.get()  // RASTER_WORKER_POOL_TYPE_DIRECT
 204   };
 205   raster_worker_pool_delegate_ = RasterWorkerPoolDelegate::Create(
 206       this, raster_worker_pools, arraysize(raster_worker_pools));
 207 }
 208
 209 TileManager::~TileManager() {
 210   // Reset global state and manage. This should cause
 211   // our memory usage to drop to zero.
 212   global_state_ = GlobalStateThatImpactsTilePriority();
 213
 214   CleanUpReleasedTiles();
 215   DCHECK_EQ(0u, tiles_.size());
 216
 217   RasterWorkerPool::RasterTask::Queue empty[NUM_RASTER_WORKER_POOL_TYPES];
 218   raster_worker_pool_delegate_->ScheduleTasks(empty);
 219
 220   // This should finish all pending tasks and release any uninitialized
 221   // resources.
 222   raster_worker_pool_delegate_->Shutdown();
 223   raster_worker_pool_delegate_->CheckForCompletedTasks();
 224
 225   DCHECK_EQ(0u, bytes_releasable_);
 226   DCHECK_EQ(0u, resources_releasable_);
 227 }
 228
 229 void TileManager::Release(Tile* tile) {
 230   prioritized_tiles_dirty_ = true;
 231   released_tiles_.push_back(tile);
 232 }
 233
 234 void TileManager::DidChangeTilePriority(Tile* tile) {
 235   prioritized_tiles_dirty_ = true;
 236 }
 237
 238 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
 239   return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 240 }
 241
 242 void TileManager::CleanUpReleasedTiles() {
 243   for (std::vector<Tile*>::iterator it = released_tiles_.begin();
 244        it != released_tiles_.end();
 245        ++it) {
 246     Tile* tile = *it;
 247
 248     FreeResourcesForTile(tile);
 249
 250     DCHECK(tiles_.find(tile->id()) != tiles_.end());
 251     tiles_.erase(tile->id());
 252
 253     LayerCountMap::iterator layer_it =
 254         used_layer_counts_.find(tile->layer_id());
 255     DCHECK_GT(layer_it->second, 0);
 256     if (--layer_it->second == 0) {
 257       used_layer_counts_.erase(layer_it);
 258       image_decode_tasks_.erase(tile->layer_id());
 259     }
 260
 261     delete tile;
 262   }
 263
 264   released_tiles_.clear();
 265 }
 266
 267 void TileManager::UpdatePrioritizedTileSetIfNeeded() {
 268   if (!prioritized_tiles_dirty_)
 269     return;
 270
 271   CleanUpReleasedTiles();
 272
 273   prioritized_tiles_.Clear();
 274   GetTilesWithAssignedBins(&prioritized_tiles_);
 275   prioritized_tiles_dirty_ = false;
 276 }
 277
 278 void TileManager::DidFinishRunningTasks() {
 279   TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks");
 280
 281   // When OOM, keep re-assigning memory until we reach a steady state
 282   // where top-priority tiles are initialized.
 283   if (all_tiles_that_need_to_be_rasterized_have_memory_)
 284     return;
 285
 286   raster_worker_pool_delegate_->CheckForCompletedTasks();
 287   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 288
 289   TileVector tiles_that_need_to_be_rasterized;
 290   AssignGpuMemoryToTiles(&prioritized_tiles_,
 291                          &tiles_that_need_to_be_rasterized);
 292
 293   // |tiles_that_need_to_be_rasterized| will be empty when we reach a
 294   // steady memory state. Keep scheduling tasks until we reach this state.
 295   if (!tiles_that_need_to_be_rasterized.empty()) {
 296     ScheduleTasks(tiles_that_need_to_be_rasterized);
 297     return;
 298   }
 299
 300   // We don't reserve memory for required-for-activation tiles during
 301   // accelerated gestures, so we just postpone activation when we don't
 302   // have these tiles, and activate after the accelerated gesture.
 303   bool allow_rasterize_on_demand =
 304       global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 305
 306   // Use on-demand raster for any required-for-activation tiles that have not
 307   // been been assigned memory after reaching a steady memory state. This
 308   // ensures that we activate even when OOM.
 309   for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
 310     Tile* tile = it->second;
 311     ManagedTileState& mts = tile->managed_state();
 312     ManagedTileState::TileVersion& tile_version =
 313         mts.tile_versions[mts.raster_mode];
 314
 315     if (tile->required_for_activation() && !tile_version.IsReadyToDraw()) {
 316       // If we can't raster on demand, give up early (and don't activate).
 317       if (!allow_rasterize_on_demand)
 318         return;
 319       if (use_rasterize_on_demand_)
 320         tile_version.set_rasterize_on_demand();
 321     }
 322   }
 323
 324   client_->NotifyReadyToActivate();
 325 }
 326
 327 void TileManager::DidFinishRunningTasksRequiredForActivation() {
 328   // This is only a true indication that all tiles required for
 329   // activation are initialized when no tiles are OOM. We need to
 330   // wait for DidFinishRunningTasks() to be called, try to re-assign
 331   // memory and in worst case use on-demand raster when tiles
 332   // required for activation are OOM.
 333   if (!all_tiles_required_for_activation_have_memory_)
 334     return;
 335
 336   client_->NotifyReadyToActivate();
 337 }
 338
 339 void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) {
 340   TRACE_EVENT0("cc", "TileManager::GetTilesWithAssignedBins");
 341
 342   // Compute new stats to be return by GetMemoryStats().
 343   memory_required_bytes_ = 0;
 344   memory_nice_to_have_bytes_ = 0;
 345
 346   const TileMemoryLimitPolicy memory_policy = global_state_.memory_limit_policy;
 347   const TreePriority tree_priority = global_state_.tree_priority;
 348
 349   // For each tree, bin into different categories of tiles.
 350   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
 351     Tile* tile = it->second;
 352     ManagedTileState& mts = tile->managed_state();
 353
 354     const ManagedTileState::TileVersion& tile_version =
 355         tile->GetTileVersionForDrawing();
 356     bool tile_is_ready_to_draw = tile_version.IsReadyToDraw();
 357     bool tile_is_active =
 358         tile_is_ready_to_draw ||
 359         !mts.tile_versions[mts.raster_mode].raster_task_.is_null();
 360
 361     // Get the active priority and bin.
 362     TilePriority active_priority = tile->priority(ACTIVE_TREE);
 363     ManagedTileBin active_bin = BinFromTilePriority(active_priority);
 364
 365     // Get the pending priority and bin.
 366     TilePriority pending_priority = tile->priority(PENDING_TREE);
 367     ManagedTileBin pending_bin = BinFromTilePriority(pending_priority);
 368
 369     bool pending_is_low_res = pending_priority.resolution == LOW_RESOLUTION;
 370     bool pending_is_non_ideal =
 371         pending_priority.resolution == NON_IDEAL_RESOLUTION;
 372     bool active_is_non_ideal =
 373         active_priority.resolution == NON_IDEAL_RESOLUTION;
 374
 375     // Adjust pending bin state for low res tiles. This prevents
 376     // pending tree low-res tiles from being initialized before
 377     // high-res tiles.
 378     if (pending_is_low_res)
 379       pending_bin = std::max(pending_bin, EVENTUALLY_BIN);
 380
 381     // Adjust bin state based on if ready to draw.
 382     active_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][active_bin];
 383     pending_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][pending_bin];
 384
 385     // Adjust bin state based on if active.
 386     active_bin = kBinIsActiveMap[tile_is_active][active_bin];
 387     pending_bin = kBinIsActiveMap[tile_is_active][pending_bin];
 388
 389     // We never want to paint new non-ideal tiles, as we always have
 390     // a high-res tile covering that content (paint that instead).
 391     if (!tile_is_ready_to_draw && active_is_non_ideal)
 392       active_bin = NEVER_BIN;
 393     if (!tile_is_ready_to_draw && pending_is_non_ideal)
 394       pending_bin = NEVER_BIN;
 395
 396     // Compute combined bin.
 397     ManagedTileBin combined_bin = std::min(active_bin, pending_bin);
 398
 399     if (!tile_is_ready_to_draw || tile_version.requires_resource()) {
 400       // The bin that the tile would have if the GPU memory manager had
 401       // a maximally permissive policy, send to the GPU memory manager
 402       // to determine policy.
 403       ManagedTileBin gpu_memmgr_stats_bin = combined_bin;
 404       if ((gpu_memmgr_stats_bin == NOW_BIN) ||
 405           (gpu_memmgr_stats_bin == NOW_AND_READY_TO_DRAW_BIN))
 406         memory_required_bytes_ += BytesConsumedIfAllocated(tile);
 407       if (gpu_memmgr_stats_bin != NEVER_BIN)
 408         memory_nice_to_have_bytes_ += BytesConsumedIfAllocated(tile);
 409     }
 410
 411     ManagedTileBin tree_bin[NUM_TREES];
 412     tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin];
 413     tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin];
 414
 415     TilePriority tile_priority;
 416     switch (tree_priority) {
 417       case SAME_PRIORITY_FOR_BOTH_TREES:
 418         mts.bin = kBinPolicyMap[memory_policy][combined_bin];
 419         tile_priority = tile->combined_priority();
 420         break;
 421       case SMOOTHNESS_TAKES_PRIORITY:
 422         mts.bin = tree_bin[ACTIVE_TREE];
 423         tile_priority = active_priority;
 424         break;
 425       case NEW_CONTENT_TAKES_PRIORITY:
 426         mts.bin = tree_bin[PENDING_TREE];
 427         tile_priority = pending_priority;
 428         break;
 429     }
 430
 431     // Bump up the priority if we determined it's NEVER_BIN on one tree,
 432     // but is still required on the other tree.
 433     bool is_in_never_bin_on_both_trees = tree_bin[ACTIVE_TREE] == NEVER_BIN &&
 434                                          tree_bin[PENDING_TREE] == NEVER_BIN;
 435
 436     if (mts.bin == NEVER_BIN && !is_in_never_bin_on_both_trees)
 437       mts.bin = tile_is_active ? AT_LAST_AND_ACTIVE_BIN : AT_LAST_BIN;
 438
 439     mts.resolution = tile_priority.resolution;
 440     mts.priority_bin = tile_priority.priority_bin;
 441     mts.distance_to_visible = tile_priority.distance_to_visible;
 442     mts.required_for_activation = tile_priority.required_for_activation;
 443
 444     mts.visible_and_ready_to_draw =
 445         tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
 446
 447     if (mts.bin == NEVER_BIN) {
 448       FreeResourcesForTile(tile);
 449       continue;
 450     }
 451
 452     // In almost all concievable cases (all in practice right now), we can't get
 453     // memory back from visible-active-tree tiles. Further, active-tree tiles
 454     // can still be used for animations. Further, ready-to-draw tiles won't
 455     // delay activation since they are already rastered. So we should keep
 456     // these tiles around in all cases.
 457     if (mts.visible_and_ready_to_draw)
 458       mts.bin = NOW_AND_READY_TO_DRAW_BIN;
 459
 460     // Insert the tile into a priority set.
 461     tiles->InsertTile(tile, mts.bin);
 462   }
 463 }
 464
 465 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
 466   TRACE_EVENT0("cc", "TileManager::ManageTiles");
 467
 468   // Update internal state.
 469   if (state != global_state_) {
 470     global_state_ = state;
 471     prioritized_tiles_dirty_ = true;
 472     // Soft limit is used for resource pool such that
 473     // memory returns to soft limit after going over.
 474     resource_pool_->SetResourceUsageLimits(
 475         global_state_.soft_memory_limit_in_bytes,
 476         global_state_.unused_memory_limit_in_bytes,
 477         global_state_.num_resources_limit);
 478   }
 479
 480   // We need to call CheckForCompletedTasks() once in-between each call
 481   // to ScheduleTasks() to prevent canceled tasks from being scheduled.
 482   if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
 483     raster_worker_pool_delegate_->CheckForCompletedTasks();
 484     did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 485   }
 486
 487   UpdatePrioritizedTileSetIfNeeded();
 488
 489   TileVector tiles_that_need_to_be_rasterized;
 490   AssignGpuMemoryToTiles(&prioritized_tiles_,
 491                          &tiles_that_need_to_be_rasterized);
 492
 493   // Finally, schedule rasterizer tasks.
 494   ScheduleTasks(tiles_that_need_to_be_rasterized);
 495
 496   TRACE_EVENT_INSTANT1("cc",
 497                        "DidManage",
 498                        TRACE_EVENT_SCOPE_THREAD,
 499                        "state",
 500                        TracedValue::FromValue(BasicStateAsValue().release()));
 501
 502   TRACE_COUNTER_ID1("cc",
 503                     "unused_memory_bytes",
 504                     this,
 505                     resource_pool_->total_memory_usage_bytes() -
 506                         resource_pool_->acquired_memory_usage_bytes());
 507 }
 508
 509 bool TileManager::UpdateVisibleTiles() {
 510   TRACE_EVENT0("cc", "TileManager::UpdateVisibleTiles");
 511
 512   raster_worker_pool_delegate_->CheckForCompletedTasks();
 513   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 514
 515   TRACE_EVENT_INSTANT1(
 516       "cc",
 517       "DidUpdateVisibleTiles",
 518       TRACE_EVENT_SCOPE_THREAD,
 519       "stats",
 520       TracedValue::FromValue(RasterTaskCompletionStatsAsValue(
 521                                  update_visible_tiles_stats_).release()));
 522   update_visible_tiles_stats_ = RasterTaskCompletionStats();
 523
 524   bool did_initialize_visible_tile = did_initialize_visible_tile_;
 525   did_initialize_visible_tile_ = false;
 526   return did_initialize_visible_tile;
 527 }
 528
 529 void TileManager::GetMemoryStats(size_t* memory_required_bytes,
 530                                  size_t* memory_nice_to_have_bytes,
 531                                  size_t* memory_allocated_bytes,
 532                                  size_t* memory_used_bytes) const {
 533   *memory_required_bytes = memory_required_bytes_;
 534   *memory_nice_to_have_bytes = memory_nice_to_have_bytes_;
 535   *memory_allocated_bytes = resource_pool_->total_memory_usage_bytes();
 536   *memory_used_bytes = resource_pool_->acquired_memory_usage_bytes();
 537 }
 538
 539 scoped_ptr<base::Value> TileManager::BasicStateAsValue() const {
 540   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
 541   state->SetInteger("tile_count", tiles_.size());
 542   state->Set("global_state", global_state_.AsValue().release());
 543   state->Set("memory_requirements", GetMemoryRequirementsAsValue().release());
 544   return state.PassAs<base::Value>();
 545 }
 546
 547 scoped_ptr<base::Value> TileManager::AllTilesAsValue() const {
 548   scoped_ptr<base::ListValue> state(new base::ListValue());
 549   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
 550     state->Append(it->second->AsValue().release());
 551
 552   return state.PassAs<base::Value>();
 553 }
 554
 555 scoped_ptr<base::Value> TileManager::GetMemoryRequirementsAsValue() const {
 556   scoped_ptr<base::DictionaryValue> requirements(new base::DictionaryValue());
 557
 558   size_t memory_required_bytes;
 559   size_t memory_nice_to_have_bytes;
 560   size_t memory_allocated_bytes;
 561   size_t memory_used_bytes;
 562   GetMemoryStats(&memory_required_bytes,
 563                  &memory_nice_to_have_bytes,
 564                  &memory_allocated_bytes,
 565                  &memory_used_bytes);
 566   requirements->SetInteger("memory_required_bytes", memory_required_bytes);
 567   requirements->SetInteger("memory_nice_to_have_bytes",
 568                            memory_nice_to_have_bytes);
 569   requirements->SetInteger("memory_allocated_bytes", memory_allocated_bytes);
 570   requirements->SetInteger("memory_used_bytes", memory_used_bytes);
 571   return requirements.PassAs<base::Value>();
 572 }
 573
 574 RasterMode TileManager::DetermineRasterMode(const Tile* tile) const {
 575   DCHECK(tile);
 576   DCHECK(tile->picture_pile());
 577
 578   const ManagedTileState& mts = tile->managed_state();
 579   RasterMode current_mode = mts.raster_mode;
 580
 581   RasterMode raster_mode = HIGH_QUALITY_RASTER_MODE;
 582   if (tile->managed_state().resolution == LOW_RESOLUTION)
 583     raster_mode = LOW_QUALITY_RASTER_MODE;
 584   else if (tile->can_use_lcd_text())
 585     raster_mode = HIGH_QUALITY_RASTER_MODE;
 586   else if (mts.tile_versions[current_mode].has_text_ ||
 587            !mts.tile_versions[current_mode].IsReadyToDraw())
 588     raster_mode = HIGH_QUALITY_NO_LCD_RASTER_MODE;
 589
 590   return std::min(raster_mode, current_mode);
 591 }
 592
 593 void TileManager::AssignGpuMemoryToTiles(
 594     PrioritizedTileSet* tiles,
 595     TileVector* tiles_that_need_to_be_rasterized) {
 596   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
 597
 598   // Maintain the list of released resources that can potentially be re-used
 599   // or deleted.
 600   // If this operation becomes expensive too, only do this after some
 601   // resource(s) was returned. Note that in that case, one also need to
 602   // invalidate when releasing some resource from the pool.
 603   resource_pool_->CheckBusyResources();
 604
 605   // Now give memory out to the tiles until we're out, and build
 606   // the needs-to-be-rasterized queue.
 607   all_tiles_that_need_to_be_rasterized_have_memory_ = true;
 608   all_tiles_required_for_activation_have_memory_ = true;
 609
 610   // Cast to prevent overflow.
 611   int64 soft_bytes_available =
 612       static_cast<int64>(bytes_releasable_) +
 613       static_cast<int64>(global_state_.soft_memory_limit_in_bytes) -
 614       static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
 615   int64 hard_bytes_available =
 616       static_cast<int64>(bytes_releasable_) +
 617       static_cast<int64>(global_state_.hard_memory_limit_in_bytes) -
 618       static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
 619   int resources_available = resources_releasable_ +
 620                             global_state_.num_resources_limit -
 621                             resource_pool_->acquired_resource_count();
 622   size_t soft_bytes_allocatable =
 623       std::max(static_cast<int64>(0), soft_bytes_available);
 624   size_t hard_bytes_allocatable =
 625       std::max(static_cast<int64>(0), hard_bytes_available);
 626   size_t resources_allocatable = std::max(0, resources_available);
 627
 628   size_t bytes_that_exceeded_memory_budget = 0;
 629   size_t soft_bytes_left = soft_bytes_allocatable;
 630   size_t hard_bytes_left = hard_bytes_allocatable;
 631
 632   size_t resources_left = resources_allocatable;
 633   bool oomed_soft = false;
 634   bool oomed_hard = false;
 635   bool have_hit_soft_memory = false;  // Soft memory comes after hard.
 636
 637   // Memory we assign to raster tasks now will be deducted from our memory
 638   // in future iterations if priorities change. By assigning at most half
 639   // the raster limit, we will always have another 50% left even if priorities
 640   // change completely (assuming we check for completed/cancelled rasters
 641   // between each call to this function).
 642   size_t max_raster_bytes = max_raster_usage_bytes_ / 2;
 643   size_t raster_bytes = 0;
 644
 645   unsigned schedule_priority = 1u;
 646   for (PrioritizedTileSet::Iterator it(tiles, true); it; ++it) {
 647     Tile* tile = *it;
 648     ManagedTileState& mts = tile->managed_state();
 649
 650     mts.scheduled_priority = schedule_priority++;
 651
 652     mts.raster_mode = DetermineRasterMode(tile);
 653
 654     ManagedTileState::TileVersion& tile_version =
 655         mts.tile_versions[mts.raster_mode];
 656
 657     // If this tile doesn't need a resource, then nothing to do.
 658     if (!tile_version.requires_resource())
 659       continue;
 660
 661     // If the tile is not needed, free it up.
 662     if (mts.bin == NEVER_BIN) {
 663       FreeResourcesForTile(tile);
 664       continue;
 665     }
 666
 667     const bool tile_uses_hard_limit = mts.bin <= NOW_BIN;
 668     const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile);
 669     const size_t raster_bytes_if_rastered = raster_bytes + bytes_if_allocated;
 670     const size_t tile_bytes_left =
 671         (tile_uses_hard_limit) ? hard_bytes_left : soft_bytes_left;
 672
 673     // Hard-limit is reserved for tiles that would cause a calamity
 674     // if they were to go away, so by definition they are the highest
 675     // priority memory, and must be at the front of the list.
 676     DCHECK(!(have_hit_soft_memory && tile_uses_hard_limit));
 677     have_hit_soft_memory |= !tile_uses_hard_limit;
 678
 679     size_t tile_bytes = 0;
 680     size_t tile_resources = 0;
 681
 682     // It costs to maintain a resource.
 683     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
 684       if (mts.tile_versions[mode].resource_) {
 685         tile_bytes += bytes_if_allocated;
 686         tile_resources++;
 687       }
 688     }
 689
 690     // Allow lower priority tiles with initialized resources to keep
 691     // their memory by only assigning memory to new raster tasks if
 692     // they can be scheduled.
 693     if (raster_bytes_if_rastered <= max_raster_bytes) {
 694       // If we don't have the required version, and it's not in flight
 695       // then we'll have to pay to create a new task.
 696       if (!tile_version.resource_ && tile_version.raster_task_.is_null()) {
 697         tile_bytes += bytes_if_allocated;
 698         tile_resources++;
 699       }
 700     }
 701
 702     // Tile is OOM.
 703     if (tile_bytes > tile_bytes_left || tile_resources > resources_left) {
 704       FreeResourcesForTile(tile);
 705
 706       // This tile was already on screen and now its resources have been
 707       // released. In order to prevent checkerboarding, set this tile as
 708       // rasterize on demand immediately.
 709       if (mts.visible_and_ready_to_draw && use_rasterize_on_demand_)
 710         tile_version.set_rasterize_on_demand();
 711
 712       oomed_soft = true;
 713       if (tile_uses_hard_limit) {
 714         oomed_hard = true;
 715         bytes_that_exceeded_memory_budget += tile_bytes;
 716       }
 717     } else {
 718       resources_left -= tile_resources;
 719       hard_bytes_left -= tile_bytes;
 720       soft_bytes_left =
 721           (soft_bytes_left > tile_bytes) ? soft_bytes_left - tile_bytes : 0;
 722       if (tile_version.resource_)
 723         continue;
 724     }
 725
 726     DCHECK(!tile_version.resource_);
 727
 728     // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized|
 729     // has reached it's limit or we've failed to assign gpu memory to this
 730     // or any higher priority tile. Preventing tiles that fit into memory
 731     // budget to be rasterized when higher priority tile is oom is
 732     // important for two reasons:
 733     // 1. Tile size should not impact raster priority.
 734     // 2. Tiles with existing raster task could otherwise incorrectly
 735     //    be added as they are not affected by |bytes_allocatable|.
 736     if (oomed_soft || raster_bytes_if_rastered > max_raster_bytes) {
 737       all_tiles_that_need_to_be_rasterized_have_memory_ = false;
 738       if (tile->required_for_activation())
 739         all_tiles_required_for_activation_have_memory_ = false;
 740       it.DisablePriorityOrdering();
 741       continue;
 742     }
 743
 744     raster_bytes = raster_bytes_if_rastered;
 745     tiles_that_need_to_be_rasterized->push_back(tile);
 746   }
 747
 748   // OOM reporting uses hard-limit, soft-OOM is normal depending on limit.
 749   ever_exceeded_memory_budget_ |= oomed_hard;
 750   if (ever_exceeded_memory_budget_) {
 751     TRACE_COUNTER_ID2("cc",
 752                       "over_memory_budget",
 753                       this,
 754                       "budget",
 755                       global_state_.hard_memory_limit_in_bytes,
 756                       "over",
 757                       bytes_that_exceeded_memory_budget);
 758   }
 759   memory_stats_from_last_assign_.total_budget_in_bytes =
 760       global_state_.hard_memory_limit_in_bytes;
 761   memory_stats_from_last_assign_.bytes_allocated =
 762       hard_bytes_allocatable - hard_bytes_left;
 763   memory_stats_from_last_assign_.bytes_unreleasable =
 764       hard_bytes_allocatable - bytes_releasable_;
 765   memory_stats_from_last_assign_.bytes_over = bytes_that_exceeded_memory_budget;
 766 }
 767
 768 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) {
 769   ManagedTileState& mts = tile->managed_state();
 770   if (mts.tile_versions[mode].resource_) {
 771     resource_pool_->ReleaseResource(mts.tile_versions[mode].resource_.Pass());
 772
 773     DCHECK_GE(bytes_releasable_, BytesConsumedIfAllocated(tile));
 774     DCHECK_GE(resources_releasable_, 1u);
 775
 776     bytes_releasable_ -= BytesConsumedIfAllocated(tile);
 777     --resources_releasable_;
 778   }
 779 }
 780
 781 void TileManager::FreeResourcesForTile(Tile* tile) {
 782   for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
 783     FreeResourceForTile(tile, static_cast<RasterMode>(mode));
 784   }
 785 }
 786
 787 void TileManager::FreeUnusedResourcesForTile(Tile* tile) {
 788   DCHECK(tile->IsReadyToDraw());
 789   ManagedTileState& mts = tile->managed_state();
 790   RasterMode used_mode = HIGH_QUALITY_NO_LCD_RASTER_MODE;
 791   for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
 792     if (mts.tile_versions[mode].IsReadyToDraw()) {
 793       used_mode = static_cast<RasterMode>(mode);
 794       break;
 795     }
 796   }
 797
 798   for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
 799     if (mode != used_mode)
 800       FreeResourceForTile(tile, static_cast<RasterMode>(mode));
 801   }
 802 }
 803
 804 void TileManager::ScheduleTasks(
 805     const TileVector& tiles_that_need_to_be_rasterized) {
 806   TRACE_EVENT1("cc",
 807                "TileManager::ScheduleTasks",
 808                "count",
 809                tiles_that_need_to_be_rasterized.size());
 810
 811   DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
 812
 813   for (size_t i = 0; i < NUM_RASTER_WORKER_POOL_TYPES; ++i)
 814     raster_queue_[i].Reset();
 815
 816   // Build a new task queue containing all task currently needed. Tasks
 817   // are added in order of priority, highest priority task first.
 818   for (TileVector::const_iterator it = tiles_that_need_to_be_rasterized.begin();
 819        it != tiles_that_need_to_be_rasterized.end();
 820        ++it) {
 821     Tile* tile = *it;
 822     ManagedTileState& mts = tile->managed_state();
 823     ManagedTileState::TileVersion& tile_version =
 824         mts.tile_versions[mts.raster_mode];
 825
 826     DCHECK(tile_version.requires_resource());
 827     DCHECK(!tile_version.resource_);
 828
 829     if (tile_version.raster_task_.is_null())
 830       tile_version.raster_task_ = CreateRasterTask(tile);
 831
 832     size_t pool_type = tile->use_gpu_rasterization()
 833                            ? RASTER_WORKER_POOL_TYPE_DIRECT
 834                            : RASTER_WORKER_POOL_TYPE_DEFAULT;
 835
 836     raster_queue_[pool_type]
 837         .Append(tile_version.raster_task_, tile->required_for_activation());
 838   }
 839
 840   // We must reduce the amount of unused resoruces before calling
 841   // ScheduleTasks to prevent usage from rising above limits.
 842   resource_pool_->ReduceResourceUsage();
 843
 844   // Schedule running of |raster_tasks_|. This replaces any previously
 845   // scheduled tasks and effectively cancels all tasks not present
 846   // in |raster_tasks_|.
 847   raster_worker_pool_delegate_->ScheduleTasks(raster_queue_);
 848
 849   did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
 850 }
 851
 852 RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
 853     Tile* tile,
 854     SkPixelRef* pixel_ref) {
 855   return RasterWorkerPool::CreateImageDecodeTask(
 856       pixel_ref,
 857       tile->layer_id(),
 858       rendering_stats_instrumentation_,
 859       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
 860                  base::Unretained(this),
 861                  tile->layer_id(),
 862                  base::Unretained(pixel_ref)));
 863 }
 864
 865 RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
 866   ManagedTileState& mts = tile->managed_state();
 867
 868   scoped_ptr<ScopedResource> resource =
 869       resource_pool_->AcquireResource(tile->tile_size_.size());
 870   const ScopedResource* const_resource = resource.get();
 871
 872   // Create and queue all image decode tasks that this tile depends on.
 873   RasterWorkerPool::Task::Set decode_tasks;
 874   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
 875   for (PicturePileImpl::PixelRefIterator iter(
 876            tile->content_rect(), tile->contents_scale(), tile->picture_pile());
 877        iter;
 878        ++iter) {
 879     SkPixelRef* pixel_ref = *iter;
 880     uint32_t id = pixel_ref->getGenerationID();
 881
 882     // Append existing image decode task if available.
 883     PixelRefTaskMap::iterator decode_task_it = existing_pixel_refs.find(id);
 884     if (decode_task_it != existing_pixel_refs.end()) {
 885       decode_tasks.Insert(decode_task_it->second);
 886       continue;
 887     }
 888
 889     // Create and append new image decode task for this pixel ref.
 890     RasterWorkerPool::Task decode_task = CreateImageDecodeTask(tile, pixel_ref);
 891     decode_tasks.Insert(decode_task);
 892     existing_pixel_refs[id] = decode_task;
 893   }
 894
 895   return RasterWorkerPool::CreateRasterTask(
 896       const_resource,
 897       tile->picture_pile(),
 898       tile->content_rect(),
 899       tile->contents_scale(),
 900       mts.raster_mode,
 901       mts.resolution,
 902       tile->layer_id(),
 903       static_cast<const void*>(tile),
 904       tile->source_frame_number(),
 905       rendering_stats_instrumentation_,
 906       base::Bind(&TileManager::OnRasterTaskCompleted,
 907                  base::Unretained(this),
 908                  tile->id(),
 909                  base::Passed(&resource),
 910                  mts.raster_mode),
 911       &decode_tasks,
 912       context_provider_);
 913 }
 914
 915 void TileManager::OnImageDecodeTaskCompleted(int layer_id,
 916                                              SkPixelRef* pixel_ref,
 917                                              bool was_canceled) {
 918   // If the task was canceled, we need to clean it up
 919   // from |image_decode_tasks_|.
 920   if (!was_canceled)
 921     return;
 922
 923   LayerPixelRefTaskMap::iterator layer_it = image_decode_tasks_.find(layer_id);
 924
 925   if (layer_it == image_decode_tasks_.end())
 926     return;
 927
 928   PixelRefTaskMap& pixel_ref_tasks = layer_it->second;
 929   PixelRefTaskMap::iterator task_it =
 930       pixel_ref_tasks.find(pixel_ref->getGenerationID());
 931
 932   if (task_it != pixel_ref_tasks.end())
 933     pixel_ref_tasks.erase(task_it);
 934 }
 935
 936 void TileManager::OnRasterTaskCompleted(
 937     Tile::Id tile_id,
 938     scoped_ptr<ScopedResource> resource,
 939     RasterMode raster_mode,
 940     const PicturePileImpl::Analysis& analysis,
 941     bool was_canceled) {
 942   TileMap::iterator it = tiles_.find(tile_id);
 943   if (it == tiles_.end()) {
 944     ++update_visible_tiles_stats_.canceled_count;
 945     resource_pool_->ReleaseResource(resource.Pass());
 946     return;
 947   }
 948
 949   Tile* tile = it->second;
 950   ManagedTileState& mts = tile->managed_state();
 951   ManagedTileState::TileVersion& tile_version = mts.tile_versions[raster_mode];
 952   DCHECK(!tile_version.raster_task_.is_null());
 953   tile_version.raster_task_.Reset();
 954
 955   if (was_canceled) {
 956     ++update_visible_tiles_stats_.canceled_count;
 957     resource_pool_->ReleaseResource(resource.Pass());
 958     return;
 959   }
 960
 961   ++update_visible_tiles_stats_.completed_count;
 962
 963   tile_version.set_has_text(analysis.has_text);
 964   if (analysis.is_solid_color) {
 965     tile_version.set_solid_color(analysis.solid_color);
 966     resource_pool_->ReleaseResource(resource.Pass());
 967   } else {
 968     tile_version.set_use_resource();
 969     tile_version.resource_ = resource.Pass();
 970
 971     bytes_releasable_ += BytesConsumedIfAllocated(tile);
 972     ++resources_releasable_;
 973   }
 974
 975   FreeUnusedResourcesForTile(tile);
 976   if (tile->priority(ACTIVE_TREE).distance_to_visible == 0.f)
 977     did_initialize_visible_tile_ = true;
 978 }
 979
 980 scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
 981                                             const gfx::Size& tile_size,
 982                                             const gfx::Rect& content_rect,
 983                                             const gfx::Rect& opaque_rect,
 984                                             float contents_scale,
 985                                             int layer_id,
 986                                             int source_frame_number,
 987                                             int flags) {
 988   scoped_refptr<Tile> tile = make_scoped_refptr(new Tile(this,
 989                                                          picture_pile,
 990                                                          tile_size,
 991                                                          content_rect,
 992                                                          opaque_rect,
 993                                                          contents_scale,
 994                                                          layer_id,
 995                                                          source_frame_number,
 996                                                          flags));
 997   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 998
 999   tiles_[tile->id()] = tile;
1000   used_layer_counts_[tile->layer_id()]++;
1001   prioritized_tiles_dirty_ = true;
1002   return tile;
1003 }
1004
1005 }  // namespace cc