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 61 matching lines @@
       this, task_runner_.get());
 }
 
 ResourcePool::~ResourcePool() {
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 
   DCHECK_EQ(0u, in_use_resources_.size());
 
   while (!busy_resources_.empty()) {
-    DidFinishUsingResource(busy_resources_.take_front());
+    DidFinishUsingResource(busy_resources_.take_back());
   }
 
   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) {
+  // Finding resources in |unused_resources_| from MRU to LRU direction, touches
+  // LRU resources only if needed, which inreases possibility of expiring more
+  // LRU resources within kResourceExpirationDelayMs.
   for (ResourceDeque::iterator it = unused_resources_.begin();
        it != unused_resources_.end(); ++it) {
     ScopedResource* resource = *it;
     DCHECK(resource_provider_->CanLockForWrite(resource->id()));
 
     if (resource->format() != format)
       continue;
     if (resource->size() != size)
       continue;
 
@@ skipping 45 matching lines @@
 
 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;
   pool_resource->set_content_id(content_id);
   pool_resource->set_last_usage(base::TimeTicks::Now());
 
   // Transfer resource to |busy_resources_|.
-  busy_resources_.push_back(in_use_resources_.take_and_erase(it));
+  busy_resources_.push_front(in_use_resources_.take_and_erase(it));
   in_use_memory_usage_bytes_ -= ResourceUtil::UncheckedSizeInBytes<size_t>(
       pool_resource->size(), pool_resource->format());
 
   // Now that we have evictable resources, schedule an eviction call for this
   // resource if necessary.
   ScheduleEvictExpiredResourcesIn(resource_expiration_delay_);
 }
 
 void ResourcePool::SetResourceUsageLimits(size_t max_memory_usage_bytes,
                                           size_t max_resource_count) {
   max_memory_usage_bytes_ = max_memory_usage_bytes;
   max_resource_count_ = max_resource_count;
 
   ReduceResourceUsage();
 }
 
 void ResourcePool::ReduceResourceUsage() {
   while (!unused_resources_.empty()) {
     if (!ResourceUsageTooHigh())
       break;
 
     // LRU eviction pattern. Most recently used might be blocked by
     // a read lock fence but it's still better to evict the least
     // recently used as it prevents a resource that is hard to reuse
     // because of unique size from being kept around. Resources that
     // can't be locked for write might also not be truly free-able.
     // We can free the resource here but it doesn't mean that the
     // memory is necessarily returned to the OS.
-    DeleteResource(unused_resources_.take_front());
+    DeleteResource(unused_resources_.take_back());
   }
 }
 
 bool ResourcePool::ResourceUsageTooHigh() {
   if (total_resource_count_ > max_resource_count_)
     return true;
   if (total_memory_usage_bytes_ > max_memory_usage_bytes_)
     return true;
   return false;
 }
@@ skipping 15 matching lines @@
     } else if (resource_provider_->IsLost(resource->id())) {
       // Remove lost resources from pool.
       DeleteResource(busy_resources_.take(it));
     } else {
       ++i;
     }
   }
 }
 
 void ResourcePool::DidFinishUsingResource(scoped_ptr<PoolResource> resource) {
-  unused_resources_.push_back(resource.Pass());
+  unused_resources_.push_front(resource.Pass());
 }
 
 void ResourcePool::ScheduleEvictExpiredResourcesIn(
     base::TimeDelta time_from_now) {
   if (evict_expired_resources_pending_)
     return;
 
   evict_expired_resources_pending_ = true;
 
   task_runner_->PostDelayedTask(FROM_HERE,
@@ skipping 18 matching lines @@
   ScheduleEvictExpiredResourcesIn(GetUsageTimeForLRUResource() +
                                   resource_expiration_delay_ - current_time);
 }
 
 void ResourcePool::EvictResourcesNotUsedSince(base::TimeTicks time_limit) {
   while (!unused_resources_.empty()) {
     // |unused_resources_| is not strictly ordered with regards to last_usage,
     // as this may not exactly line up with the time a resource became non-busy.
     // However, this should be roughly ordered, and will only introduce slight
     // delays in freeing expired resources.
-    if (unused_resources_.front()->last_usage() > time_limit)
+    if (unused_resources_.back()->last_usage() > time_limit)
       return;
 
-    DeleteResource(unused_resources_.take_front());
+    DeleteResource(unused_resources_.take_back());
   }
 
   // Also free busy resources older than the delay. With a sufficiently large
   // delay, such as the 1 second used here, any "busy" resources which have
   // expired are not likely to be busy. Additionally, freeing a "busy" resource
   // has no downside other than incorrect accounting.
   while (!busy_resources_.empty()) {
-    if (busy_resources_.front()->last_usage() > time_limit)
+    if (busy_resources_.back()->last_usage() > time_limit)
       return;
 
-    DeleteResource(busy_resources_.take_front());
+    DeleteResource(busy_resources_.take_back());
   }
 }
 
 base::TimeTicks ResourcePool::GetUsageTimeForLRUResource() const {
   if (!unused_resources_.empty()) {
-    return unused_resources_.front()->last_usage();
+    return unused_resources_.back()->last_usage();
   }
 
   // This is only called when we have at least one evictable resource.
   DCHECK(!busy_resources_.empty());
-  return busy_resources_.front()->last_usage();
+  return busy_resources_.back()->last_usage();
 }
 
 bool ResourcePool::OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                                 base::trace_event::ProcessMemoryDump* pmd) {
   for (const auto& resource : unused_resources_) {
     resource->OnMemoryDump(pmd, resource_provider_, true /* is_free */);
   }
   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