cc: Keep most recently used resources at the front of resource queue.

cc/resources/resource_pool.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/resource_pool.h"
 
 #include <algorithm>
 
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
@@ skipping 73 matching lines @@
 
   SetResourceUsageLimits(0, 0);
   DCHECK_EQ(0u, unused_resources_.size());
   DCHECK_EQ(0u, in_use_memory_usage_bytes_);
   DCHECK_EQ(0u, total_memory_usage_bytes_);
   DCHECK_EQ(0u, total_resource_count_);
 }
 
 Resource* ResourcePool::AcquireResource(const gfx::Size& size,
                                         ResourceFormat format) {
-  for (ResourceDeque::iterator it = unused_resources_.begin();
-       it != unused_resources_.end(); ++it) {
+  // Traverse the |unused_resources_| from rear end as MRU resources are
+  // held at the rear end of the queue. This touches LRU resources only if
+  // needed, which inreases possibility of expiring more LRU resources
+  // within kResourceExpirationDelayMs.
+  for (ResourceDeque::reverse_iterator it = unused_resources_.rbegin();
+       it != unused_resources_.rend(); ++it) {
     ScopedResource* resource = *it;
     DCHECK(resource_provider_->CanLockForWrite(resource->id()));
 
     if (resource->format() != format)
       continue;
     if (resource->size() != size)
       continue;
 
     // Transfer resource to |in_use_resources_|.
-    in_use_resources_.set(resource->id(), unused_resources_.take(it));
+    in_use_resources_.set(resource->id(), unused_resources_.rtake(it));
     in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
         resource->size(), resource->format());
     return resource;
   }
 
   scoped_ptr<PoolResource> pool_resource =
       PoolResource::Create(resource_provider_);
   GLenum target =
       target_ ? target_ : resource_provider_->GetImageTextureTarget(format);
   pool_resource->AllocateManaged(size, target, format);
 
   DCHECK(ResourceUtil::VerifySizeInBytes<size_t>(pool_resource->size(),
                                                  pool_resource->format()));
   total_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
       pool_resource->size(), pool_resource->format());
   ++total_resource_count_;
 
   Resource* resource = pool_resource.get();
   in_use_resources_.set(resource->id(), pool_resource.Pass());
   in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
       resource->size(), resource->format());
   return resource;
 }
 
 Resource* ResourcePool::TryAcquireResourceWithContentId(uint64_t content_id) {

[reveman, 2015/11/02 01:47:07]

It shouldn't matter in what order we search the resources when looking for a
specific content id. Can we leave this function unmodified?

[prashant.n, 2015/11/02 04:07:20]

Ahh! I missed one content id = one resource (next_tile_id_). May be in this
patch it will not be needed. When we move the code to common function, there we
need to change this function.

   DCHECK(content_id);
 
-  auto it = std::find_if(unused_resources_.begin(), unused_resources_.end(),
-                         [content_id](const PoolResource* pool_resource) {
-                           return pool_resource->content_id() == content_id;
-                         });
-  if (it == unused_resources_.end())
+  // TODO(prashant.n): Move resource finding logic to common function.

[reveman, 2015/11/02 01:47:07]

I don't see much duplication of resource finding logic. Is this worthwhile?

[prashant.n, 2015/11/02 04:07:20]

Yes most of the code in getting resource from unused resources from
AcquireResource and TryAcquireResourceWithContentId is same execpt the search
criteria.

I think we should have separate function to do that job, which I was thining to
put in separate patch.

[reveman, 2015/11/02 04:32:59]

Ok, feel free to put up a patch for that and I'll review it. No need for this
TODO.

+  ResourceDeque::reverse_iterator it = unused_resources_.rbegin();
+  for (; it != unused_resources_.rend(); ++it) {
+    PoolResource* pool_resource = *it;
+    if (pool_resource->content_id() != content_id)
+      continue;
+  }
+
+  if (it == unused_resources_.rend())
     return nullptr;
 
   Resource* resource = *it;
   DCHECK(resource_provider_->CanLockForWrite(resource->id()));
 
   // Transfer resource to |in_use_resources_|.
-  in_use_resources_.set(resource->id(), unused_resources_.take(it));
+  in_use_resources_.set(resource->id(), unused_resources_.rtake(it));
   in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
       resource->size(), resource->format());
   return resource;
 }
 
 void ResourcePool::ReleaseResource(Resource* resource, uint64_t content_id) {
   auto it = in_use_resources_.find(resource->id());
   DCHECK(it != in_use_resources_.end());
 
   PoolResource* pool_resource = it->second;
@@ skipping 141 matching lines @@
   for (const auto& resource : busy_resources_) {
     resource->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
   }
   for (const auto& entry : in_use_resources_) {
     entry.second->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
   }
   return true;
 }
 
 }  // namespace cc