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

net/disk_cache/block_files.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/block_files.h"
 
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 154 matching lines @@
   if (zero_buffer_)
     delete[] zero_buffer_;
   CloseFiles();
 }
 
 bool BlockFiles::Init(bool create_files) {
   DCHECK(!init_);
   if (init_)
     return false;
 
-  block_files_.resize(kFirstAdditionlBlockFile);
-  for (int i = 0; i < kFirstAdditionlBlockFile; i++) {
+  block_files_.resize(kFirstAdditionalBlockFile);
+  for (int i = 0; i < kFirstAdditionalBlockFile; i++) {
     if (create_files)
       if (!CreateBlockFile(i, static_cast<FileType>(i + 1), true))
         return false;
 
     if (!OpenBlockFile(i))
       return false;
 
     // Walk this chain of files removing empty ones.
     RemoveEmptyFile(static_cast<FileType>(i + 1));
   }
 
   init_ = true;
   return true;
 }
 
 void BlockFiles::CloseFiles() {
   init_ = false;
   for (unsigned int i = 0; i < block_files_.size(); i++) {
     if (block_files_[i]) {
       block_files_[i]->Release();
       block_files_[i] = NULL;
     }
   }
   block_files_.clear();
 }
 
-FilePath BlockFiles::Name(int index) {
-  // The file format allows for 256 files.
-  DCHECK(index < 256 || index >= 0);
-  std::string tmp = StringPrintf("%s%d", kBlockName, index);
-  return path_.AppendASCII(tmp);
+void BlockFiles::ReportStats() {
+  int used_blocks[kFirstAdditionalBlockFile];
+  int load[kFirstAdditionalBlockFile];
+  for (int i = 0; i < kFirstAdditionalBlockFile; i++) {
+    GetFileStats(i, &used_blocks[i], &load[i]);
+  }
+  UMA_HISTOGRAM_COUNTS("Blocks_0", used_blocks[0]);
+  UMA_HISTOGRAM_COUNTS("Blocks_1", used_blocks[1]);
+  UMA_HISTOGRAM_COUNTS("Blocks_2", used_blocks[2]);
+  UMA_HISTOGRAM_COUNTS("Blocks_3", used_blocks[3]);
+
+  UMA_HISTOGRAM_ENUMERATION("BlockLoad_0", load[0], 101);
+  UMA_HISTOGRAM_ENUMERATION("BlockLoad_1", load[1], 101);
+  UMA_HISTOGRAM_ENUMERATION("BlockLoad_2", load[2], 101);
+  UMA_HISTOGRAM_ENUMERATION("BlockLoad_3", load[3], 101);
 }
 
 bool BlockFiles::CreateBlockFile(int index, FileType file_type, bool force) {
   FilePath name = Name(index);
   int flags =
       force ? base::PLATFORM_FILE_CREATE_ALWAYS : base::PLATFORM_FILE_CREATE;
   flags |= base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_EXCLUSIVE_WRITE;
 
   scoped_refptr<File> file(new File(
       base::CreatePlatformFile(name, flags, NULL)));
@@ skipping 16 matching lines @@
   }
 
   FilePath name = Name(index);
   scoped_refptr<MappedFile> file(new MappedFile());
 
   if (!file->Init(name, kBlockHeaderSize)) {
     LOG(ERROR) << "Failed to open " << name.value();
     return false;
   }
 
-  if (file->GetLength() < static_cast<size_t>(kBlockHeaderSize)) {
+  size_t file_len = file->GetLength();

[gavinp, 2010/07/15 15:03:48]

nit: const

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

What do you mean?

if you mean const size_t file_len = x, we don't usually do that unless we are
declaring a constant

+  if (file_len < static_cast<size_t>(kBlockHeaderSize)) {
     LOG(ERROR) << "File too small " << name.value();
     return false;
   }
 
   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
   if (kBlockMagic != header->magic || kCurrentVersion != header->version) {
     LOG(ERROR) << "Invalid file version or magic";
     return false;
   }
 
   if (header->updating) {
     // Last instance was not properly shutdown.
     if (!FixBlockFileHeader(file))
       return false;
   }
 
+  if (index == 0) {
+    // Load the links file into memory with a single read.
+    scoped_array<char> buf(new char[file_len]);
+    if (!file->Read(buf.get(), file_len, 0))
+      return false;
+  }
+
   DCHECK(!block_files_[index]);
   file.swap(&block_files_[index]);
   return true;
 }
 
 MappedFile* BlockFiles::GetFile(Addr address) {
   DCHECK(block_files_.size() >= 4);
   DCHECK(address.is_block_file() || !address.is_initialized());
   if (!address.is_initialized())
     return NULL;
@@ skipping 78 matching lines @@
     FileLock lock(header);
     header->next_file = new_file;
   }
 
   // Only the block_file argument is relevant for what we want.
   Addr address(BLOCK_256, 1, new_file, 0);
   return GetFile(address);
 }
 
 int BlockFiles::CreateNextBlockFile(FileType block_type) {
-  for (int i = kFirstAdditionlBlockFile; i <= kMaxBlockFile; i++) {
+  for (int i = kFirstAdditionalBlockFile; i <= kMaxBlockFile; i++) {
     if (CreateBlockFile(i, block_type, false))
       return i;
   }
   return 0;
 }
 
 // We walk the list of files for this particular block type, deleting the ones
 // that are empty.
 void BlockFiles::RemoveEmptyFile(FileType block_type) {
   MappedFile* file = block_files_[block_type - 1];
@@ skipping 108 matching lines @@
     // We were in the middle of growing the file.
     int num_entries = (file_size - sizeof(*header)) / header->entry_size;
     header->max_entries = num_entries;
   }
 
   FixAllocationCounters(header);
   header->updating = 0;
   return true;
 }
 
+// We are interested in the total number of block used by this file type, and
+// the max number of blocks that we can store (reported as the percentage of
+// used blocks). In order to find out the number of used blocks, we have to
+// substract the empty blocks from the total blocks for each file in the chain.
+void BlockFiles::GetFileStats(int index, int* used_count, int* load) {
+  int max_blocks = 0;
+  *used_count = 0;
+  *load = 0;
+  for (;;) {
+    if (!block_files_[index] && !OpenBlockFile(index))
+      return;
+
+    BlockFileHeader* header =
+        reinterpret_cast<BlockFileHeader*>(block_files_[index]->buffer());
+
+    max_blocks += header->max_entries;
+    int used = header->max_entries;
+    for (int i = 0; i < 4; i++) {
+      used -= header->empty[i] * (i + 1);

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

What does header->empty[i] contain? This looks a little bit weird that we
multiple by i+1, but i'm sure it's right ;)

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

empty is an array of 4 slots that keeps the number of empty blocks that can hold
an entry of the desired size:
entry[0] == x -> can store x entries of size 1
entry[3] == x -> can store x entries of size 4 (or 3, 2x of size 2 and 4x of
size 1)

+      DCHECK_GE(used, 0);
+    }
+    *used_count += used;
+
+    if (!header->next_file)
+      break;
+    index = header->next_file;
+  }
+  if (max_blocks)
+    *load = *used_count * 100 / max_blocks;
+}
+
+FilePath BlockFiles::Name(int index) {
+  // The file format allows for 256 files.
+  DCHECK(index < 256 || index >= 0);
+  std::string tmp = StringPrintf("%s%d", kBlockName, index);
+  return path_.AppendASCII(tmp);
+}
+
 }  // namespace disk_cache