Disk cache: Add base files for implementation of file format version 3.

net/disk_cache/v3/eviction_v3.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.
 
 // 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 143 matching lines @@
   } else {
     CACHE_UMA(AGE_MS, "TotalTrimTimeV1", 0, start);
   }
   CACHE_UMA(COUNTS, "TrimItemsV1", 0, deleted_entries);
 
   trimming_ = false;
   Trace("*** Trim Cache end ***");
   return;
 }
 
-void Eviction::UpdateRank(EntryImpl* entry, bool modified) {
-  if (new_eviction_)
-    return UpdateRankV2(entry, modified);
+void Eviction::OnOpenEntryV2(EntryImpl* entry) {
+  EntryStore* info = entry->entry()->Data();
+  DCHECK_EQ(ENTRY_NORMAL, info->state);
 
-  rankings_->UpdateRank(entry->rankings(), modified, GetListForEntry(entry));
+  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, 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, true);
+      rankings_->Insert(entry->rankings(), false, Rankings::HIGH_USE);
+      entry->entry()->Store();
+    }
+  }
 }
 
-void Eviction::OnOpenEntry(EntryImpl* entry) {
-  if (new_eviction_)
-    return OnOpenEntryV2(entry);
-}
+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++;
 
-void Eviction::OnCreateEntry(EntryImpl* entry) {
-  if (new_eviction_)
-    return OnCreateEntryV2(entry);
+      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, true);
+      break;
+    };
+    default:
+      NOTREACHED();
+  }
 
-  rankings_->Insert(entry->rankings(), true, GetListForEntry(entry));
-}
-
-void Eviction::OnDoomEntry(EntryImpl* entry) {
-  if (new_eviction_)
-    return OnDoomEntryV2(entry);
-
-  if (entry->LeaveRankingsBehind())
-    return;
-
-  rankings_->Remove(entry->rankings(), GetListForEntry(entry), true);
-}
-
-void Eviction::OnDestroyEntry(EntryImpl* entry) {
-  if (new_eviction_)
-    return OnDestroyEntryV2(entry);
+  rankings_->Insert(entry->rankings(), true, GetListForEntryV2(entry));
 }
 
 void Eviction::SetTestMode() {
   test_mode_ = true;
 }
 
 void Eviction::TrimDeletedList(bool empty) {
   DCHECK(test_mode_ && new_eviction_);
   TrimDeleted(empty);
 }
 
+// -----------------------------------------------------------------------
+
 void Eviction::PostDelayedTrim() {
   // Prevent posting multiple tasks.
   if (delay_trim_)
     return;
   delay_trim_ = true;
   trim_delays_++;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&Eviction::DelayedTrim, ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(1000));
@@ skipping 22 matching lines @@
   int index_load = header_->num_entries * 100 / index_size_;
 
   // If the index is not loaded, the deleted list will tend to double the size
   // of the other lists 3 lists (40% of the total). Otherwise, all lists will be
   // about the same size.
   int max_length = (index_load < 25) ? 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;
-
-    header_->lru.filled = 1;
-
-    if (header_->create_time) {
-      // This is the first entry that we have to evict, generate some noise.
-      backend_->FirstEviction();
-    } else {
-      // This is an old file, but we may want more reports from this user so
-      // lets save some create_time.
-      Time::Exploded old = {0};
-      old.year = 2009;
-      old.month = 3;
-      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,
                           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), true);
     info->state = ENTRY_EVICTED;
     entry->entry()->Store();
     rankings_->Insert(entry->rankings(), true, Rankings::DELETED);
   }
   if (!empty)
     backend_->OnEvent(Stats::TRIM_ENTRY);
 
   entry->Release();
 
   return true;
 }
 
-// -----------------------------------------------------------------------
-
 void Eviction::TrimCacheV2(bool empty) {
   Trace("*** Trim Cache ***");
   trimming_ = true;
   TimeTicks start = TimeTicks::Now();
 
   const int kListsToSearch = 3;
   Rankings::ScopedRankingsBlock next[kListsToSearch];
   int list = Rankings::LAST_ELEMENT;
 
   // Get a node from each list.
@@ skipping 64 matching lines @@
   } else {
     CACHE_UMA(AGE_MS, "TotalTrimTimeV2", 0, start);
   }
   CACHE_UMA(COUNTS, "TrimItemsV2", 0, deleted_entries);
 
   Trace("*** Trim Cache end ***");
   trimming_ = false;
   return;
 }
 
-void Eviction::UpdateRankV2(EntryImpl* entry, bool modified) {
-  rankings_->UpdateRank(entry->rankings(), modified, GetListForEntryV2(entry));
-}
-
-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, 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, 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, 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;
-
-  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) {
-  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(
@@ skipping 15 matching lines @@
         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;
 }
 
-bool Eviction::RemoveDeletedNode(CacheRankingsBlock* node) {
-  EntryImpl* entry = backend_->GetEnumeratedEntry(node, Rankings::DELETED);
-  if (!entry) {
-    Trace("NewEntry failed on Trim 0x%x", node->address().value());
-    return 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;
+
+    header_->lru.filled = 1;
+
+    if (header_->create_time) {
+      // This is the first entry that we have to evict, generate some noise.
+      backend_->FirstEviction();
+    } else {
+      // This is an old file, but we may want more reports from this user so
+      // lets save some create_time.
+      Time::Exploded old = {0};
+      old.year = 2009;
+      old.month = 3;
+      old.day_of_month = 1;
+      header_->create_time = Time::FromLocalExploded(old).ToInternalValue();
+    }
   }
-
-  bool doomed = (entry->entry()->Data()->state == ENTRY_DOOMED);
-  entry->entry()->Data()->state = ENTRY_DOOMED;
-  entry->DoomImpl();
-  entry->Release();
-  return !doomed;
 }
 
 bool Eviction::NodeIsOldEnough(CacheRankingsBlock* node, int list) {
   if (!node)
     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);
@@ skipping 42 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