Add cheapness predictor success histogram

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 98 matching lines @@
 
 ManagedTileState::~ManagedTileState() {
   DCHECK(!resource);
   DCHECK(!resource_is_being_initialized);
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
-    bool record_rendering_stats)
+    bool record_rendering_stats,
+    bool use_cheapness_estimator)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads, record_rendering_stats)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
       bytes_pending_set_pixels_(0),
       ever_exceeded_memory_budget_(false),
-      record_rendering_stats_(record_rendering_stats) {
+      record_rendering_stats_(record_rendering_stats),
+      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;
     }
   }
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
@@ skipping 488 matching lines @@
       if (pixel_ref_id == (*pixel_it)->getGenerationID()) {
         pixel_refs.erase(pixel_it);
         break;
       }
     }
   }
 
   DispatchMoreTasks();
 }
 
-void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
-  TRACE_EVENT0("cc", "TileManager::DispatchOneRasterTask");
+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());
 
   managed_tile_state.resource_is_being_initialized = true;
   managed_tile_state.can_be_freed = false;
 
   DidTileRasterStateChange(tile, RASTER_STATE);
+  return resource.Pass();
+}
 
+void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
+  TRACE_EVENT0("cc", "TileManager::DispatchOneRasterTask");
+  scoped_ptr<ResourcePool::Resource> resource = PrepareTileForRaster(tile);
   ResourceProvider::ResourceId resource_id = resource->id();
 
   raster_worker_pool_->PostRasterTaskAndReply(
       tile->picture_pile(),
-      base::Bind(&TileManager::RunRasterTask,
+      base::Bind(&TileManager::PerformRaster,
                  resource_pool_->resource_provider()->mapPixelBuffer(
                      resource_id),
                  tile->content_rect_,
-                 tile->contents_scale()),
+                 tile->contents_scale(),
+                 use_cheapness_estimator_),
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile,
                  base::Passed(&resource),
                  manage_tiles_call_count_));
 }
 
-void TileManager::OnRasterTaskCompleted(
+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(),
+                use_cheapness_estimator_,
+                tile->picture_pile(),
+                &rendering_stats_);
+
+  OnRasterCompleted(tile, resource.Pass(), manage_tiles_call_count_);
+}
+
+void TileManager::OnRasterCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
     int manage_tiles_call_count_when_dispatched) {
-  TRACE_EVENT0("cc", "TileManager::OnRasterTaskCompleted");
+  TRACE_EVENT0("cc", "TileManager::OnRasterCompleted");
 
   // Release raster resources.
   resource_pool_->resource_provider()->unmapPixelBuffer(resource->id());
 
   ManagedTileState& managed_tile_state = tile->managed_state();
   managed_tile_state.can_be_freed = true;
 
   // Tile can be freed after the completion of the raster task. Call
   // AssignGpuMemoryToTiles() to re-assign gpu memory to highest priority
   // tiles if ManageTiles() was called since task was dispatched. The result
@@ skipping 20 matching lines @@
 
     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) {
+  OnRasterCompleted(tile, resource.Pass(),
+                    manage_tiles_call_count_when_dispatched);
   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;
 }
 
@@ skipping 22 matching lines @@
   --raster_state_count_[mts.raster_state][tree][mts.tree_bin[tree]];
   DCHECK_GE(raster_state_count_[mts.raster_state][tree][mts.tree_bin[tree]], 0);
 
   // Increment count for new bin.
   ++raster_state_count_[mts.raster_state][tree][bin];
 
   mts.tree_bin[tree] = bin;
 }
 
 // static
-void TileManager::RunRasterTask(uint8* buffer,
+void TileManager::PerformRaster(uint8* buffer,
                                 const gfx::Rect& rect,
                                 float contents_scale,
+                                bool use_cheapness_estimator,
                                 PicturePileImpl* picture_pile,
                                 RenderingStats* stats) {
-  TRACE_EVENT0("cc", "TileManager::RunRasterTask");
+  TRACE_EVENT0("cc", "TileManager::PerformRaster");
   DCHECK(picture_pile);
   DCHECK(buffer);
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height());
   bitmap.setPixels(buffer);
   SkDevice device(bitmap);
   SkCanvas canvas(&device);
 
   base::TimeTicks begin_time;
   if (stats)
     begin_time = base::TimeTicks::Now();
 
   picture_pile->Raster(&canvas, rect, contents_scale, stats);
 
   if (stats) {
     base::TimeTicks end_time = base::TimeTicks::Now();
     base::TimeDelta duration = end_time - begin_time;
     stats->totalRasterizeTime += duration;
-    UMA_HISTOGRAM_CUSTOM_COUNTS(
-      "Renderer4.PictureRasterTimeMS",
-      duration.InMilliseconds(),
-      0, 10, 10
-    );
+    UMA_HISTOGRAM_CUSTOM_COUNTS("Renderer4.PictureRasterTimeMS",
+                                duration.InMilliseconds(),
+                                0,
+                                10,
+                                10);
+
+    if (use_cheapness_estimator) {
+      bool is_predicted_cheap = picture_pile->IsCheapInRect (rect, contents_scale);
+      bool is_actually_cheap = duration.InMillisecondsF() <= 1.0f;
+      RecordCheapnessPredictorResults(is_predicted_cheap, is_actually_cheap);
+    }
   }
 }
 
 // static
+void TileManager::RecordCheapnessPredictorResults(bool is_predicted_cheap,
+                                                  bool is_actually_cheap) {
+  if (is_predicted_cheap && !is_actually_cheap)
+    UMA_HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorBadlyWrong", true);
+  else if (!is_predicted_cheap && is_actually_cheap)
+    UMA_HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorSafelyWrong", true);
+
+  UMA_HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorAccuracy",
+                        is_predicted_cheap == is_actually_cheap);
+}
+
+// static
 void TileManager::RunImageDecodeTask(skia::LazyPixelRef* pixel_ref,
                                      RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
   base::TimeTicks decode_begin_time;
   if (stats)
     decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   if (stats) {
     stats->totalDeferredImageDecodeCount++;
     stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::Now() - decode_begin_time;
   }
 }
 
 }  // namespace cc