Disk cache: Make sure the list of unused entries is not

net/disk_cache/eviction.cc

-// Copyright (c) 2006-2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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.
 
 // The eviction policy is a very simple pure LRU, so the elements at the end of
 // the list are evicted until kCleanUpMargin free space is available. There is
 // only one list in use (Rankings::NO_USE), and elements are sent to the front
 // of the list whenever they are accessed.
 
 // The new (in-development) eviction policy adds re-use as a factor to evict
 // an entry. The story so far:
@@ skipping 97 matching lines @@
   if (new_eviction_)
     return TrimCacheV2(empty);
 
   Trace("*** Trim Cache ***");
   trimming_ = true;
   TimeTicks start = TimeTicks::Now();
   Rankings::ScopedRankingsBlock node(rankings_);
   Rankings::ScopedRankingsBlock next(rankings_,
       rankings_->GetPrev(node.get(), Rankings::NO_USE));
   int target_size = empty ? 0 : max_size_;
-  while (header_->num_bytes > target_size && next.get()) {
+  while ((header_->num_bytes > target_size && next.get()) || test_mode_) {
     // The iterator could be invalidated within EvictEntry().
     if (!next->HasData())
       break;
     node.reset(next.release());
     next.reset(rankings_->GetPrev(node.get(), Rankings::NO_USE));
     if (node->Data()->dirty != backend_->GetCurrentEntryId() || empty) {
       // This entry is not being used by anybody.
       // Do NOT use node as an iterator after this point.
       rankings_->TrackRankingsBlock(node.get(), false);
       if (!EvictEntry(node.get(), empty) && !test_mode_)
@@ skipping 167 matching lines @@
     if (done)
       continue;
     next[i].reset(rankings_->GetPrev(NULL, static_cast<Rankings::List>(i)));
     if (!empty && NodeIsOldEnough(next[i].get(), i)) {
       list = static_cast<Rankings::List>(i);
       done = true;
     }
   }
 
   // If we are not meeting the time targets lets move on to list length.
-  if (!empty && Rankings::LAST_ELEMENT == list) {
-    list = SelectListByLenght();
-    // Make sure that frequently used items are kept for a minimum time; we know
-    // that this entry is not older than its current target, but it must be at
-    // least older than the target for list 0 (kTargetTime).
-    if ((Rankings::HIGH_USE == list || Rankings::LOW_USE == list) &&
-        !NodeIsOldEnough(next[list].get(), 0))
-      list = 0;
-  }
+  if (!empty && Rankings::LAST_ELEMENT == list)
+    list = SelectListByLenght(next);
 
   if (empty)
     list = 0;
 
   Rankings::ScopedRankingsBlock node(rankings_);
 
   int target_size = empty ? 0 : max_size_;
   for (; list < kListsToSearch; list++) {
-    while (header_->num_bytes > target_size && next[list].get()) {
+    while ((header_->num_bytes > target_size && next[list].get()) ||
+           test_mode_) {
       // The iterator could be invalidated within EvictEntry().
       if (!next[list]->HasData())
         break;
       node.reset(next[list].release());
       next[list].reset(rankings_->GetPrev(node.get(),
                                           static_cast<Rankings::List>(list)));
       if (node->Data()->dirty != backend_->GetCurrentEntryId() || empty) {
         // This entry is not being used by anybody.
         // Do NOT use node as an iterator after this point.
         rankings_->TrackRankingsBlock(node.get(), false);
@@ skipping 172 matching lines @@
     return false;
 
   // If possible, we want to keep entries on each list at least kTargetTime
   // hours. Each successive list on the enumeration has 2x the target time of
   // the previous list.
   Time used = Time::FromInternalValue(node->Data()->last_used);
   int multiplier = 1 << list;
   return (Time::Now() - used).InHours() > kTargetTime * multiplier;
 }
 
-int Eviction::SelectListByLenght() {
+int Eviction::SelectListByLenght(Rankings::ScopedRankingsBlock* next) {
   int data_entries = header_->num_entries -
                      header_->lru.sizes[Rankings::DELETED];
   // Start by having each list to be roughly the same size.
   if (header_->lru.sizes[0] > data_entries / 3)
     return 0;
-  if (header_->lru.sizes[1] > data_entries / 3)
-    return 1;
-  return 2;
+
+  int list = (header_->lru.sizes[1] > data_entries / 3) ? 1 : 2;
+
+  // Make sure that frequently used items are kept for a minimum time; we know
+  // that this entry is not older than its current target, but it must be at
+  // least older than the target for list 0 (kTargetTime), as long as we don't
+  // exhaust list 0.
+  if (!NodeIsOldEnough(next[list].get(), 0) &&
+      header_->lru.sizes[0] > data_entries / 10)
+    list = 0;
+
+  return list;
 }
 
 void Eviction::ReportListStats() {
   if (!new_eviction_)
     return;
 
   Rankings::ScopedRankingsBlock last1(rankings_,
       rankings_->GetPrev(NULL, Rankings::NO_USE));
   Rankings::ScopedRankingsBlock last2(rankings_,
       rankings_->GetPrev(NULL, Rankings::LOW_USE));
@@ skipping 10 matching lines @@
               Time::FromInternalValue(last2.get()->Data()->last_used));
   if (last3.get())
     CACHE_UMA(AGE, "HighUseAge", 0,
               Time::FromInternalValue(last3.get()->Data()->last_used));
   if (last4.get())
     CACHE_UMA(AGE, "DeletedAge", 0,
               Time::FromInternalValue(last4.get()->Data()->last_used));
 }
 
 }  // namespace disk_cache