Disk cache: Add support for an extra data stream for each cache entry....

net/disk_cache/rankings.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.
 
 #include "net/disk_cache/rankings.h"
 
 #include "base/histogram.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/errors.h"
 
 using base::Time;
 
 // This is used by crash_cache.exe to generate unit test files.
 disk_cache::RankCrashes g_rankings_crash = disk_cache::NO_CRASH;
 
 namespace {
 
-const int kHeadIndex = 0;
-const int kTailIndex = 1;
-const int kTransactionIndex = 2;
-const int kOperationIndex = 3;
+enum Lists {
+  NO_USE = 0,   // List of entries that have not been reused.
+  LOW_USE,      // List of entries with low reuse.
+  HIGH_USE,     // List of entries with high reuse.
+  DELETED,      // List of recently deleted or doomed entries.
+  LAST_ELEMENT
+};
 
 enum Operation {
   INSERT = 1,
   REMOVE
 };
 
 // This class provides a simple lock for the LRU list of rankings. Whenever an
 // entry is to be inserted or removed from the list, a transaction object should
 // be created to keep track of the operation. If the process crashes before
 // finishing the operation, the transaction record (stored as part of the user
 // data on the file header) can be used to finish the operation.
 class Transaction {
  public:
   // addr is the cache addres of the node being inserted or removed. We want to
   // avoid having the compiler doing optimizations on when to read or write
   // from user_data because it is the basis of the crash detection. Maybe
   // volatile is not enough for that, but it should be a good hint.
-  Transaction(volatile int32* user_data, disk_cache::Addr addr, Operation op);
+  Transaction(volatile disk_cache::LruData* data, disk_cache::Addr addr,
+              Operation op, int list);
   ~Transaction();
  private:
-  volatile int32* user_data_;
-  DISALLOW_EVIL_CONSTRUCTORS(Transaction);
+  volatile disk_cache::LruData* data_;
+  DISALLOW_COPY_AND_ASSIGN(Transaction);
 };
 
-Transaction::Transaction(volatile int32* user_data, disk_cache::Addr addr,
-                         Operation op) : user_data_(user_data) {
-  DCHECK(!user_data_[kTransactionIndex]);
+Transaction::Transaction(volatile disk_cache::LruData* data,
+                         disk_cache::Addr addr, Operation op, int list)
+    : data_(data) {
+  DCHECK(!data_->transaction);
   DCHECK(addr.is_initialized());
-  user_data_[kOperationIndex] = op;
-  user_data_[kTransactionIndex] = static_cast<int32>(addr.value());
+  data_->operation = op;
+  data_->operation_list = list;
+  data_->transaction = addr.value();
 }
 
 Transaction::~Transaction() {
-  DCHECK(user_data_[kTransactionIndex]);
-  user_data_[kTransactionIndex] = 0;
-  user_data_[kOperationIndex] = 0;
+  DCHECK(data_->transaction);
+  data_->transaction = 0;
+  data_->operation = 0;
+  data_->operation_list = 0;
 }
 
 // Code locations that can generate crashes.
 enum CrashLocation {
   ON_INSERT_1, ON_INSERT_2, ON_INSERT_3, ON_INSERT_4, ON_REMOVE_1, ON_REMOVE_2,
   ON_REMOVE_3, ON_REMOVE_4, ON_REMOVE_5, ON_REMOVE_6, ON_REMOVE_7, ON_REMOVE_8
 };
 
 // Generates a crash on debug builds, acording to the value of g_rankings_crash.
 // This used by crash_cache.exe to generate unit-test files.
@@ skipping 84 matching lines @@
 }  // namespace
 
 namespace disk_cache {
 
 bool Rankings::Init(BackendImpl* backend) {
   DCHECK(!init_);
   if (init_)
     return false;
 
   backend_ = backend;
-  MappedFile* file = backend_->File(Addr(RANKINGS, 0, 0, 0));
 
-  header_ = reinterpret_cast<BlockFileHeader*>(file->buffer());
+  control_data_ = backend_->GetLruData();
 
   head_ = ReadHead();
   tail_ = ReadTail();
 
-  if (header_->user[kTransactionIndex])
+  if (control_data_->transaction)
     CompleteTransaction();
 
   init_ = true;
   return true;
 }
 
 void Rankings::Reset() {
   init_ = false;
   head_.set_value(0);
   tail_.set_value(0);
-  header_ = NULL;
+  control_data_ = NULL;
 }
 
 bool Rankings::GetRanking(CacheRankingsBlock* rankings) {
   Time start = Time::Now();
   if (!rankings->address().is_initialized())
     return false;
 
   if (!rankings->Load())
     return false;
 
@@ skipping 21 matching lines @@
   EntryImpl* cache_entry =
       reinterpret_cast<EntryImpl*>(rankings->Data()->pointer);
   rankings->SetData(cache_entry->rankings()->Data());
   UMA_HISTOGRAM_TIMES(L"DiskCache.GetRankings", Time::Now() - start);
   return true;
 }
 
 void Rankings::Insert(CacheRankingsBlock* node, bool modified) {
   Trace("Insert 0x%x", node->address().value());
   DCHECK(node->HasData());
-  Transaction lock(header_->user, node->address(), INSERT);
+  Transaction lock(control_data_, node->address(), INSERT, NO_USE);
   CacheRankingsBlock head(backend_->File(head_), head_);
   if (head_.is_initialized()) {
     if (!GetRanking(&head))
       return;
 
     if (head.Data()->prev != head_.value() &&  // Normal path.
         head.Data()->prev != node->address().value()) {  // FinishInsert().
       backend_->CriticalError(ERR_INVALID_LINKS);
       return;
     }
@@ skipping 66 matching lines @@
   }
 
   CacheRankingsBlock next(backend_->File(next_addr), next_addr);
   CacheRankingsBlock prev(backend_->File(prev_addr), prev_addr);
   if (!GetRanking(&next) || !GetRanking(&prev))
     return;
 
   if (!CheckLinks(node, &prev, &next))
     return;
 
-  Transaction lock(header_->user, node->address(), REMOVE);
+  Transaction lock(control_data_, node->address(), REMOVE, NO_USE);
   prev.Data()->next = next.address().value();
   next.Data()->prev = prev.address().value();
   GenerateCrash(ON_REMOVE_1);
 
   CacheAddr node_value = node->address().value();
   if (node_value == head_.value() || node_value == tail_.value()) {
     if (head_.value() == tail_.value()) {
       head_.set_value(0);
       tail_.set_value(0);
 
@@ skipping 40 matching lines @@
 // but the net effect is just an assert on debug when attempting to remove the
 // entry. Otherwise we'll need reentrant transactions, which is an overkill.
 void Rankings::UpdateRank(CacheRankingsBlock* node, bool modified) {
   Time start = Time::Now();
   Remove(node);
   Insert(node, modified);
   UMA_HISTOGRAM_TIMES(L"DiskCache.UpdateRank", Time::Now() - start);
 }
 
 void Rankings::CompleteTransaction() {
-  Addr node_addr(static_cast<CacheAddr>(header_->user[kTransactionIndex]));
+  Addr node_addr(static_cast<CacheAddr>(control_data_->transaction));
   if (!node_addr.is_initialized() || node_addr.is_separate_file()) {
     NOTREACHED();
     LOG(ERROR) << "Invalid rankings info.";
     return;
   }
 
   Trace("CompleteTransaction 0x%x", node_addr.value());
 
   CacheRankingsBlock node(backend_->File(node_addr), node_addr);
   if (!node.Load())
     return;
 
   node.Data()->pointer = NULL;
   node.Store();
 
   // We want to leave the node inside the list. The entry must me marked as
   // dirty, and will be removed later. Otherwise, we'll get assertions when
   // attempting to remove the dirty entry.
-  if (INSERT == header_->user[kOperationIndex]) {
+  if (INSERT == control_data_->operation) {
     Trace("FinishInsert h:0x%x t:0x%x", head_.value(), tail_.value());
     FinishInsert(&node);
-  } else if (REMOVE == header_->user[kOperationIndex]) {
+  } else if (REMOVE == control_data_->operation) {
     Trace("RevertRemove h:0x%x t:0x%x", head_.value(), tail_.value());
     RevertRemove(&node);
   } else {
     NOTREACHED();
     LOG(ERROR) << "Invalid operation to recover.";
   }
 }
 
 void Rankings::FinishInsert(CacheRankingsBlock* node) {
-  header_->user[kTransactionIndex] = 0;
-  header_->user[kOperationIndex] = 0;
+  control_data_->transaction = 0;
+  control_data_->operation = 0;
   if (head_.value() != node->address().value()) {
     if (tail_.value() == node->address().value()) {
       // This part will be skipped by the logic of Insert.
       node->Data()->next = tail_.value();
     }
 
     Insert(node, true);
   }
 
   // Tell the backend about this entry.
   backend_->RecoveredEntry(node);
 }
 
 void Rankings::RevertRemove(CacheRankingsBlock* node) {
   Addr next_addr(node->Data()->next);
   Addr prev_addr(node->Data()->prev);
   if (!next_addr.is_initialized() || !prev_addr.is_initialized()) {
     // The operation actually finished. Nothing to do.
-    header_->user[kTransactionIndex] = 0;
+    control_data_->transaction = 0;
     return;
   }
   if (next_addr.is_separate_file() || prev_addr.is_separate_file()) {
     NOTREACHED();
     LOG(WARNING) << "Invalid rankings info.";
-    header_->user[kTransactionIndex] = 0;
+    control_data_->transaction = 0;
     return;
   }
 
   CacheRankingsBlock next(backend_->File(next_addr), next_addr);
   CacheRankingsBlock prev(backend_->File(prev_addr), prev_addr);
   if (!next.Load() || !prev.Load())
     return;
 
   CacheAddr node_value = node->address().value();
   DCHECK(prev.Data()->next == node_value ||
@@ skipping 18 matching lines @@
     prev.Data()->next = next.address().value();
     WriteHead();
   } else if (tail_.value() == prev.address().value()) {
     tail_.set_value(node_value);
     next.Data()->prev = prev.address().value();
     WriteTail();
   }
 
   next.Store();
   prev.Store();
-  header_->user[kTransactionIndex] = 0;
-  header_->user[kOperationIndex] = 0;
+  control_data_->transaction = 0;
+  control_data_->operation = 0;
 }
 
 CacheRankingsBlock* Rankings::GetNext(CacheRankingsBlock* node) {
   ScopedRankingsBlock next(this);
   if (!node) {
     if (!head_.is_initialized())
       return NULL;
     next.reset(new CacheRankingsBlock(backend_->File(head_), head_));
   } else {
     if (!tail_.is_initialized())
@@ skipping 101 matching lines @@
   if ((node->address().value() == data->prev) && (head_.value() != data->prev))
     return false;
 
   if ((node->address().value() == data->next) && (tail_.value() != data->next))
     return false;
 
   return true;
 }
 
 Addr Rankings::ReadHead() {
-  CacheAddr head = static_cast<CacheAddr>(header_->user[kHeadIndex]);
-  return Addr(head);
+  return Addr(control_data_->heads[NO_USE]);
 }
 
 Addr Rankings::ReadTail() {
-  CacheAddr tail = static_cast<CacheAddr>(header_->user[kTailIndex]);
-  return Addr(tail);
+  return Addr(control_data_->tails[NO_USE]);
 }
 
 void Rankings::WriteHead() {
-  header_->user[kHeadIndex] = static_cast<int32>(head_.value());
+  control_data_->heads[NO_USE] = head_.value();
 }
 
 void Rankings::WriteTail() {
-  header_->user[kTailIndex] = static_cast<int32>(tail_.value());
+  control_data_->tails[NO_USE] = tail_.value();
 }
 
 bool Rankings::CheckEntry(CacheRankingsBlock* rankings) {
   if (!rankings->Data()->pointer)
     return true;
 
   // If this entry is not dirty, it is a serious problem.
   return backend_->GetCurrentEntryId() != rankings->Data()->dirty;
 }
 
@@ skipping 55 matching lines @@
        ++it) {
     if (it->first == address) {
       CacheRankingsBlock* other = it->second;
       other->Data()->next = node->Data()->next;
       other->Data()->prev = node->Data()->prev;
     }
   }
 }
 
 }  // namespace disk_cache