Disk Cache: Second pass (and final) to allow multiple instances...

net/disk_cache/eviction.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.
 
 // The eviction policy is a very simple pure LRU, so the elements at the end of
 // the list are evicted until kCleanUpMargin free space is available. There is
 // only one list in use (Rankings::NO_USE), and elements are sent to the front
 // of the list whenever they are accessed.
 
 // The new (in-development) eviction policy ads re-use as a factor to evict
@@ skipping 16 matching lines @@
 // list.
 
 #include "net/disk_cache/eviction.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/entry_impl.h"
+#include "net/disk_cache/histogram_macros.h"
 #include "net/disk_cache/trace.h"
 
 using base::Time;
 
-// HISTOGRAM_HOURS will collect time related data with a granularity of hours
-// and normal values of a few months.
-#define UMA_HISTOGRAM_HOURS UMA_HISTOGRAM_COUNTS_10000
-
 namespace {
 
 const int kCleanUpMargin = 1024 * 1024;
 const int kHighUse = 10;  // Reuse count to be on the HIGH_USE list.
 const int kTargetTime = 24 * 7;  // Time to be evicted (hours since last use).
 
 int LowWaterAdjust(int high_water) {
   if (high_water < kCleanUpMargin)
     return 0;
 
@@ skipping 43 matching lines @@
       if (++deleted == 4 && !empty) {
 #if defined(OS_WIN)
         MessageLoop::current()->PostTask(FROM_HERE,
             factory_.NewRunnableMethod(&Eviction::TrimCache, false));
         break;
 #endif
       }
     }
   }
 
-  UMA_HISTOGRAM_TIMES("DiskCache.TotalTrimTime", Time::Now() - start);
+  CACHE_UMA(AGE_MS, "TotalTrimTime", 0, start);
   Trace("*** Trim Cache end ***");
   return;
 }
 
 void Eviction::UpdateRank(EntryImpl* entry, bool modified) {
   if (new_eviction_)
     return UpdateRankV2(entry, modified);
 
   rankings_->UpdateRank(entry->rankings(), modified, GetListForEntry(entry));
 }
@@ skipping 19 matching lines @@
 
 void Eviction::OnDestroyEntry(EntryImpl* entry) {
   if (new_eviction_)
     return OnDestroyEntryV2(entry);
 }
 
 void Eviction::ReportTrimTimes(EntryImpl* entry) {
   if (first_trim_) {
     first_trim_ = false;
     if (backend_->ShouldReportAgain()) {
-      std::string name(StringPrintf("DiskCache.TrimAge_%d",
-                                    header_->experiment));
-      UMA_HISTOGRAM_HOURS(name.c_str(),
-                          (Time::Now() - entry->GetLastUsed()).InHours());
+      CACHE_UMA(AGE, "TrimAge", header_->experiment, entry->GetLastUsed());
     }
 
     if (header_->create_time && !header_->lru.filled) {
       // This is the first entry that we have to evict, generate some noise.
       header_->lru.filled = 1;
       backend_->FirstEviction();
     }
   }
 }
 
@@ skipping 96 matching lines @@
       list = kListsToSearch;
   }
 
   if (empty) {
     TrimDeleted(true);
   } else if (header_->lru.sizes[Rankings::DELETED] > header_->num_entries / 4) {
     MessageLoop::current()->PostTask(FROM_HERE,
         factory_.NewRunnableMethod(&Eviction::TrimDeleted, empty));
   }
 
-  UMA_HISTOGRAM_TIMES("DiskCache.TotalTrimTime", Time::Now() - start);
+  CACHE_UMA(AGE_MS, "TotalTrimTime", 0, start);
   Trace("*** Trim Cache end ***");
   return;
 }
 
 void Eviction::UpdateRankV2(EntryImpl* entry, bool modified) {
   rankings_->UpdateRank(entry->rankings(), modified, GetListForEntryV2(entry));
 }
 
 void Eviction::OnOpenEntryV2(EntryImpl* entry) {
   EntryStore* info = entry->entry()->Data();
@@ skipping 89 matching lines @@
   for (int i = 0; (i < 4 || empty) && next.get(); i++) {
     node.reset(next.release());
     next.reset(rankings_->GetPrev(node.get(), Rankings::DELETED));
     RemoveDeletedNode(node.get());
   }
 
   if (header_->lru.sizes[Rankings::DELETED] > header_->num_entries / 4)
     MessageLoop::current()->PostTask(FROM_HERE,
         factory_.NewRunnableMethod(&Eviction::TrimDeleted, false));
 
-  UMA_HISTOGRAM_TIMES("DiskCache.TotalTrimDeletedTime", Time::Now() - start);
+  CACHE_UMA(AGE_MS, "TotalTrimDeletedTime", 0, start);
   Trace("*** Trim Deleted end ***");
   return;
 }
 
 bool Eviction::RemoveDeletedNode(CacheRankingsBlock* node) {
   EntryImpl* entry;
   bool dirty;
   if (backend_->NewEntry(Addr(node->Data()->contents), &entry, &dirty)) {
     Trace("NewEntry failed on Trim 0x%x", node->address().value());
     return false;
@@ skipping 25 matching lines @@
                      header_->lru.sizes[Rankings::DELETED];
   // Start by having each list to be roughly the same size.
   if (header_->lru.sizes[0] > data_entries / 3)
     return 0;
   if (header_->lru.sizes[1] > data_entries / 3)
     return 1;
   return 2;
 }
 
 }  // namespace disk_cache