cc: Check for completed raster tasks at interval.

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 "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 12 matching lines @@
 
 // If we raster too fast we become upload bound, and pending
 // uploads consume memory. For maximum upload throughput, we would
 // want to allow for upload_throughput * pipeline_time of pending
 // uploads, after which we are just wasting memory. Since we don't
 // know our upload throughput yet, this just caps our memory usage.
 #if defined(OS_ANDROID)
 // For reference, the Nexus10 can upload 1MB in about 2.5ms.
 // Assuming a three frame deep pipeline this implies ~20MB.
 const int kMaxPendingUploadBytes = 20 * 1024 * 1024;
+const int kMaxPendingRasterBytes = 2 * 1024 * 1024;
 #else
 const int kMaxPendingUploadBytes = 100 * 1024 * 1024;
+const int kMaxPendingRasterBytes = 10 * 1024 * 1024;
 #endif
 
 // Determine bin based on three categories of tiles: things we need now,
 // things we need soon, and eventually.
 inline TileManagerBin BinFromTilePriority(const TilePriority& prio) {
   if (!prio.is_live)
     return NEVER_BIN;
 
   // The amount of time for which we want to have prepainting coverage.
   const double prepainting_window_time_seconds = 1.0;
@@ skipping 120 matching lines @@
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
     bool use_cheapness_estimator)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
+      bytes_pending_raster_(0),
       bytes_pending_set_pixels_(0),
+      need_shallow_flush_(false),
       ever_exceeded_memory_budget_(false),
       record_rendering_stats_(false),
       use_cheapness_estimator_(use_cheapness_estimator) {
   for (int i = 0; i < NUM_STATES; ++i) {
     for (int j = 0; j < NUM_TREES; ++j) {
       for (int k = 0; k < NUM_BINS; ++k)
         raster_state_count_[i][j][k] = 0;
     }
   }
 }
@@ skipping 439 matching lines @@
 }
 
 void TileManager::FreeResourcesForTile(Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.can_be_freed);
   if (managed_tile_state.resource)
     resource_pool_->ReleaseResource(managed_tile_state.resource.Pass());
 }
 
 bool TileManager::CanDispatchRasterTask(Tile* tile) {
-  if (raster_worker_pool_->IsBusy())
+  size_t new_raster_bytes_pending = bytes_pending_raster_;
+  new_raster_bytes_pending += tile->bytes_consumed_if_allocated();
+  if (new_raster_bytes_pending > kMaxPendingRasterBytes)
     return false;
-  size_t new_bytes_pending = bytes_pending_set_pixels_;
-  new_bytes_pending += tile->bytes_consumed_if_allocated();
-  return new_bytes_pending <= kMaxPendingUploadBytes;
+
+  size_t new_upload_bytes_pending = bytes_pending_raster_ +
+      bytes_pending_set_pixels_;
+  new_upload_bytes_pending += tile->bytes_consumed_if_allocated();
+  if (new_upload_bytes_pending > kMaxPendingUploadBytes)
+    return false;
+
+  return true;
 }
 
 void TileManager::DispatchMoreTasks() {
+  // If a flush is needed, do it now before we start dispatching more tasks.
+  if (need_shallow_flush_) {

[nduca, 2013/02/13 08:29:32]

hmmm the position of this group surprised me, I was sort of hoping to see this
on the raster task callback... whys it not called after we get the raster task
and do the upload?

[reveman, 2013/02/13 08:46:38]

this is just common code that is always executed after task completion and it
shouldn't hurt to have it here if DispatchMoreTasks is called for a different
reason. But I can move this to OnImageDecodeTaskCompleted and
OnRasterTaskCompleted if you prefer that?

+    resource_pool_->resource_provider()->shallowFlushIfSupported();
+    need_shallow_flush_ = false;
+  }
+
   // Because tiles in the image decoding list have higher priorities, we
   // need to process those tiles first before we start to handle the tiles
   // in the need_to_be_rasterized queue.
   for(TileList::iterator it = tiles_with_image_decoding_tasks_.begin();
       it != tiles_with_image_decoding_tasks_.end(); ) {
     DispatchImageDecodeTasksForTile(*it);
     ManagedTileState& managed_state = (*it)->managed_state();
     if (managed_state.pending_pixel_refs.empty()) {
       if (!CanDispatchRasterTask(*it))
         return;
@@ skipping 50 matching lines @@
     if (pending_decode_tasks_.end() != pending_decode_tasks_.find(
         (*it)->getGenerationID())) {
       ++it;
       continue;
     }
     // TODO(qinmin): passing correct image size to PrepareToDecode().
     if ((*it)->PrepareToDecode(skia::LazyPixelRef::PrepareParams())) {
       rendering_stats_.totalDeferredImageCacheHitCount++;
       pending_pixel_refs.erase(it++);
     } else {
-      if (raster_worker_pool_->IsBusy())
+      if (!CanDispatchRasterTask(tile))
         return;
       DispatchOneImageDecodeTask(tile, *it);
       ++it;
     }
   }
 }
 
 void TileManager::DispatchOneImageDecodeTask(
     scoped_refptr<Tile> tile, skia::LazyPixelRef* pixel_ref) {
   TRACE_EVENT0("cc", "TileManager::DispatchOneImageDecodeTask");
   uint32_t pixel_ref_id = pixel_ref->getGenerationID();
   DCHECK(pending_decode_tasks_.end() ==
       pending_decode_tasks_.find(pixel_ref_id));
   pending_decode_tasks_[pixel_ref_id] = pixel_ref;
 
   raster_worker_pool_->PostTaskAndReply(
       base::Bind(&TileManager::RunImageDecodeTask, pixel_ref),
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
                  tile,
                  pixel_ref_id));
 }
 
 void TileManager::OnImageDecodeTaskCompleted(
-    scoped_refptr<Tile> tile, uint32_t pixel_ref_id) {
+    scoped_refptr<Tile> tile,
+    uint32_t pixel_ref_id,
+    bool more_tasks_completed) {
   TRACE_EVENT0("cc", "TileManager::OnImageDecodeTaskCompleted");
   pending_decode_tasks_.erase(pixel_ref_id);
 
   for (TileList::iterator it = tiles_with_image_decoding_tasks_.begin();
       it != tiles_with_image_decoding_tasks_.end(); ++it) {
     std::list<skia::LazyPixelRef*>& pixel_refs =
         (*it)->managed_state().pending_pixel_refs;
     for (std::list<skia::LazyPixelRef*>::iterator pixel_it =
         pixel_refs.begin(); pixel_it != pixel_refs.end(); ++pixel_it) {
       if (pixel_ref_id == (*pixel_it)->getGenerationID()) {
         pixel_refs.erase(pixel_it);
         break;
       }
     }
   }
 
-  DispatchMoreTasks();
+  if (!more_tasks_completed)
+    DispatchMoreTasks();
 }
 
 scoped_ptr<ResourcePool::Resource> TileManager::PrepareTileForRaster(
     Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.can_use_gpu_memory);
   scoped_ptr<ResourcePool::Resource> resource =
       resource_pool_->AcquireResource(tile->tile_size_.size(), tile->format_);
   resource_pool_->resource_provider()->acquirePixelBuffer(resource->id());
 
