Disk cache: Don't evict anything for the first five

net/disk_cache/backend_impl.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/backend_impl.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
@@ skipping 29 matching lines @@
 const char* kIndexName = "index";
 const int kMaxOldFolders = 100;
 
 // Seems like ~240 MB correspond to less than 50k entries for 99% of the people.
 // Note that the actual target is to keep the index table load factor under 55%
 // for most users.
 const int k64kEntriesStore = 240 * 1000 * 1000;
 const int kBaseTableLen = 64 * 1024;
 const int kDefaultCacheSize = 80 * 1024 * 1024;
 
+// Avoid trimming the cache for the first 5 minutes (10 timer ticks).
+const int kTrimDelay = 10;

[gavinp, 2011/08/31 03:01:20]

I'm also made a bit grumpy that these are in multiples of 30 seconds, without
being calculated.  I'd rather this was 5 * kTicksPerMinute or 300 /
kSecondsPerTick.  I haven't looked to see if either constant is available
though.

[rvargas (doing something else), 2011/08/31 18:06:35]

I see your point, but right now 30 seconds is kind of embedded in the code
(mostly relevant for UMA) and I don't want to give the impression that changing
the timer interval is as easy as changing a constant at the top of the file :(

+
 int DesiredIndexTableLen(int32 storage_size) {
   if (storage_size <= k64kEntriesStore)
     return kBaseTableLen;
   if (storage_size <= k64kEntriesStore * 2)
     return kBaseTableLen * 2;
   if (storage_size <= k64kEntriesStore * 4)
     return kBaseTableLen * 4;
   if (storage_size <= k64kEntriesStore * 8)
     return kBaseTableLen * 8;
 
@@ skipping 299 matching lines @@
 // ------------------------------------------------------------------------
 
 BackendImpl::BackendImpl(const FilePath& path,
                          base::MessageLoopProxy* cache_thread,
                          net::NetLog* net_log)
     : ALLOW_THIS_IN_INITIALIZER_LIST(background_queue_(this, cache_thread)),
       path_(path),
       block_files_(path),
       mask_(0),
       max_size_(0),
-      io_delay_(0),
+      up_ticks_(0),
       cache_type_(net::DISK_CACHE),
       uma_report_(0),
       user_flags_(0),
       init_(false),
       restarted_(false),
       unit_test_(false),
       read_only_(false),
       disabled_(false),
       new_eviction_(false),
       first_timer_(true),
       net_log_(net_log),
       done_(true, false),
       ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)) {
 }
 
 BackendImpl::BackendImpl(const FilePath& path,
                          uint32 mask,
                          base::MessageLoopProxy* cache_thread,
                          net::NetLog* net_log)
     : ALLOW_THIS_IN_INITIALIZER_LIST(background_queue_(this, cache_thread)),
       path_(path),
       block_files_(path),
       mask_(mask),
       max_size_(0),
-      io_delay_(0),
+      up_ticks_(0),
       cache_type_(net::DISK_CACHE),
       uma_report_(0),
       user_flags_(kMask),
       init_(false),
       restarted_(false),
       unit_test_(false),
       read_only_(false),
       disabled_(false),
       new_eviction_(false),
       first_timer_(true),
@@ skipping 562 matching lines @@
 }
 
 void BackendImpl::OnEntryDestroyBegin(Addr address) {
   EntriesMap::iterator it = open_entries_.find(address.value());
   if (it != open_entries_.end())
     open_entries_.erase(it);
 }
 
 void BackendImpl::OnEntryDestroyEnd() {
   DecreaseNumRefs();
-  if (data_->header.num_bytes > max_size_ && !read_only_)
+  if (data_->header.num_bytes > max_size_ && !read_only_ &&
+      (up_ticks_ > kTrimDelay || user_flags_ & disk_cache::kNoRandom))
     eviction_.TrimCache(false);
 }
 
 EntryImpl* BackendImpl::GetOpenEntry(CacheRankingsBlock* rankings) const {
   DCHECK(rankings->HasData());
   EntriesMap::const_iterator it =
       open_entries_.find(rankings->Data()->contents);
   if (it != open_entries_.end()) {
     // We have this entry in memory.
     return it->second;
@@ skipping 194 matching lines @@
     stats_.SetCounter(Stats::OPEN_ENTRIES, current);
     stats_.SetCounter(Stats::MAX_ENTRIES, max_refs_);
   }
 
   CACHE_UMA(COUNTS, "NumberOfReferences", 0, num_refs_);
 
   CACHE_UMA(COUNTS_10000, "EntryAccessRate", 0, entry_count_);
   CACHE_UMA(COUNTS, "ByteIORate", 0, byte_count_ / 1024);
   entry_count_ = 0;
   byte_count_ = 0;
+  if (up_ticks_ < kTrimDelay * 2)  // No need to count forever.

[gavinp, 2011/08/31 02:20:32]

Nit: Why not count forever?  Seems easier and less confusing.

[rvargas (doing something else), 2011/08/31 02:33:19]

Not easier because then I would have to either clamp the value or care about
integer overflows. To be fair, this is also a clamp, just at a lower value (so
few instructions saved). I could as easily change the constant to be kint32max
if you prefer it that way.

[gavinp, 2011/08/31 03:01:20]

I'm not convinced a clamp is necessary, because if I'm not missing something,
the overflow is about 2043 years, right?  Admittedly, since we use a signed int,
so after that we then would not evict cache entries for 2043 years + 5 minutes,
which is a long time, and so the disk would probably get full...

[rvargas (doing something else), 2011/08/31 18:06:35]

Convinced. Clamp gone.

+    up_ticks_++;
 
   if (!data_)
     first_timer_ = false;
   if (first_timer_) {
     first_timer_ = false;
     if (ShouldReportAgain())
       ReportStats();
   }
 
   // Save stats to disk at 5 min intervals.
@@ skipping 912 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache