cc: Heapify pointers instead of objects in eviction tile priority queue.

This patch ensures that we heapify pointers instead of objects in
priority queue eviction.

Performance data:
Before:
tile_manager_eviction_tile_queue_construct:
2= 411875.46875 runs/s
10= 8762.1435546875 runs/s
50= 48.008880615234375 runs/s

tile_manager_eviction_tile_queue_construct_and_iterate:
2_16= 3337.1767578125 runs/s
2_32= 3041.9306640625 runs/s
2_64= 2513.700439453125 runs/s
2_128= 1940.756591796875 runs/s

After:
tile_manager_eviction_tile_queue_construct:
2= 391767.84375 runs/s (-5%)
10= 8705.869140625 runs/s (-2%)
50= 49.93892288208008 runs/s (+4%)

tile_manager_eviction_tile_queue_construct_and_iterate:
2_16= 3691.25146484375 runs/s (+10%)
2_32= 3666.619384765625 runs/s (+20%)
2_64= 3544.351318359375 runs/s (+41%)
2_128= 3341.751708984375 runs/s (+72%)

R=reveman

Review URL: https://codereview.chromium.org/430053003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@287846 0039d316-1c4b-4281-b951-d872f2087c98

cc/resources/eviction_tile_priority_queue.cc

@@ -14,21 +14,21 @@ class EvictionOrderComparator {
       : tree_priority_(tree_priority) {}
 
   bool operator()(
-      const EvictionTilePriorityQueue::PairedPictureLayerQueue& a,
-      const EvictionTilePriorityQueue::PairedPictureLayerQueue& b) const {
-    if (a.IsEmpty())
+      const EvictionTilePriorityQueue::PairedPictureLayerQueue* a,
+      const EvictionTilePriorityQueue::PairedPictureLayerQueue* b) const {
+    if (a->IsEmpty())
       return true;
 
-    if (b.IsEmpty())
+    if (b->IsEmpty())
       return false;
 
-    WhichTree a_tree = a.NextTileIteratorTree(tree_priority_);
+    WhichTree a_tree = a->NextTileIteratorTree(tree_priority_);
     const PictureLayerImpl::LayerEvictionTileIterator* a_iterator =
-        a_tree == ACTIVE_TREE ? &a.active_iterator : &a.pending_iterator;
+        a_tree == ACTIVE_TREE ? &a->active_iterator : &a->pending_iterator;
 
-    WhichTree b_tree = b.NextTileIteratorTree(tree_priority_);
+    WhichTree b_tree = b->NextTileIteratorTree(tree_priority_);
     const PictureLayerImpl::LayerEvictionTileIterator* b_iterator =
-        b_tree == ACTIVE_TREE ? &b.active_iterator : &b.pending_iterator;
+        b_tree == ACTIVE_TREE ? &b->active_iterator : &b->pending_iterator;
 
     const Tile* a_tile = **a_iterator;
     const Tile* b_tile = **b_iterator;
@@ -96,12 +96,11 @@ void EvictionTilePriorityQueue::Build(
            paired_layers.begin();
        it != paired_layers.end();
        ++it) {
-    paired_queues_.push_back(PairedPictureLayerQueue(*it, tree_priority_));
+    paired_queues_.push_back(
+        make_scoped_ptr(new PairedPictureLayerQueue(*it, tree_priority_)));
   }
 
-  std::make_heap(paired_queues_.begin(),
-                 paired_queues_.end(),
-                 EvictionOrderComparator(tree_priority_));
+  paired_queues_.make_heap(EvictionOrderComparator(tree_priority_));
 }
 
 void EvictionTilePriorityQueue::Reset() {
@@ -109,25 +108,21 @@ void EvictionTilePriorityQueue::Reset() {
 }
 
 bool EvictionTilePriorityQueue::IsEmpty() const {
-  return paired_queues_.empty() || paired_queues_.front().IsEmpty();
+  return paired_queues_.empty() || paired_queues_.front()->IsEmpty();
 }
 
 Tile* EvictionTilePriorityQueue::Top() {
   DCHECK(!IsEmpty());
-  return paired_queues_.front().Top(tree_priority_);
+  return paired_queues_.front()->Top(tree_priority_);
 }
 
 void EvictionTilePriorityQueue::Pop() {
   DCHECK(!IsEmpty());
 
-  std::pop_heap(paired_queues_.begin(),
-                paired_queues_.end(),
-                EvictionOrderComparator(tree_priority_));
-  PairedPictureLayerQueue& paired_queue = paired_queues_.back();
-  paired_queue.Pop(tree_priority_);
-  std::push_heap(paired_queues_.begin(),
-                 paired_queues_.end(),
-                 EvictionOrderComparator(tree_priority_));
+  paired_queues_.pop_heap(EvictionOrderComparator(tree_priority_));
+  PairedPictureLayerQueue* paired_queue = paired_queues_.back();
+  paired_queue->Pop(tree_priority_);
+  paired_queues_.push_heap(EvictionOrderComparator(tree_priority_));
 }
 
 EvictionTilePriorityQueue::PairedPictureLayerQueue::PairedPictureLayerQueue() {

cc/resources/eviction_tile_priority_queue.h

@@ -47,7 +47,10 @@ class CC_EXPORT EvictionTilePriorityQueue {
   void Pop();
 
  private:
-  std::vector<PairedPictureLayerQueue> paired_queues_;
+  // TODO(vmpstr): This is potentially unnecessary if it becomes the case that
+  // PairedPictureLayerQueue is fast enough to copy. In that case, we can use
+  // objects directly (ie std::vector<PairedPictureLayerQueue>).
+  ScopedPtrVector<PairedPictureLayerQueue> paired_queues_;
   TreePriority tree_priority_;
 
   DISALLOW_COPY_AND_ASSIGN(EvictionTilePriorityQueue);

cc/resources/raster_tile_priority_queue.cc

@@ -83,33 +83,33 @@ void RasterTilePriorityQueue::Build(
            paired_layers.begin();
        it != paired_layers.end();
        ++it) {
-    paired_queues_heap_.push_back(
+    paired_queues_.push_back(
         make_scoped_ptr(new PairedPictureLayerQueue(*it, tree_priority_)));
   }
 
-  paired_queues_heap_.make_heap(RasterOrderComparator(tree_priority_));
+  paired_queues_.make_heap(RasterOrderComparator(tree_priority_));
 }
 
 void RasterTilePriorityQueue::Reset() {
-  paired_queues_heap_.clear();
+  paired_queues_.clear();
 }
 
 bool RasterTilePriorityQueue::IsEmpty() const {
-  return paired_queues_heap_.empty() || paired_queues_heap_.front()->IsEmpty();
+  return paired_queues_.empty() || paired_queues_.front()->IsEmpty();
 }
 
 Tile* RasterTilePriorityQueue::Top() {
   DCHECK(!IsEmpty());
-  return paired_queues_heap_.front()->Top(tree_priority_);
+  return paired_queues_.front()->Top(tree_priority_);
 }
 
 void RasterTilePriorityQueue::Pop() {
   DCHECK(!IsEmpty());
 
-  paired_queues_heap_.pop_heap(RasterOrderComparator(tree_priority_));
-  PairedPictureLayerQueue* paired_queue = paired_queues_heap_.back();
+  paired_queues_.pop_heap(RasterOrderComparator(tree_priority_));
+  PairedPictureLayerQueue* paired_queue = paired_queues_.back();
   paired_queue->Pop(tree_priority_);
-  paired_queues_heap_.push_heap(RasterOrderComparator(tree_priority_));
+  paired_queues_.push_heap(RasterOrderComparator(tree_priority_));
 }
 
 RasterTilePriorityQueue::PairedPictureLayerQueue::PairedPictureLayerQueue() {

cc/resources/raster_tile_priority_queue.h

@@ -50,7 +50,7 @@ class CC_EXPORT RasterTilePriorityQueue {
   // TODO(vmpstr): This is potentially unnecessary if it becomes the case that
   // PairedPictureLayerQueue is fast enough to copy. In that case, we can use
   // objects directly (ie std::vector<PairedPictureLayerQueue>.
-  ScopedPtrVector<PairedPictureLayerQueue> paired_queues_heap_;
+  ScopedPtrVector<PairedPictureLayerQueue> paired_queues_;
   TreePriority tree_priority_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTilePriorityQueue);