Disk Cache: Split some time histograms in groups based...

net/disk_cache/entry_impl.cc

 // Copyright (c) 2006-2009 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/entry_impl.h"
 
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
@@ skipping 63 matching lines @@
 
 }  // namespace
 
 namespace disk_cache {
 
 EntryImpl::EntryImpl(BackendImpl* backend, Addr address)
     : entry_(NULL, Addr(0)), node_(NULL, Addr(0)) {
   entry_.LazyInit(backend->File(address), address);
   doomed_ = false;
   backend_ = backend;
-  for (int i = 0; i < NUM_STREAMS; i++) {
+  for (int i = 0; i < kNumStreams; i++) {
     unreported_size_[i] = 0;
   }
 }
 
 // When an entry is deleted from the cache, we clean up all the data associated
 // with it for two reasons: to simplify the reuse of the block (we know that any
 // unused block is filled with zeros), and to simplify the handling of write /
 // read partial information from an entry (don't have to worry about returning
 // data related to a previous cache entry because the range was not fully
 // written before).
 EntryImpl::~EntryImpl() {
   // Save the sparse info to disk before deleting this entry.
   sparse_.reset();
 
   if (doomed_) {
     DeleteEntryData(true);
   } else {
     bool ret = true;
-    for (int index = 0; index < NUM_STREAMS; index++) {
+    for (int index = 0; index < kNumStreams; index++) {
       if (user_buffers_[index].get()) {
         if (!(ret = Flush(index, entry_.Data()->data_size[index], false)))
           LOG(ERROR) << "Failed to save user data";
       } else if (unreported_size_[index]) {
         backend_->ModifyStorageSize(
             entry_.Data()->data_size[index] - unreported_size_[index],
             entry_.Data()->data_size[index]);
       }
     }
     if (node_.HasData() && this == node_.Data()->pointer) {
@@ skipping 27 matching lines @@
 
 void EntryImpl::Close() {
   Release();
 }
 
 std::string EntryImpl::GetKey() const {
   CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_);
   if (entry->Data()->key_len > kMaxInternalKeyLength) {
     Addr address(entry->Data()->long_key);
     DCHECK(address.is_initialized());
-    COMPILE_ASSERT(NUM_STREAMS == kKeyFileIndex, invalid_key_index);
+    COMPILE_ASSERT(kNumStreams == kKeyFileIndex, invalid_key_index);
     File* file = const_cast<EntryImpl*>(this)->GetBackingFile(address,
                                                               kKeyFileIndex);
 
     size_t offset = 0;
     if (address.is_block_file())
       offset = address.start_block() * address.BlockSize() + kBlockHeaderSize;
 
     std::string key;
     if (!file || !file->Read(WriteInto(&key, entry->Data()->key_len + 1),
                              entry->Data()->key_len + 1, offset))
       key.clear();
     return key;
   } else {
     return std::string(entry->Data()->key);
   }
 }
 
 Time EntryImpl::GetLastUsed() const {
   CacheRankingsBlock* node = const_cast<CacheRankingsBlock*>(&node_);
   return Time::FromInternalValue(node->Data()->last_used);
 }
 
 Time EntryImpl::GetLastModified() const {
   CacheRankingsBlock* node = const_cast<CacheRankingsBlock*>(&node_);
   return Time::FromInternalValue(node->Data()->last_modified);
 }
 
 int32 EntryImpl::GetDataSize(int index) const {
-  if (index < 0 || index >= NUM_STREAMS)
+  if (index < 0 || index >= kNumStreams)
     return 0;
 
   CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_);
   return entry->Data()->data_size[index];
 }
 
 int EntryImpl::ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
                         net::CompletionCallback* completion_callback) {
   DCHECK(node_.Data()->dirty);
-  if (index < 0 || index >= NUM_STREAMS)
+  if (index < 0 || index >= kNumStreams)
     return net::ERR_INVALID_ARGUMENT;
 
   int entry_size = entry_.Data()->data_size[index];
   if (offset >= entry_size || offset < 0 || !buf_len)
     return 0;
 
   if (buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   Time start = Time::Now();
-  static Histogram stats("DiskCache.ReadTime", TimeDelta::FromMilliseconds(1),
-                         TimeDelta::FromSeconds(10), 50);
-  stats.SetFlags(kUmaTargetedHistogramFlag);
 
   if (offset + buf_len > entry_size)
     buf_len = entry_size - offset;
 
   UpdateRank(false);
 
   backend_->OnEvent(Stats::READ_DATA);
 
   if (user_buffers_[index].get()) {
     // Complete the operation locally.
     DCHECK(kMaxBlockSize >= offset + buf_len);
     memcpy(buf->data() , user_buffers_[index].get() + offset, buf_len);
-    if (backend_->cache_type() == net::DISK_CACHE)
-      stats.AddTime(Time::Now() - start);
+    ReportIOTime(kRead, start);
     return buf_len;
   }
 
   Addr address(entry_.Data()->data_addr[index]);
   DCHECK(address.is_initialized());
   if (!address.is_initialized())
     return net::ERR_FAILED;
 
   File* file = GetBackingFile(address, index);
   if (!file)
@@ skipping 11 matching lines @@
   bool completed;
   if (!file->Read(buf->data(), buf_len, file_offset, io_callback, &completed)) {
     if (io_callback)
       io_callback->Discard();
     return net::ERR_FAILED;
   }
 
   if (io_callback && completed)
     io_callback->Discard();
 
-  if (backend_->cache_type() == net::DISK_CACHE)
-    stats.AddTime(Time::Now() - start);
+  ReportIOTime(kRead, start);
   return (completed || !completion_callback) ? buf_len : net::ERR_IO_PENDING;
 }
 
 int EntryImpl::WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
                          net::CompletionCallback* completion_callback,
                          bool truncate) {
   DCHECK(node_.Data()->dirty);
-  if (index < 0 || index >= NUM_STREAMS)
+  if (index < 0 || index >= kNumStreams)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   int max_file_size = backend_->MaxFileSize();
 
   // offset of buf_len could be negative numbers.
   if (offset > max_file_size || buf_len > max_file_size ||
       offset + buf_len > max_file_size) {
     int size = offset + buf_len;
     if (size <= max_file_size)
       size = kint32max;
     backend_->TooMuchStorageRequested(size);
     return net::ERR_FAILED;
   }
 
   Time start = Time::Now();
-  static Histogram stats("DiskCache.WriteTime", TimeDelta::FromMilliseconds(1),
-                         TimeDelta::FromSeconds(10), 50);
-  stats.SetFlags(kUmaTargetedHistogramFlag);
 
   // Read the size at this point (it may change inside prepare).
   int entry_size = entry_.Data()->data_size[index];
   if (!PrepareTarget(index, offset, buf_len, truncate))
     return net::ERR_FAILED;
 
   if (entry_size < offset + buf_len) {
     unreported_size_[index] += offset + buf_len - entry_size;
     entry_.Data()->data_size[index] = offset + buf_len;
     entry_.set_modified();
@@ skipping 17 matching lines @@
 
   backend_->OnEvent(Stats::WRITE_DATA);
 
   if (user_buffers_[index].get()) {
     // Complete the operation locally.
     if (!buf_len)
       return 0;
 
     DCHECK(kMaxBlockSize >= offset + buf_len);
     memcpy(user_buffers_[index].get() + offset, buf->data(), buf_len);
-    if (backend_->cache_type() == net::DISK_CACHE)
-      stats.AddTime(Time::Now() - start);
+    ReportIOTime(kWrite, start);
     return buf_len;
   }
 
   Addr address(entry_.Data()->data_addr[index]);
   File* file = GetBackingFile(address, index);
   if (!file)
     return net::ERR_FAILED;
 
   size_t file_offset = offset;
   if (address.is_block_file()) {
@@ skipping 15 matching lines @@
   if (!file->Write(buf->data(), buf_len, file_offset, io_callback,
                    &completed)) {
     if (io_callback)
       io_callback->Discard();
     return net::ERR_FAILED;
   }
 
   if (io_callback && completed)
     io_callback->Discard();
 
-  if (backend_->cache_type() == net::DISK_CACHE)
-    stats.AddTime(Time::Now() - start);
+  ReportIOTime(kWrite, start);
   return (completed || !completion_callback) ? buf_len : net::ERR_IO_PENDING;
 }
 
 int EntryImpl::ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
                               net::CompletionCallback* completion_callback) {
   DCHECK(node_.Data()->dirty);
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
-  return sparse_->StartIO(SparseControl::kReadOperation, offset, buf, buf_len,
-                          completion_callback);
+  Time start = Time::Now();
+  result = sparse_->StartIO(SparseControl::kReadOperation, offset, buf, buf_len,
+                            completion_callback);
+  ReportIOTime(kSparseRead, start);
+  return result;
 }
 
 int EntryImpl::WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
                                net::CompletionCallback* completion_callback) {
   DCHECK(node_.Data()->dirty);
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
-  return sparse_->StartIO(SparseControl::kWriteOperation, offset, buf, buf_len,
-                          completion_callback);
+  Time start = Time::Now();
+  result = sparse_->StartIO(SparseControl::kWriteOperation, offset, buf,
+                            buf_len, completion_callback);
+  ReportIOTime(kSparseWrite, start);
+  return result;
 }
 
 int EntryImpl::GetAvailableRange(int64 offset, int len, int64* start) {
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
   return sparse_->GetAvailableRange(offset, len, start);
 }
 
@@ skipping 65 matching lines @@
   doomed_ = true;
 }
 
 void EntryImpl::DeleteEntryData(bool everything) {
   DCHECK(doomed_ || !everything);
 
   if (GetDataSize(0))
     CACHE_UMA(COUNTS, "DeleteHeader", 0, GetDataSize(0));
   if (GetDataSize(1))
     CACHE_UMA(COUNTS, "DeleteData", 0, GetDataSize(1));
-  for (int index = 0; index < NUM_STREAMS; index++) {
+  for (int index = 0; index < kNumStreams; index++) {
     Addr address(entry_.Data()->data_addr[index]);
     if (address.is_initialized()) {
       DeleteData(address, index);
       backend_->ModifyStorageSize(entry_.Data()->data_size[index] -
                                       unreported_size_[index], 0);
       entry_.Data()->data_addr[index] = 0;
       entry_.Data()->data_size[index] = 0;
     }
   }
 
@@ skipping 103 matching lines @@
   backend_->DecrementIoCount();
 }
 
 void EntryImpl::SetTimes(base::Time last_used, base::Time last_modified) {
   node_.Data()->last_used = last_used.ToInternalValue();
   node_.Data()->last_modified = last_modified.ToInternalValue();
   node_.set_modified();
 }
 
 bool EntryImpl::CreateDataBlock(int index, int size) {
-  DCHECK(index >= 0 && index < NUM_STREAMS);
+  DCHECK(index >= 0 && index < kNumStreams);
 
   Addr address(entry_.Data()->data_addr[index]);
   if (!CreateBlock(size, &address))
     return false;
 
   entry_.Data()->data_addr[index] = address.value();
   entry_.Store();
   return true;
 }
 
@@ skipping 239 matching lines @@
   if (sparse_.get())
     return net::OK;
 
   sparse_.reset(new SparseControl(this));
   int result = sparse_->Init();
   if (net::OK != result)
     sparse_.reset();
   return result;
 }
 
+void EntryImpl::ReportIOTime(Operation op, const base::Time& start) {
+  int group = backend_->GetSizeGroup();
+  switch (op) {
+    case kRead:
+      CACHE_UMA(AGE_MS, "ReadTime", group, start);
+      break;
+    case kWrite:
+      CACHE_UMA(AGE_MS, "WriteTime", group, start);
+      break;
+    case kSparseRead:
+      CACHE_UMA(AGE_MS, "SparseReadTime", 0, start);
+      break;
+    case kSparseWrite:
+      CACHE_UMA(AGE_MS, "SparseWriteTime", 0, start);
+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
 void EntryImpl::Log(const char* msg) {
   void* pointer = NULL;
   int dirty = 0;
   if (node_.HasData()) {
     pointer = node_.Data()->pointer;
     dirty = node_.Data()->dirty;
   }
 
   Trace("%s 0x%p 0x%x 0x%x", msg, reinterpret_cast<void*>(this),
         entry_.address().value(), node_.address().value());
 
   Trace("  data: 0x%x 0x%x 0x%x", entry_.Data()->data_addr[0],
         entry_.Data()->data_addr[1], entry_.Data()->long_key);
 
   Trace("  doomed: %d 0x%p 0x%x", doomed_, pointer, dirty);
 }
 
 }  // namespace disk_cache