Disk Cache: Improve handling of dirty entries.

net/disk_cache/rankings.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.
 
 #include "net/disk_cache/rankings.h"
 
 #include "base/metrics/histogram.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/errors.h"
@@ skipping 282 matching lines @@
 //    1. r(r, b), b(r, y), head(r), tail(y)           initial state
 //    2. r(r, b), b(r, y), head(b), tail(y)           WriteHead()
 //    3. r(r, b), b(b, y), head(b), tail(y)           next.Store()
 //    4. r(0, 0), b(b, y), head(b), tail(y)           prev.Store()
 //
 // D. Remove tail:
 //    1. a(x, r), r(a, r), head(x), tail(r)           initial state
 //    2. a(x, r), r(a, r), head(x), tail(a)           WriteTail()
 //    3. a(x, a), r(a, r), head(x), tail(a)           prev.Store()
 //    4. a(x, a), r(0, 0), head(x), tail(a)           next.Store()
-void Rankings::Remove(CacheRankingsBlock* node, List list) {
+void Rankings::Remove(CacheRankingsBlock* node, List list, bool strict) {
   Trace("Remove 0x%x (0x%x 0x%x) l %d", node->address().value(),
         node->Data()->next, node->Data()->prev, list);
   DCHECK(node->HasData());
-  InvalidateIterators(node);
+  if (strict)
+    InvalidateIterators(node);
+
   Addr next_addr(node->Data()->next);
   Addr prev_addr(node->Data()->prev);
   if (!next_addr.is_initialized() || next_addr.is_separate_file() ||
       !prev_addr.is_initialized() || prev_addr.is_separate_file()) {
     if (next_addr.is_initialized() || prev_addr.is_initialized()) {
       LOG(ERROR) << "Invalid rankings info.";
     }
     return;
   }
 
@@ skipping 63 matching lines @@
 // entry. Otherwise we'll need reentrant transactions, which is an overkill.
 void Rankings::UpdateRank(CacheRankingsBlock* node, bool modified, List list) {
   Addr& my_head = heads_[list];
   if (my_head.value() == node->address().value()) {
     UpdateTimes(node, modified);
     node->set_modified();
     return;
   }
 
   TimeTicks start = TimeTicks::Now();
-  Remove(node, list);
+  Remove(node, list, true);
   Insert(node, modified, list);
   CACHE_UMA(AGE_MS, "UpdateRank", 0, start);
 }
 
 CacheRankingsBlock* Rankings::GetNext(CacheRankingsBlock* node, List list) {
   ScopedRankingsBlock next(this);
   if (!node) {
     Addr& my_head = heads_[list];
     if (!my_head.is_initialized())
       return NULL;
@@ skipping 78 matching lines @@
   int total = 0;
   for (int i = 0; i < LAST_ELEMENT; i++) {
     int partial = CheckList(static_cast<List>(i));
     if (partial < 0)
       return partial;
     total += partial;
   }
   return total;
 }
 
-bool Rankings::SanityCheck(CacheRankingsBlock* node, bool from_list) {
+bool Rankings::SanityCheck(CacheRankingsBlock* node, bool from_list) const {
   const RankingsNode* data = node->Data();
-  if (!data->contents)
-    return false;
-
-  // It may have never been inserted.
-  if (from_list && (!data->last_used || !data->last_modified))
-    return false;
 
   if ((!data->next && data->prev) || (data->next && !data->prev))
     return false;
 
   // Both pointers on zero is a node out of the list.
   if (!data->next && !data->prev && from_list)
     return false;
 
   List list = NO_USE;  // Initialize it to something.
   if ((node->address().value() == data->prev) && !IsHead(data->prev, &list))
     return false;
 
   if ((node->address().value() == data->next) && !IsTail(data->next, &list))
     return false;
 
   if (!data->next && !data->prev)
     return true;
 
   Addr next_addr(data->next);
   Addr prev_addr(data->prev);
   if (!next_addr.SanityCheck() || next_addr.file_type() != RANKINGS ||
       !prev_addr.SanityCheck() || prev_addr.file_type() != RANKINGS)
     return false;
 
   return true;
 }
 
+bool Rankings::DataSanityCheck(CacheRankingsBlock* node, bool from_list) const {
+  const RankingsNode* data = node->Data();
+  if (!data->contents)
+    return false;
+
+  // It may have never been inserted.
+  if (from_list && (!data->last_used || !data->last_modified))
+    return false;
+
+  return true;
+}
+
+void Rankings::SetContents(CacheRankingsBlock* node, CacheAddr address) {
+  node->Data()->contents = address;
+  node->Store();
+}
+
 void Rankings::ReadHeads() {
   for (int i = 0; i < LAST_ELEMENT; i++)
     heads_[i] = Addr(control_data_->heads[i]);
 }
 
 void Rankings::ReadTails() {
   for (int i = 0; i < LAST_ELEMENT; i++)
     tails_[i] = Addr(control_data_->tails[i]);
 }
 
@@ skipping 261 matching lines @@
     prev.set_value(address.value());
     address.set_value(node->Data()->next);
     if (!address.is_initialized() || address.is_separate_file())
       return ERR_INVALID_NEXT;
 
     num_items++;
   } while (node->address().value() != address.value());
   return num_items;
 }
 
-bool Rankings::IsHead(CacheAddr addr, List* list) {
+bool Rankings::IsHead(CacheAddr addr, List* list) const {

[gavinp, 2011/09/29 13:25:34]

Good catch.

   for (int i = 0; i < LAST_ELEMENT; i++) {
     if (addr == heads_[i].value()) {
       if (*list != i)
         Trace("Changing list %d to %d", *list, i);
       *list = static_cast<List>(i);
       return true;
     }
   }
   return false;
 }
 
-bool Rankings::IsTail(CacheAddr addr, List* list) {
+bool Rankings::IsTail(CacheAddr addr, List* list) const {
   for (int i = 0; i < LAST_ELEMENT; i++) {
     if (addr == tails_[i].value()) {
       if (*list != i)
         Trace("Changing list %d to %d", *list, i);
       *list = static_cast<List>(i);
       return true;
     }
   }
   return false;
 }
@@ skipping 35 matching lines @@
 void Rankings::DecrementCounter(List list) {
   if (!count_lists_)
     return;
 
   DCHECK(control_data_->sizes[list] > 0);
   if (control_data_->sizes[list] > 0)
     control_data_->sizes[list]--;
 }
 
 }  // namespace disk_cache