Disk cache: Reference CL for the implementation of file format version 3.

net/disk_cache/stats.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/stats.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
-#include "net/disk_cache/backend_impl.h"
 
 namespace {
 
 const int32 kDiskSignature = 0xF01427E0;
 
 struct OnDiskStats {
   int32 signature;
   int size;
   int data_sizes[disk_cache::Stats::kDataSizesLength];
   int64 counters[disk_cache::Stats::MAX_COUNTER];
@@ skipping 32 matching lines @@
   "Max entries",
   "Timer",
   "Read data",
   "Write data",
   "Open rankings",
   "Get rankings",
   "Fatal error",
   "Last report",
   "Last report timer",
   "Doom recent entries",
-  "ga.js evicted"
+  "unused"
 };
 COMPILE_ASSERT(arraysize(kCounterNames) == disk_cache::Stats::MAX_COUNTER,
                update_the_names);
 
 }  // namespace
 
 namespace disk_cache {
 
-bool LoadStats(BackendImpl* backend, Addr address, OnDiskStats* stats) {
-  MappedFile* file = backend->File(address);
-  if (!file)
-    return false;
-
-  size_t offset = address.start_block() * address.BlockSize() +
-                  kBlockHeaderSize;
-  memset(stats, 0, sizeof(*stats));
-  if (!file->Read(stats, sizeof(*stats), offset))
-    return false;
-
+bool VerifyStats(OnDiskStats* stats) {
   if (stats->signature != kDiskSignature)
     return false;
 
   // We don't want to discard the whole cache every time we have one extra
   // counter; we keep old data if we can.
   if (static_cast<unsigned int>(stats->size) > sizeof(*stats)) {
     memset(stats, 0, sizeof(*stats));
     stats->signature = kDiskSignature;
   } else if (static_cast<unsigned int>(stats->size) != sizeof(*stats)) {
     size_t delta = sizeof(*stats) - static_cast<unsigned int>(stats->size);
     memset(reinterpret_cast<char*>(stats) + stats->size, 0, delta);
     stats->size = sizeof(*stats);
   }
 
   return true;
 }
 
-bool StoreStats(BackendImpl* backend, Addr address, OnDiskStats* stats) {
-  MappedFile* file = backend->File(address);
-  if (!file)
-    return false;
-
-  size_t offset = address.start_block() * address.BlockSize() +
-                  kBlockHeaderSize;
-  return file->Write(stats, sizeof(*stats), offset);
-}
-
-bool CreateStats(BackendImpl* backend, Addr* address, OnDiskStats* stats) {
-  if (!backend->CreateBlock(BLOCK_256, 2, address))
-    return false;
-
-  // If we have more than 512 bytes of counters, change kDiskSignature so we
-  // don't overwrite something else (LoadStats must fail).
-  COMPILE_ASSERT(sizeof(*stats) <= 256 * 2, use_more_blocks);
-  memset(stats, 0, sizeof(*stats));
-  stats->signature = kDiskSignature;
-  stats->size = sizeof(*stats);
-
-  return StoreStats(backend, *address, stats);
-}
-
-Stats::Stats() : backend_(NULL), size_histogram_(NULL) {
+Stats::Stats() : size_histogram_(NULL) {
 }
 
 Stats::~Stats() {
 }
 
-bool Stats::Init(BackendImpl* backend, uint32* storage_addr) {
-  OnDiskStats stats;
-  Addr address(*storage_addr);
-  if (address.is_initialized()) {
-    if (!LoadStats(backend, address, &stats))
+bool Stats::Init(void* data, int num_bytes, Addr address) {
+  OnDiskStats local_stats;
+  OnDiskStats* stats = &local_stats;
+  if (!num_bytes) {
+    memset(stats, 0, sizeof(local_stats));
+    local_stats.signature = kDiskSignature;
+    local_stats.size = sizeof(local_stats);
+  } else if (num_bytes >= static_cast<int>(sizeof(*stats))) {
+    stats = reinterpret_cast<OnDiskStats*>(data);
+    if (!VerifyStats(stats))
       return false;
   } else {
-    if (!CreateStats(backend, &address, &stats))
-      return false;
-    *storage_addr = address.value();
+    return false;
   }
 
-  storage_addr_ = address.value();
-  backend_ = backend;
+  storage_addr_ = address;
 
-  memcpy(data_sizes_, stats.data_sizes, sizeof(data_sizes_));
-  memcpy(counters_, stats.counters, sizeof(counters_));
+  memcpy(data_sizes_, stats->data_sizes, sizeof(data_sizes_));
+  memcpy(counters_, stats->counters, sizeof(counters_));
 
+  // Clean up old value.
+  SetCounter(UNUSED, 0);
+  return true;
+}
+
+void Stats::InitSizeHistogram() {
   // It seems impossible to support this histogram for more than one
   // simultaneous objects with the current infrastructure.
   static bool first_time = true;
   if (first_time) {
     first_time = false;
-    // ShouldReportAgain() will re-enter this object.
-    if (!size_histogram_ && backend->cache_type() == net::DISK_CACHE &&
-        backend->ShouldReportAgain()) {
+    if (!size_histogram_) {
       // Stats may be reused when the cache is re-created, but we want only one
       // histogram at any given time.
       size_histogram_ = StatsHistogram::FactoryGet("DiskCache.SizeStats", this);
     }
   }
+}
 
-  return true;
+int Stats::StorageSize() {
+  // If we have more than 512 bytes of counters, change kDiskSignature so we
+  // don't overwrite something else (LoadStats must fail).
+  COMPILE_ASSERT(sizeof(OnDiskStats) <= 256 * 2, use_more_blocks);
+  return 256 * 2;
 }
 
 void Stats::ModifyStorageStats(int32 old_size, int32 new_size) {
   // We keep a counter of the data block size on an array where each entry is
   // the adjusted log base 2 of the size. The first entry counts blocks of 256
   // bytes, the second blocks up to 512 bytes, etc. With 20 entries, the last
   // one stores entries of more than 64 MB
   int new_index = GetStatsBucket(new_size);
   int old_index = GetStatsBucket(old_size);
 
@@ skipping 52 matching lines @@
 int Stats::GetLargeEntriesSize() {
   int total = 0;
   // data_sizes_[20] stores values between 512 KB and 1 MB (see comment before
   // GetStatsBucket()).
   for (int bucket = 20; bucket < kDataSizesLength; bucket++)
     total += data_sizes_[bucket] * GetBucketRange(bucket);
 
   return total;
 }
 
-void Stats::Store() {
-  if (!backend_)
-    return;
+int Stats::SerializeStats(void* data, int num_bytes, Addr* address) {
+  OnDiskStats* stats = reinterpret_cast<OnDiskStats*>(data);
+  if (num_bytes < static_cast<int>(sizeof(*stats)))
+    return 0;
 
-  OnDiskStats stats;
-  stats.signature = kDiskSignature;
-  stats.size = sizeof(stats);
-  memcpy(stats.data_sizes, data_sizes_, sizeof(data_sizes_));
-  memcpy(stats.counters, counters_, sizeof(counters_));
+  stats->signature = kDiskSignature;
+  stats->size = sizeof(*stats);
+  memcpy(stats->data_sizes, data_sizes_, sizeof(data_sizes_));
+  memcpy(stats->counters, counters_, sizeof(counters_));
 
-  Addr address(storage_addr_);
-  StoreStats(backend_, address, &stats);
+  *address = storage_addr_;
+  return sizeof(*stats);
 }
 
 int Stats::GetBucketRange(size_t i) const {
   if (i < 2)
     return static_cast<int>(1024 * i);
 
   if (i < 12)
     return static_cast<int>(2048 * (i - 1));
 
   if (i < 17)
@@ skipping 65 matching lines @@
 int Stats::GetRatio(Counters hit, Counters miss) const {
   int64 ratio = GetCounter(hit) * 100;
   if (!ratio)
     return 0;
 
   ratio /= (GetCounter(hit) + GetCounter(miss));
   return static_cast<int>(ratio);
 }
 
 }  // namespace disk_cache