cc: Remove memory state from tile management

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 <string>
 
 #include "base/bind.h"
@@ skipping 289 matching lines @@
   if (!client_->ShouldForceTileUploadsRequiredForActivationToComplete())
     return;
 
   TileSet initialized_tiles;
   for (TileSet::iterator it =
            tiles_that_need_to_be_initialized_for_activation_.begin();
        it != tiles_that_need_to_be_initialized_for_activation_.end();
        ++it) {
     Tile* tile = *it;
     if (!tile->managed_state().raster_task.is_null() &&
-        tile->tile_version().memory_state_ == USING_UNRELEASABLE_MEMORY &&
         !tile->tile_version().forced_upload_) {
       if (!raster_worker_pool_->ForceUploadToComplete(
               tile->managed_state().raster_task))
         continue;
 
       // Setting |forced_upload_| to true makes this tile ready to draw.
       tile->tile_version().forced_upload_ = true;
       initialized_tiles.insert(tile);
     }
   }
 
   for (TileSet::iterator it = initialized_tiles.begin();
        it != initialized_tiles.end();
        ++it) {
     Tile* tile = *it;
     DidFinishTileInitialization(tile);
     DCHECK(tile->tile_version().IsReadyToDraw());
   }
 }
 
 void TileManager::GetMemoryStats(
     size_t* memory_required_bytes,
     size_t* memory_nice_to_have_bytes,
     size_t* memory_used_bytes) const {
   *memory_required_bytes = 0;
   *memory_nice_to_have_bytes = 0;
-  *memory_used_bytes = 0;
+  *memory_used_bytes = resource_pool_->acquired_memory_usage_bytes();
   for (TileVector::const_iterator it = tiles_.begin();
        it != tiles_.end();
        ++it) {
     const Tile* tile = *it;
     if (!tile->tile_version().requires_resource())
       continue;
 
     const ManagedTileState& mts = tile->managed_state();
     size_t tile_bytes = tile->bytes_consumed_if_allocated();
     if (mts.gpu_memmgr_stats_bin == NOW_BIN)
       *memory_required_bytes += tile_bytes;
     if (mts.gpu_memmgr_stats_bin != NEVER_BIN)
       *memory_nice_to_have_bytes += tile_bytes;
-    if (tile->tile_version().memory_state_ != NOT_ALLOWED_TO_USE_MEMORY)
-      *memory_used_bytes += tile_bytes;
   }
 }
 
 scoped_ptr<base::Value> TileManager::BasicStateAsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetInteger("tile_count", tiles_.size());
   state->Set("global_state", global_state_.AsValue().release());
   state->Set("memory_requirements", GetMemoryRequirementsAsValue().release());
   return state.PassAs<base::Value>();
 }
@@ skipping 28 matching lines @@
 void TileManager::AddRequiredTileForActivation(Tile* tile) {
   DCHECK(std::find(tiles_that_need_to_be_initialized_for_activation_.begin(),
                    tiles_that_need_to_be_initialized_for_activation_.end(),
                    tile) ==
          tiles_that_need_to_be_initialized_for_activation_.end());
   tiles_that_need_to_be_initialized_for_activation_.insert(tile);
 }
 
 void TileManager::AssignGpuMemoryToTiles() {
   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
-  size_t unreleasable_bytes = 0;
 
   // Now give memory out to the tiles until we're out, and build
   // the needs-to-be-rasterized queue.
   tiles_that_need_to_be_rasterized_.clear();
   tiles_that_need_to_be_initialized_for_activation_.clear();
 
-  // By clearing the tiles_that_need_to_be_rasterized_ vector list
-  // above we move all tiles currently waiting for raster to idle state.
-  // Some memory cannot be released. We figure out how much in this
-  // loop.
+  size_t bytes_releasable = 0;
   for (TileVector::const_iterator it = tiles_.begin();
        it != tiles_.end();
        ++it) {
     const Tile* tile = *it;
-    if (tile->tile_version().memory_state_ == USING_UNRELEASABLE_MEMORY)
-      unreleasable_bytes += tile->bytes_consumed_if_allocated();
+    if (tile->tile_version().resource_)
+      bytes_releasable += tile->bytes_consumed_if_allocated();
   }
 
-  // Global state's memory limit can decrease, causing
-  // it to be less than unreleasable_bytes
+  int64 signed_bytes_allocatable =
+      static_cast<int64>(bytes_releasable +
+                         global_state_.memory_limit_in_bytes) -
+      static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());

