[WeakMemoryCache] Remove dead/live distinction of Resource outside core/fetch

components/web_cache/browser/web_cache_manager.cc

 // Copyright (c) 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 "components/web_cache/browser/web_cache_manager.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 117 matching lines @@
     inactive_renderers_.erase(elmt);
 
     // A renderer that was inactive, just became active.  We should make sure
     // it is given a fair cache allocation, but we defer this for a bit in
     // order to make this function call cheap.
     ReviseAllocationStrategyLater();
   }
 }
 
 void WebCacheManager::ObserveStats(int renderer_id,
-                                   uint64_t min_dead_capacity,
-                                   uint64_t max_dead_capacity,
                                    uint64_t capacity,
-                                   uint64_t live_size,
-                                   uint64_t dead_size) {
+                                   uint64_t size) {
   StatsMap::iterator entry = stats_.find(renderer_id);
   if (entry == stats_.end())
     return;  // We might see stats for a renderer that has been destroyed.
 
   // Record the updated stats.
   entry->second.capacity = capacity;
-  entry->second.dead_size = dead_size;
-  entry->second.live_size = live_size;
-  entry->second.max_dead_capacity = max_dead_capacity;
-  entry->second.min_dead_capacity = min_dead_capacity;
+  entry->second.size = size;
 }
 
 void WebCacheManager::SetGlobalSizeLimit(uint64_t bytes) {
   global_size_limit_ = bytes;
   ReviseAllocationStrategyLater();
 }
 
 void WebCacheManager::ClearCache() {
   // Tell each renderer process to clear the cache.
   ClearRendererCache(active_renderers_, INSTANTLY);
@@ skipping 29 matching lines @@
   }
 }
 
 // static
 uint64_t WebCacheManager::GetDefaultGlobalSizeLimit() {
   return GetDefaultCacheSize();
 }
 
 void WebCacheManager::GatherStats(const std::set<int>& renderers,
                                   uint64_t* capacity,
-                                  uint64_t* live_size,
-                                  uint64_t* dead_size) {
-  *capacity = *live_size = *dead_size = 0;
+                                  uint64_t* size) {
+  *capacity = *size = 0;
 
   std::set<int>::const_iterator iter = renderers.begin();
   while (iter != renderers.end()) {
     StatsMap::iterator elmt = stats_.find(*iter);
     if (elmt != stats_.end()) {
       *capacity += elmt->second.capacity;
-      *live_size += elmt->second.live_size;
-      *dead_size += elmt->second.dead_size;
+      *size += elmt->second.size;
     }
     ++iter;
   }
 }
 
 // static
-uint64_t WebCacheManager::GetSize(AllocationTactic tactic,
-                                 uint64_t live_size,
-                                 uint64_t dead_size) {
+uint64_t WebCacheManager::GetSize(AllocationTactic tactic, uint64_t size) {
   switch (tactic) {
   case DIVIDE_EVENLY:
     // We aren't going to reserve any space for existing objects.
     return 0;
   case KEEP_CURRENT_WITH_HEADROOM:
     // We need enough space for our current objects, plus some headroom.
-    return 3 * GetSize(KEEP_CURRENT, live_size, dead_size) / 2;
+    return 3 * GetSize(KEEP_CURRENT, size) / 2;
   case KEEP_CURRENT:
     // We need enough space to keep our current objects.
-    return live_size + dead_size;
-  case KEEP_LIVE_WITH_HEADROOM:
-    // We need enough space to keep out live resources, plus some headroom.
-    return 3 * GetSize(KEEP_LIVE, live_size, dead_size) / 2;
-  case KEEP_LIVE:
-    // We need enough space to keep our live resources.
-    return live_size;
+    return size;
   default:
     NOTREACHED() << "Unknown cache allocation tactic";
     return 0;
   }
 }
 
-bool WebCacheManager::AttemptTactic(
-    AllocationTactic active_tactic,
-    uint64_t active_live_size,
-    uint64_t active_dead_size,
-    AllocationTactic inactive_tactic,
-    uint64_t inactive_live_size,
-    uint64_t inactive_dead_size,
-    AllocationStrategy* strategy) {
+bool WebCacheManager::AttemptTactic(AllocationTactic active_tactic,
+                                    uint64_t active_used_size,
+                                    AllocationTactic inactive_tactic,
+                                    uint64_t inactive_used_size,
+                                    AllocationStrategy* strategy) {
   DCHECK(strategy);
 
-  uint64_t active_size = GetSize(active_tactic, active_live_size,
-                                 active_dead_size);
-  uint64_t inactive_size = GetSize(inactive_tactic, inactive_live_size,
-                                   inactive_dead_size);
+  uint64_t active_size = GetSize(active_tactic, active_used_size);
+  uint64_t inactive_size = GetSize(inactive_tactic, inactive_used_size);
 
   // Give up if we don't have enough space to use this tactic.
   if (global_size_limit_ < active_size + inactive_size)
     return false;
 
   // Compute the unreserved space available.
   uint64_t total_extra = global_size_limit_ - (active_size + inactive_size);
 
   // The plan for the extra space is to divide it evenly amoung the active
   // renderers.
@@ skipping 32 matching lines @@
   // Divide the extra memory evenly among the renderers.
   uint64_t extra_each = extra_bytes_to_allocate / renderers.size();
 
   std::set<int>::const_iterator iter = renderers.begin();
   while (iter != renderers.end()) {
     uint64_t cache_size = extra_each;
 
     // Add in the space required to implement |tactic|.
     StatsMap::iterator elmt = stats_.find(*iter);
     if (elmt != stats_.end()) {
-      cache_size += GetSize(tactic, elmt->second.live_size,
-                            elmt->second.dead_size);
+      cache_size += GetSize(tactic, elmt->second.size);
     }
 
     // Record the allocation in our strategy.
     strategy->push_back(Allocation(*iter, cache_size));
     ++iter;
   }
 }
 
 void WebCacheManager::EnactStrategy(const AllocationStrategy& strategy) {
   // Inform each render process of its cache allocation.
   AllocationStrategy::const_iterator allocation = strategy.begin();
   while (allocation != strategy.end()) {
     content::RenderProcessHost* host =
         content::RenderProcessHost::FromID(allocation->first);
     if (host) {
       // This is the capacity this renderer has been allocated.
       uint64_t capacity = allocation->second;
 
-      // We don't reserve any space for dead objects in the cache. Instead, we
-      // prefer to keep live objects around. There is probably some performance
-      // tuning to be done here.
-      uint64_t min_dead_capacity = 0;
-
-      // We allow the dead objects to consume up to half of the cache capacity.
-      uint64_t max_dead_capacity = capacity / 2;
-      if (base::SysInfo::IsLowEndDevice()) {
-        max_dead_capacity = std::min(static_cast<uint64_t>(512 * 1024u),
-                                     max_dead_capacity);
-      }
-
       // Find the WebCachePtr by renderer process id.
       auto it = web_cache_services_.find(allocation->first);
       DCHECK(it != web_cache_services_.end());
       const mojom::WebCachePtr& service = it->second;
       DCHECK(service);
-      service->SetCacheCapacities(min_dead_capacity, max_dead_capacity,
-                                  capacity);
+      service->SetCacheCapacity(capacity);
     }
     ++allocation;
   }
 }
 
 void WebCacheManager::ClearCacheForProcess(int render_process_id) {
   std::set<int> renderers;
   renderers.insert(render_process_id);
   ClearRendererCache(renderers, INSTANTLY);
 }
@@ skipping 17 matching lines @@
 }
 
 void WebCacheManager::ReviseAllocationStrategy() {
   DCHECK(stats_.size() <=
       active_renderers_.size() + inactive_renderers_.size());
 
   // Check if renderers have gone inactive.
   FindInactiveRenderers();
 
   // Gather statistics
-  uint64_t active_capacity, active_live_size, active_dead_size,
-           inactive_capacity, inactive_live_size, inactive_dead_size;
-  GatherStats(active_renderers_, &active_capacity, &active_live_size,
-              &active_dead_size);
-  GatherStats(inactive_renderers_, &inactive_capacity, &inactive_live_size,
-              &inactive_dead_size);
+  uint64_t active_capacity, active_size, inactive_capacity, inactive_size;
+  GatherStats(active_renderers_, &active_capacity, &active_size);
+  GatherStats(inactive_renderers_, &inactive_capacity, &inactive_size);
 
   UMA_HISTOGRAM_COUNTS_100("Cache.ActiveTabs", active_renderers_.size());
   UMA_HISTOGRAM_COUNTS_100("Cache.InactiveTabs", inactive_renderers_.size());
   UMA_HISTOGRAM_MEMORY_MB("Cache.ActiveCapacityMB",
                           active_capacity / 1024 / 1024);
-  UMA_HISTOGRAM_MEMORY_MB("Cache.ActiveDeadSizeMB",
-                          active_dead_size / 1024 / 1024);
-  UMA_HISTOGRAM_MEMORY_MB("Cache.ActiveLiveSizeMB",
-                          active_live_size / 1024 / 1024);
+  UMA_HISTOGRAM_MEMORY_MB("Cache.ActiveLiveSizeMB", active_size / 1024 / 1024);
   UMA_HISTOGRAM_MEMORY_MB("Cache.InactiveCapacityMB",
                           inactive_capacity / 1024 / 1024);
-  UMA_HISTOGRAM_MEMORY_MB("Cache.InactiveDeadSizeMB",
-                          inactive_dead_size / 1024 / 1024);
   UMA_HISTOGRAM_MEMORY_MB("Cache.InactiveLiveSizeMB",
-                          inactive_live_size / 1024 / 1024);
+                          inactive_size / 1024 / 1024);
 
   // Compute an allocation strategy.
   //
   // We attempt various tactics in order of preference.  Our first preference
   // is not to evict any objects.  If we don't have enough resources, we'll
   // first try to evict dead data only.  If that fails, we'll just divide the
   // resources we have evenly.
   //
   // We always try to give the active renderers some head room in their
   // allocations so they can take memory away from an inactive renderer with
   // a large cache allocation.
   //
   // Notice the early exit will prevent attempting less desirable tactics once
   // we've found a workable strategy.
   AllocationStrategy strategy;
   if (  // Ideally, we'd like to give the active renderers some headroom and
-        // keep all our current objects.
-      AttemptTactic(KEEP_CURRENT_WITH_HEADROOM, active_live_size,
-                    active_dead_size, KEEP_CURRENT, inactive_live_size,
-                    inactive_dead_size, &strategy) ||
-      // If we can't have that, then we first try to evict the dead objects in
-      // the caches of inactive renderers.
-      AttemptTactic(KEEP_CURRENT_WITH_HEADROOM, active_live_size,
-                    active_dead_size, KEEP_LIVE, inactive_live_size,
-                    inactive_dead_size, &strategy) ||
-      // Next, we try to keep the live objects in the active renders (with some
-      // room for new objects) and give whatever is left to the inactive
+      // keep all our current objects.
+      AttemptTactic(KEEP_CURRENT_WITH_HEADROOM, active_size, KEEP_CURRENT,
+                    inactive_size, &strategy) ||
+      // Next, we try to keep the current objects in the active renders (with
+      // some room for new objects) and give whatever is left to the inactive
       // renderers.
-      AttemptTactic(KEEP_LIVE_WITH_HEADROOM, active_live_size,
-                    active_dead_size, DIVIDE_EVENLY, inactive_live_size,
-                    inactive_dead_size, &strategy) ||
+      AttemptTactic(KEEP_CURRENT_WITH_HEADROOM, active_size, DIVIDE_EVENLY,
+                    inactive_size, &strategy) ||
       // If we've gotten this far, then we are very tight on memory.  Let's try
       // to at least keep around the live objects for the active renderers.
-      AttemptTactic(KEEP_LIVE, active_live_size, active_dead_size,
-                    DIVIDE_EVENLY, inactive_live_size, inactive_dead_size,
+      AttemptTactic(KEEP_CURRENT, active_size, DIVIDE_EVENLY, inactive_size,
                     &strategy) ||
       // We're basically out of memory.  The best we can do is just divide up
       // what we have and soldier on.
-      AttemptTactic(DIVIDE_EVENLY, active_live_size, active_dead_size,
-                    DIVIDE_EVENLY, inactive_live_size, inactive_dead_size,
+      AttemptTactic(DIVIDE_EVENLY, active_size, DIVIDE_EVENLY, inactive_size,
                     &strategy)) {
     // Having found a workable strategy, we enact it.
     EnactStrategy(strategy);
   } else {
     // DIVIDE_EVENLY / DIVIDE_EVENLY should always succeed.
     NOTREACHED() << "Unable to find a cache allocation";
   }
 }
 
 void WebCacheManager::ReviseAllocationStrategyLater() {
@@ skipping 16 matching lines @@
       inactive_renderers_.insert(*iter);
       active_renderers_.erase(*iter);
       iter = active_renderers_.begin();
       continue;
     }
     ++iter;
   }
 }
 
 }  // namespace web_cache