Disk cache: Don't evict entries if we are busy doing other stuff....

net/disk_cache/eviction.cc

 // Copyright (c) 2006-2008 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 ads re-use as a factor to evict
@@ skipping 48 matching lines @@
 void Eviction::Init(BackendImpl* backend) {
   // We grab a bunch of info from the backend to make the code a little cleaner
   // when we're actually doing work.
   backend_ = backend;
   rankings_ = &backend->rankings_;
   header_ = &backend_->data_->header;
   max_size_ = LowWaterAdjust(backend_->max_size_);
   new_eviction_ = backend->new_eviction_;
   first_trim_ = true;
   trimming_ = false;
+  delay_trim_ = false;
 }
 
 void Eviction::TrimCache(bool empty) {
   if (new_eviction_)
     return TrimCacheV2(empty);
 
   Trace("*** Trim Cache ***");
   if (backend_->disabled_ || trimming_)
     return;
 
+  if (!empty && backend_->IsLoaded())
+    return PostDelayedTrim();
+
   trimming_ = true;
   Time start = Time::Now();
   Rankings::ScopedRankingsBlock node(rankings_);
   Rankings::ScopedRankingsBlock next(rankings_,
       rankings_->GetPrev(node.get(), Rankings::NO_USE));
   DCHECK(next.get());
   int target_size = empty ? 0 : max_size_;
-  int deleted = 0;
   while (header_->num_bytes > target_size && next.get()) {
     node.reset(next.release());
     next.reset(rankings_->GetPrev(node.get(), Rankings::NO_USE));
     if (!node->Data()->pointer || empty) {
       // This entry is not being used by anybody.
       if (!EvictEntry(node.get(), empty))
         continue;
 
-      if (!empty)
+      if (!empty) {
         backend_->OnEvent(Stats::TRIM_ENTRY);
-      if (++deleted == 4 && !empty) {
-#if defined(OS_WIN)
-        MessageLoop::current()->PostTask(FROM_HERE,
-            factory_.NewRunnableMethod(&Eviction::TrimCache, false));
-        break;
-#endif
+
+        if ((Time::Now() - start).InMilliseconds() > 20) {
+          MessageLoop::current()->PostTask(FROM_HERE,
+              factory_.NewRunnableMethod(&Eviction::TrimCache, false));
+          break;
+        }
       }
     }
   }
 
   CACHE_UMA(AGE_MS, "TotalTrimTime", backend_->GetSizeGroup(), start);
   trimming_ = false;
   Trace("*** Trim Cache end ***");
   return;
 }
 
@@ skipping 21 matching lines @@
     return OnDoomEntryV2(entry);
 
   rankings_->Remove(entry->rankings(), GetListForEntry(entry));
 }
 
 void Eviction::OnDestroyEntry(EntryImpl* entry) {
   if (new_eviction_)
     return OnDestroyEntryV2(entry);
 }
 
+void Eviction::PostDelayedTrim() {
+  // Prevent posting multiple tasks.
+  if (delay_trim_)
+    return;
+  delay_trim_ = true;
+  MessageLoop::current()->PostDelayedTask(FROM_HERE,
+      factory_.NewRunnableMethod(&Eviction::DelayedTrim), 1000);
+}
+
+void Eviction::DelayedTrim() {
+  delay_trim_ = false;
+  TrimCache(false);
+}
+
 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 50 matching lines @@
   return true;
 }
 
 // -----------------------------------------------------------------------
 
 void Eviction::TrimCacheV2(bool empty) {
   Trace("*** Trim Cache ***");
   if (backend_->disabled_ || trimming_)
     return;
 
+  if (!empty && backend_->IsLoaded())
+    return PostDelayedTrim();
+
   trimming_ = true;
   Time start = Time::Now();
 
   const int kListsToSearch = 3;
   Rankings::ScopedRankingsBlock next[kListsToSearch];
   int list = Rankings::LAST_ELEMENT;
 
   // Get a node from each list.
   for (int i = 0; i < kListsToSearch; i++) {
     bool done = false;
@@ skipping 17 matching lines @@
         !NodeIsOldEnough(next[list].get(), 0))
       list = 0;
   }
 
   if (empty)
     list = 0;
 
   Rankings::ScopedRankingsBlock node(rankings_);
 
   int target_size = empty ? 0 : max_size_;
-  int deleted = 0;
   for (; list < kListsToSearch; list++) {
     while (header_->num_bytes > target_size && next[list].get()) {
       node.reset(next[list].release());
       next[list].reset(rankings_->GetPrev(node.get(),
                                           static_cast<Rankings::List>(list)));
       if (!node->Data()->pointer || empty) {
         // This entry is not being used by anybody.
         if (!EvictEntry(node.get(), empty))
           continue;
 
-        if (++deleted == 4 && !empty) {
+        if (!empty && (Time::Now() - start).InMilliseconds() > 20) {
           MessageLoop::current()->PostTask(FROM_HERE,
               factory_.NewRunnableMethod(&Eviction::TrimCache, false));
           break;
         }
       }
     }
     if (!empty)
       list = kListsToSearch;
   }
 
@@ skipping 181 matching lines @@
               Time::FromInternalValue(last2.get()->Data()->last_used));
   if (last3.get())
     CACHE_UMA(AGE, "HighUseAge", header_->experiment,
               Time::FromInternalValue(last3.get()->Data()->last_used));
   if (last4.get())
     CACHE_UMA(AGE, "DeletedAge", header_->experiment,
               Time::FromInternalValue(last4.get()->Data()->last_used));
 }
 
 }  // namespace disk_cache