Disk Cache: Improve handling of dirty 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 98 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()) || test_mode_) {
+  while ((header_->num_bytes > target_size || test_mode_) && next.get()) {
     // 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_)
+      if (!EvictEntry(node.get(), empty, Rankings::NO_USE) && !test_mode_)
         continue;
 
       if (!empty) {
         backend_->OnEvent(Stats::TRIM_ENTRY);
         if (test_mode_)
           break;
 
         if ((TimeTicks::Now() - start).InMilliseconds() > 20) {
           MessageLoop::current()->PostTask(FROM_HERE,
               factory_.NewRunnableMethod(&Eviction::TrimCache, false));
@@ skipping 30 matching lines @@
   if (new_eviction_)
     return OnCreateEntryV2(entry);
 
   rankings_->Insert(entry->rankings(), true, GetListForEntry(entry));
 }
 
 void Eviction::OnDoomEntry(EntryImpl* entry) {
   if (new_eviction_)
     return OnDoomEntryV2(entry);
 
-  rankings_->Remove(entry->rankings(), GetListForEntry(entry));
+  if (entry->LeaveRankingsBehind())
+    return;
+
+  rankings_->Remove(entry->rankings(), GetListForEntry(entry), true);
 }
 
 void Eviction::OnDestroyEntry(EntryImpl* entry) {
   if (new_eviction_)
     return OnDestroyEntryV2(entry);
 }
 
 void Eviction::SetTestMode() {
   test_mode_ = true;
 }
@@ skipping 56 matching lines @@
       old.day_of_month = 1;
       header_->create_time = Time::FromLocalExploded(old).ToInternalValue();
     }
   }
 }
 
 Rankings::List Eviction::GetListForEntry(EntryImpl* entry) {
   return Rankings::NO_USE;
 }
 