@@ skipping 15 matching lines @@
                  resource_pool_->resource_provider()->mapPixelBuffer(
                      resource_id),
                  tile->content_rect_,
                  tile->contents_scale(),
                  use_cheapness_estimator_),
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile,
                  base::Passed(&resource),
                  manage_tiles_call_count_));
+
+  bytes_pending_raster_ += tile->bytes_consumed_if_allocated();
 }
 
 void TileManager::PerformOneRaster(Tile* tile) {
   scoped_ptr<ResourcePool::Resource> resource = PrepareTileForRaster(tile);
   ResourceProvider::ResourceId resource_id = resource->id();
 
   PerformRaster(resource_pool_->resource_provider()->mapPixelBuffer(
                     resource_id),
                 tile->content_rect_,
                 tile->contents_scale(),
@@ skipping 30 matching lines @@
     // The component order may be bgra if we're uploading bgra pixels to rgba
     // texture. Mark contents as swizzled if image component order is
     // different than texture format.
     managed_tile_state.contents_swizzled =
         !PlatformColor::sameComponentOrder(tile->format_);
 
     // Tile resources can't be freed until upload has completed.
     managed_tile_state.can_be_freed = false;
 
     resource_pool_->resource_provider()->beginSetPixels(resource->id());
-    resource_pool_->resource_provider()->shallowFlushIfSupported();
+    need_shallow_flush_ = true;
+
     managed_tile_state.resource = resource.Pass();
 
     bytes_pending_set_pixels_ += tile->bytes_consumed_if_allocated();
     DidTileRasterStateChange(tile, SET_PIXELS_STATE);
     tiles_with_pending_set_pixels_.push(tile);
   } else {
     resource_pool_->resource_provider()->releasePixelBuffer(resource->id());
     resource_pool_->ReleaseResource(resource.Pass());
     managed_tile_state.resource_is_being_initialized = false;
     DidTileRasterStateChange(tile, IDLE_STATE);
   }
 }
 
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
-    int manage_tiles_call_count_when_dispatched) {
+    int manage_tiles_call_count_when_dispatched,
+    bool more_tasks_completed) {
+  bytes_pending_raster_ -= tile->bytes_consumed_if_allocated();
   OnRasterCompleted(tile, resource.Pass(),
                     manage_tiles_call_count_when_dispatched);
-  DispatchMoreTasks();
+  if (!more_tasks_completed)
+    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;
 }
 
 void TileManager::DidTileRasterStateChange(Tile* tile, TileRasterState state) {
@@ skipping 92 matching lines @@
     decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   if (stats) {
     stats->totalDeferredImageDecodeCount++;
     stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::Now() - decode_begin_time;
   }
 }
 
 }  // namespace cc