Disk Cache: Avoid discarding more deleted entries

net/disk_cache/eviction.cc

 // 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
@@ skipping 206 matching lines @@
 
 bool Eviction::ShouldTrim() {
   if (trim_delays_ < kMaxDelayedTrims && backend_->IsLoaded())
     return false;
 
   UMA_HISTOGRAM_COUNTS("DiskCache.TrimDelays", trim_delays_);
   trim_delays_ = 0;
   return true;
 }
 
+bool Eviction::ShouldTrimDeleted() {
+  // Normally we use 25% for each list. The experiment doubles the number of
+  // deleted entries, so the total number of entries increases by 25%. Using
+  // 40% of that value for deleted entries leaves the size of the other three
+  // lists intact.
+  int max_length = in_experiment_ ? header_->num_entries * 2 / 5 :
+                                    header_->num_entries / 4;
+  return (!test_mode_ && header_->lru.sizes[Rankings::DELETED] > max_length);
+}
+
 void Eviction::ReportTrimTimes(EntryImpl* entry) {
   if (first_trim_) {
     first_trim_ = false;
     if (backend_->ShouldReportAgain()) {
       CACHE_UMA(AGE, "TrimAge", 0, entry->GetLastUsed());
       ReportListStats();
     }
 
     if (header_->lru.filled)
       return;
@@ skipping 109 matching lines @@
             &Eviction::TrimCache, ptr_factory_.GetWeakPtr(), false));
         break;
       }
     }
     if (!empty)
       list = kListsToSearch;
   }
 
   if (empty) {
     TrimDeleted(true);
-  } else if (header_->lru.sizes[Rankings::DELETED] > header_->num_entries / 4 &&
-             !test_mode_) {
+  } else if (ShouldTrimDeleted()) {

[gavinp, 2011/11/15 16:17:56]

Good catch.

     MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&Eviction::TrimDeleted, ptr_factory_.GetWeakPtr(), empty));
   }
 
   if (empty) {
     CACHE_UMA(AGE_MS, "TotalClearTimeV2", 0, start);
   } else {
     CACHE_UMA(AGE_MS, "TotalTrimTimeV2", 0, start);
   }
   CACHE_UMA(COUNTS, "TrimItemsV2", 0, deleted_entries);
@@ skipping 111 matching lines @@
          (empty || (deleted_entries < 20 &&
                     (TimeTicks::Now() - start).InMilliseconds() < 20))) {
     node.reset(next.release());
     next.reset(rankings_->GetPrev(node.get(), Rankings::DELETED));
     if (RemoveDeletedNode(node.get()))
       deleted_entries++;
     if (test_mode_)
       break;
   }
 
-  // Normally we use 25% for each list. The experiment doubles the number of
-  // deleted entries, so the total number of entries increases by 25%. Using
-  // 40% of that value for deleted entries leaves the size of the other three
-  // lists intact.
-  int max_length = in_experiment_ ? header_->num_entries * 2 / 5 :
-                                    header_->num_entries / 4;
-  if (deleted_entries && !empty && !test_mode_ &&
-      header_->lru.sizes[Rankings::DELETED] > max_length) {
+  if (deleted_entries && !empty && ShouldTrimDeleted()) {
     MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&Eviction::TrimDeleted, ptr_factory_.GetWeakPtr(), false));
   }
 
   CACHE_UMA(AGE_MS, "TotalTrimDeletedTime", 0, start);
   CACHE_UMA(COUNTS, "TrimDeletedItems", 0, deleted_entries);
   Trace("*** Trim Deleted end ***");
   return;
 }
 
@@ skipping 64 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