-bool Eviction::EvictEntry(CacheRankingsBlock* node, bool empty) {
-  EntryImpl* entry = backend_->GetEnumeratedEntry(node);
+bool Eviction::EvictEntry(CacheRankingsBlock* node, bool empty,
+                          Rankings::List list) {
+  EntryImpl* entry = backend_->GetEnumeratedEntry(node, list);
   if (!entry) {
     Trace("NewEntry failed on Trim 0x%x", node->address().value());
     return false;
   }
 
   ReportTrimTimes(entry);
   if (empty || !new_eviction_) {
     entry->DoomImpl();
   } else {
     entry->DeleteEntryData(false);
     EntryStore* info = entry->entry()->Data();
     DCHECK_EQ(ENTRY_NORMAL, info->state);
 
-    rankings_->Remove(entry->rankings(), GetListForEntryV2(entry));
+    rankings_->Remove(entry->rankings(), GetListForEntryV2(entry), true);
     info->state = ENTRY_EVICTED;
     entry->entry()->Store();
     rankings_->Insert(entry->rankings(), true, Rankings::DELETED);
     backend_->OnEvent(Stats::TRIM_ENTRY);
   }
   entry->Release();
 
   return true;
 }
 
@@ skipping 25 matching lines @@
   if (!empty && Rankings::LAST_ELEMENT == list)
     list = SelectListByLength(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()) ||
-           test_mode_) {
+    while ((header_->num_bytes > target_size || test_mode_) &&
+           next[list].get()) {
       // 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);
-        if (!EvictEntry(node.get(), empty) && !test_mode_)
+        if (!EvictEntry(node.get(), empty, static_cast<Rankings::List>(list)) &&
+            !test_mode_)
           continue;
 
         if (!empty && test_mode_)
           break;
 
         if (!empty && (TimeTicks::Now() - start).InMilliseconds() > 20) {
           MessageLoop::current()->PostTask(FROM_HERE,
               factory_.NewRunnableMethod(&Eviction::TrimCache, false));
           break;
         }
@@ skipping 29 matching lines @@
 void Eviction::OnOpenEntryV2(EntryImpl* entry) {
   EntryStore* info = entry->entry()->Data();
   DCHECK_EQ(ENTRY_NORMAL, info->state);
 
   if (info->reuse_count < kint32max) {
     info->reuse_count++;
     entry->entry()->set_modified();
 
     // We may need to move this to a new list.
     if (1 == info->reuse_count) {
-      rankings_->Remove(entry->rankings(), Rankings::NO_USE);
+      rankings_->Remove(entry->rankings(), Rankings::NO_USE, true);
       rankings_->Insert(entry->rankings(), false, Rankings::LOW_USE);
       entry->entry()->Store();
     } else if (kHighUse == info->reuse_count) {
-      rankings_->Remove(entry->rankings(), Rankings::LOW_USE);
+      rankings_->Remove(entry->rankings(), Rankings::LOW_USE, true);
       rankings_->Insert(entry->rankings(), false, Rankings::HIGH_USE);
       entry->entry()->Store();
     }
   }
 }
 
 void Eviction::OnCreateEntryV2(EntryImpl* entry) {
   EntryStore* info = entry->entry()->Data();
   switch (info->state) {
     case ENTRY_NORMAL: {
       DCHECK(!info->reuse_count);
       DCHECK(!info->refetch_count);
       break;
     };
     case ENTRY_EVICTED: {
       if (info->refetch_count < kint32max)
         info->refetch_count++;
 
       if (info->refetch_count > kHighUse && info->reuse_count < kHighUse) {
         info->reuse_count = kHighUse;
       } else {
         info->reuse_count++;
       }
       info->state = ENTRY_NORMAL;
       entry->entry()->Store();
-      rankings_->Remove(entry->rankings(), Rankings::DELETED);
+      rankings_->Remove(entry->rankings(), Rankings::DELETED, true);
       break;
     };
     default:
       NOTREACHED();
   }
 
   rankings_->Insert(entry->rankings(), true, GetListForEntryV2(entry));
 }
 
 void Eviction::OnDoomEntryV2(EntryImpl* entry) {
   EntryStore* info = entry->entry()->Data();
   if (ENTRY_NORMAL != info->state)
     return;
 
-  rankings_->Remove(entry->rankings(), GetListForEntryV2(entry));
+  if (entry->LeaveRankingsBehind()) {
+    info->state = ENTRY_DOOMED;
+    entry->entry()->Store();
+    return;
+  }
+
+  rankings_->Remove(entry->rankings(), GetListForEntryV2(entry), true);
 
   info->state = ENTRY_DOOMED;
   entry->entry()->Store();
   rankings_->Insert(entry->rankings(), true, Rankings::DELETED);
 }
 
 void Eviction::OnDestroyEntryV2(EntryImpl* entry) {
-  rankings_->Remove(entry->rankings(), Rankings::DELETED);
+  if (entry->LeaveRankingsBehind())
+    return;
+
+  rankings_->Remove(entry->rankings(), Rankings::DELETED, true);
 }
 
 Rankings::List Eviction::GetListForEntryV2(EntryImpl* entry) {
   EntryStore* info = entry->entry()->Data();
   DCHECK_EQ(ENTRY_NORMAL, info->state);
 
   if (!info->reuse_count)
     return Rankings::NO_USE;
 
   if (info->reuse_count < kHighUse)
     return Rankings::LOW_USE;
 
   return Rankings::HIGH_USE;
 }
 
 // This is a minimal implementation that just discards the oldest nodes.
 // TODO(rvargas): Do something better here.
 void Eviction::TrimDeleted(bool empty) {
   Trace("*** Trim Deleted ***");
   if (backend_->disabled_)
     return;
 
   TimeTicks start = TimeTicks::Now();
   Rankings::ScopedRankingsBlock node(rankings_);
   Rankings::ScopedRankingsBlock next(rankings_,
     rankings_->GetPrev(node.get(), Rankings::DELETED));
   bool deleted = false;
-  for (int i = 0; (i < 4 || empty) && next.get(); i++) {
+  while (next.get() &&
+         (empty || (TimeTicks::Now() - start).InMilliseconds() < 20)) {
     node.reset(next.release());
     next.reset(rankings_->GetPrev(node.get(), Rankings::DELETED));
     deleted |= RemoveDeletedNode(node.get());
     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 && !empty && !test_mode_ &&
       header_->lru.sizes[Rankings::DELETED] > max_length) {
     MessageLoop::current()->PostTask(FROM_HERE,
         factory_.NewRunnableMethod(&Eviction::TrimDeleted, false));
   }
 
   CACHE_UMA(AGE_MS, "TotalTrimDeletedTime", 0, start);
   Trace("*** Trim Deleted end ***");
   return;
 }
 
 bool Eviction::RemoveDeletedNode(CacheRankingsBlock* node) {
-  EntryImpl* entry = backend_->GetEnumeratedEntry(node);
+  EntryImpl* entry = backend_->GetEnumeratedEntry(node, Rankings::DELETED);
   if (!entry) {
     Trace("NewEntry failed on Trim 0x%x", node->address().value());
     return false;
   }
 
   bool doomed = (entry->entry()->Data()->state == ENTRY_DOOMED);
   entry->entry()->Data()->state = ENTRY_DOOMED;
   entry->DoomImpl();
   entry->Release();
   return !doomed;
@@ skipping 52 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