Disk cache: Read the index and data_0 files in a single...

net/disk_cache/backend_impl.cc

 // Copyright (c) 2006-2010 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/backend_impl.h"
 
 #include "base/field_trial.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
@@ skipping 1701 matching lines @@
   StatsItems stats;
   GetStats(&stats);
 
   for (size_t index = 0; index < stats.size(); index++) {
     LOG(INFO) << stats[index].first << ": " << stats[index].second;
   }
 }
 
 void BackendImpl::ReportStats() {
   CACHE_UMA(COUNTS, "Entries", 0, data_->header.num_entries);
-  CACHE_UMA(COUNTS, "Size", 0, data_->header.num_bytes / (1024 * 1024));
-  CACHE_UMA(COUNTS, "MaxSize", 0, max_size_ / (1024 * 1024));
+  CACHE_UMA(COUNTS_10000, "Size2", 0, data_->header.num_bytes / (1024 * 1024));

[nsylvain, 2010/07/15 05:47:04]

What is COUNTS_10000 ?

[rvargas (doing something else), 2010/07/15 18:31:50]

Counts adjust the scale from 0 to 1 million. counts_10000 goes from 0 to 10000.
Given that the value is already MB, we have better resolution around interesting
values with the latter. It was an oversight / I thought COUNT was already 10k...
the downside is that now we need another name for the histogram because they are
different.

+  CACHE_UMA(COUNTS_10000, "MaxSize2", 0, max_size_ / (1024 * 1024));
 
-  CACHE_UMA(COUNTS, "AverageOpenEntries", 0,
+  CACHE_UMA(COUNTS_10000, "AverageOpenEntries2", 0,
             static_cast<int>(stats_.GetCounter(Stats::OPEN_ENTRIES)));
-  CACHE_UMA(COUNTS, "MaxOpenEntries", 0,
+  CACHE_UMA(COUNTS_10000, "MaxOpenEntries2", 0,
             static_cast<int>(stats_.GetCounter(Stats::MAX_ENTRIES)));
   stats_.SetCounter(Stats::MAX_ENTRIES, 0);
 
   if (!data_->header.create_time || !data_->header.lru.filled)
     return;
 
   // This is an up to date client that will report FirstEviction() data. After
   // that event, start reporting this:
 
   int64 total_hours = stats_.GetCounter(Stats::TIMER) / 120;
@@ skipping 11 matching lines @@
     return;
 
   CACHE_UMA(HOURS, "UseTime", 0, static_cast<int>(use_hours));
   CACHE_UMA(PERCENTAGE, "HitRatio", 0, stats_.GetHitRatio());
 
   int64 trim_rate = stats_.GetCounter(Stats::TRIM_ENTRY) / use_hours;
   CACHE_UMA(COUNTS, "TrimRate", 0, static_cast<int>(trim_rate));
 
   int avg_size = data_->header.num_bytes / GetEntryCount();
   CACHE_UMA(COUNTS, "EntrySize", 0, avg_size);
+  CACHE_UMA(COUNTS, "EntriesFull", 0, data_->header.num_entries);
 
   CACHE_UMA(PERCENTAGE, "IndexLoad", 0,
             data_->header.num_entries * 100 / (mask_ + 1));
 
   int large_entries_bytes = stats_.GetLargeEntriesSize();
   int large_ratio = large_entries_bytes * 100 / data_->header.num_bytes;
   CACHE_UMA(PERCENTAGE, "LargeEntriesRatio", 0, large_ratio);
 
   if (new_eviction_) {
     CACHE_UMA(PERCENTAGE, "ResurrectRatio", 0, stats_.GetResurrectRatio());
     CACHE_UMA(PERCENTAGE, "NoUseRatio", 0,
               data_->header.lru.sizes[0] * 100 / data_->header.num_entries);
     CACHE_UMA(PERCENTAGE, "LowUseRatio", 0,
               data_->header.lru.sizes[1] * 100 / data_->header.num_entries);
     CACHE_UMA(PERCENTAGE, "HighUseRatio", 0,
               data_->header.lru.sizes[2] * 100 / data_->header.num_entries);
     CACHE_UMA(PERCENTAGE, "DeletedRatio", 0,
               data_->header.lru.sizes[4] * 100 / data_->header.num_entries);
   }
 
   stats_.ResetRatios();
   stats_.SetCounter(Stats::TRIM_ENTRY, 0);
+
+  if (cache_type_ == net::DISK_CACHE)
+    block_files_.ReportStats();
 }
 
 void BackendImpl::UpgradeTo2_1() {
   // 2.1 is basically the same as 2.0, except that new fields are actually
   // updated by the new eviction algorithm.
   DCHECK(0x20000 == data_->header.version);
   data_->header.version = 0x20001;
   data_->header.lru.sizes[Rankings::NO_USE] = data_->header.num_entries;
 }
 
@@ skipping 46 matching lines @@
   }
 
   if (data_->header.num_entries < 0) {
     LOG(ERROR) << "Invalid number of entries";
     return false;
   }
 
   if (!mask_)
     mask_ = data_->header.table_len - 1;
 
-  return true;
+  // Load the table into memory with a single read.
+  scoped_array<char> buf(new char[current_size]);
+  return index_->Read(buf.get(), current_size, 0);

[nsylvain, 2010/07/15 05:47:04]

How much does it help? Or is this just an experiment?

[rvargas (doing something else), 2010/07/15 18:31:50]

Hard to tell, because it only affects people with slow / overloaded systems (IO
wise). It reduces the number of IO reads from 4/8 to 1, but makes cache
initialization a little slower.

Another side benefit is that it should reduce a few crashes due to unreliable
hardware when we actually try to access the table (it *should* fail at this
point).

 }
 
 int BackendImpl::CheckAllEntries() {
   int num_dirty = 0;
   int num_entries = 0;
   DCHECK(mask_ < kuint32max);
   for (int i = 0; i <= static_cast<int>(mask_); i++) {
     Addr address(data_->table[i]);
     if (!address.is_initialized())
       continue;
@@ skipping 26 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->dummy;
 }
 
 }  // namespace disk_cache