[reveman, 2013/06/03 19:48:36]

consider using:
int64 bytes_available = memory_limit_in_bytes - acquired_memory_usage_bytes;

+
   size_t bytes_allocatable =
-      global_state_.memory_limit_in_bytes > unreleasable_bytes ?
-      global_state_.memory_limit_in_bytes - unreleasable_bytes :
-      0;
+      std::max(static_cast<int64>(0), signed_bytes_allocatable);
+
   size_t bytes_that_exceeded_memory_budget_in_now_bin = 0;
   size_t bytes_left = bytes_allocatable;
   size_t bytes_oom_in_now_bin_on_pending_tree = 0;
   TileVector tiles_requiring_memory_but_oomed;
   bool higher_priority_tile_oomed = false;
   for (TileVector::iterator it = tiles_.begin();
        it != tiles_.end();
        ++it) {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
     ManagedTileState::TileVersion& tile_version = tile->tile_version();
 
     // If this tile doesn't need a resource, then nothing to do.
     if (!tile_version.requires_resource())
       continue;
 
-    size_t tile_bytes = tile->bytes_consumed_if_allocated();
-    // Memory is already reserved for tile with unreleasable memory
-    // so adding it to |tiles_that_need_to_be_rasterized_| doesn't
-    // affect bytes_allocatable.
-    if (tile_version.memory_state_ == USING_UNRELEASABLE_MEMORY)
-      tile_bytes = 0;
-
     // If the tile is not needed, free it up.
     if (mts.is_in_never_bin_on_both_trees()) {
-      if (tile_version.memory_state_ != USING_UNRELEASABLE_MEMORY) {
-        FreeResourcesForTile(tile);
-        tile_version.memory_state_ = NOT_ALLOWED_TO_USE_MEMORY;
-      }
+      FreeResourcesForTile(tile);
       continue;
     }
 
+    size_t tile_bytes = 0;
+
+    // It costs to maintain a resource.
+    if (tile_version.resource_)
+      tile_bytes += tile->bytes_consumed_if_allocated();
+
+    // It will cost to allocate a resource.
+    // Note that this is separate from the above condition,
+    // so that it's clear why we're adding memory.
+    if (!tile_version.resource_ && mts.raster_task.is_null())
+      tile_bytes += tile->bytes_consumed_if_allocated();
+
     // Tile is OOM.
     if (tile_bytes > bytes_left) {
       tile->tile_version().set_rasterize_on_demand();
       if (mts.tree_bin[PENDING_TREE] == NOW_BIN) {
         tiles_requiring_memory_but_oomed.push_back(tile);
         bytes_oom_in_now_bin_on_pending_tree += tile_bytes;
       }
       FreeResourcesForTile(tile);
       higher_priority_tile_oomed = true;
       continue;
@@ skipping 19 matching lines @@
   }
 
   // In OOM situation, we iterate tiles_, remove the memory for active tree
   // and not the now bin. And give them to bytes_oom_in_now_bin_on_pending_tree
   if (!tiles_requiring_memory_but_oomed.empty()) {
     size_t bytes_freed = 0;
     for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
       Tile* tile = *it;
       ManagedTileState& mts = tile->managed_state();
       ManagedTileState::TileVersion& tile_version = tile->tile_version();
-      if ((tile_version.memory_state_ == CAN_USE_MEMORY ||
-           tile_version.memory_state_ == USING_RELEASABLE_MEMORY) &&
+      if (tile_version.resource_ &&
           mts.tree_bin[PENDING_TREE] == NEVER_BIN &&
           mts.tree_bin[ACTIVE_TREE] != NOW_BIN) {
         DCHECK(!tile->required_for_activation());
         FreeResourcesForTile(tile);
         tile_version.set_rasterize_on_demand();
         bytes_freed += tile->bytes_consumed_if_allocated();
         TileVector::iterator it = std::find(
                 tiles_that_need_to_be_rasterized_.begin(),
                 tiles_that_need_to_be_rasterized_.end(),
                 tile);
@@ skipping 23 matching lines @@
       bytes_that_exceeded_memory_budget_in_now_bin > 0;
   if (ever_exceeded_memory_budget_) {
       TRACE_COUNTER_ID2("cc", "over_memory_budget", this,
                         "budget", global_state_.memory_limit_in_bytes,
                         "over", bytes_that_exceeded_memory_budget_in_now_bin);
   }
   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 = unreleasable_bytes;
+  memory_stats_from_last_assign_.bytes_unreleasable =
+      bytes_allocatable - bytes_releasable;
   memory_stats_from_last_assign_.bytes_over =
       bytes_that_exceeded_memory_budget_in_now_bin;
 }
 
 void TileManager::FreeResourcesForTile(Tile* tile) {
-  DCHECK_NE(USING_UNRELEASABLE_MEMORY, tile->tile_version().memory_state_);
   if (tile->tile_version().resource_) {
     resource_pool_->ReleaseResource(
         tile->tile_version().resource_.Pass());
   }
-  tile->tile_version().memory_state_ = NOT_ALLOWED_TO_USE_MEMORY;
 }
 
 void TileManager::ScheduleTasks() {
   TRACE_EVENT0("cc", "TileManager::ScheduleTasks");
   RasterWorkerPool::RasterTask::Queue tasks;
 
   // Build a new task queue containing all task currently needed. Tasks
   // are added in order of priority, highest priority task first.
   for (TileVector::iterator it = tiles_that_need_to_be_rasterized_.begin();
        it != tiles_that_need_to_be_rasterized_.end();
@@ skipping 56 matching lines @@
 
 RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
   TRACE_EVENT0("cc", "TileManager::CreateRasterTask");
 
   scoped_ptr<ResourcePool::Resource> resource =
       resource_pool_->AcquireResource(
           tile->tile_size_.size(),
           tile->tile_version().resource_format_);
   const Resource* const_resource = resource.get();
 
-  DCHECK_EQ(CAN_USE_MEMORY, tile->tile_version().memory_state_);
-  tile->tile_version().memory_state_ = USING_UNRELEASABLE_MEMORY;
   tile->tile_version().resource_id_ = resource->id();
 
   PicturePileImpl::Analysis* analysis = new PicturePileImpl::Analysis;
 
   // Create and queue all image decode tasks that this tile depends on.
   RasterWorkerPool::Task::Set decode_tasks;
   for (PicturePileImpl::PixelRefIterator iter(tile->content_rect(),
                                               tile->contents_scale(),
                                               tile->picture_pile());
        iter; ++iter) {
@@ skipping 50 matching lines @@
     scoped_ptr<ResourcePool::Resource> resource,
     PicturePileImpl::Analysis* analysis,
     bool was_canceled) {
   TRACE_EVENT1("cc", "TileManager::OnRasterTaskCompleted",
                "was_canceled", was_canceled);
 
   ManagedTileState& mts = tile->managed_state();
   DCHECK(!mts.raster_task.is_null());
   mts.raster_task.Reset();
 
-  // Tile resources can't be freed until task has completed.
-  DCHECK_EQ(USING_UNRELEASABLE_MEMORY, tile->tile_version().memory_state_);
-
   if (was_canceled) {
-    tile->tile_version().memory_state_ = CAN_USE_MEMORY;
     resource_pool_->ReleaseResource(resource.Pass());
     return;
   }
 
   mts.picture_pile_analysis = *analysis;
   mts.picture_pile_analyzed = true;
 
   if (analysis->is_solid_color) {
     tile->tile_version().set_solid_color(analysis->solid_color);
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
-    tile->tile_version().memory_state_ = USING_RELEASABLE_MEMORY;
     tile->tile_version().resource_ = resource.Pass();
   }
 
   DidFinishTileInitialization(tile.get());
 }
 
 void TileManager::DidFinishTileInitialization(Tile* tile) {
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
   if (tile->required_for_activation()) {
@@ skipping 116 matching lines @@
         100000,
         100);
   } else {
     picture_pile->RasterToBitmap(&canvas, rect, contents_scale, NULL);
   }
 
   return true;
 }
 
 }  // namespace cc