Disk cache: Extend the internal buffering performed by each entry...

net/disk_cache/backend_impl.cc

 // Copyright (c) 2006-2010 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/field_trial.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
@@ skipping 447 matching lines @@
   bool create_files = false;
   if (!InitBackingStore(&create_files)) {
     ReportError(ERR_STORAGE_ERROR);
     return net::ERR_FAILED;
   }
 
   num_refs_ = num_pending_io_ = max_refs_ = 0;
   entry_count_ = byte_count_ = 0;
 
   if (!restarted_) {
+    buffer_bytes_ = 0;
     trace_object_ = TraceObject::GetTraceObject();
     // Create a recurrent timer of 30 secs.
     int timer_delay = unit_test_ ? 1000 : 30000;
     timer_.Start(TimeDelta::FromMilliseconds(timer_delay), this,
                  &BackendImpl::OnStatsTimer);
   }
 
   init_ = true;
 
   if (data_->header.experiment != 0 && cache_type_ != net::DISK_CACHE) {
@@ skipping 483 matching lines @@
     AddStorageSize(new_size - old_size);
 
   // Update the usage statistics.
   stats_.ModifyStorageStats(old_size, new_size);
 }
 
 void BackendImpl::TooMuchStorageRequested(int32 size) {
   stats_.ModifyStorageStats(0, size);
 }
 
+bool BackendImpl::IsAllocAllowed(int current_size, int new_size) {
+  DCHECK_GT(new_size, current_size);
+  int to_add = new_size - current_size;
+  if (buffer_bytes_ + to_add > MaxBuffersSize())
+    return false;
+
+  buffer_bytes_ += to_add;
+  HISTOGRAM_COUNTS("DiskCache.BufferBytes", buffer_bytes_ / 10);
+  return true;
+}
+
+void BackendImpl::BufferDeleted(int size) {
+  buffer_bytes_ -= size;
+  DCHECK_GE(size, 0);
+}
+
 bool BackendImpl::IsLoaded() const {
   CACHE_UMA(COUNTS, "PendingIO", GetSizeGroup(), num_pending_io_);
   if (user_flags_ & kNoLoadProtection)
     return false;
 
   return num_pending_io_ > 5;
 }
 
 std::string BackendImpl::HistogramName(const char* name, int experiment) const {
   if (!experiment)
@@ skipping 877 matching lines @@
   }
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->dummy;
 }
 
+int BackendImpl::MaxBuffersSize() {
+  static int64 total_memory = base::SysInfo::AmountOfPhysicalMemory();
+  static bool done = false;
+
+  if (!done) {
+    const int kMaxBuffersSize = 30 * 1024 * 1024;
+
+    // We want to use up to 2% of the computer's memory.
+    total_memory = total_memory * 2 / 100;

[gavinp, 2010/08/19 18:17:22]

How did you arrive at 2%?

[rvargas (doing something else), 2010/08/20 18:22:21]

From nowhere?. That seems like a reasonable number, but there is no real reason.
That's the same number used for the incognito cache, but with a lower limit.

+    if (total_memory > kMaxBuffersSize || total_memory <= 0)
+      total_memory = kMaxBuffersSize;
+
+    done = true;
+  }
+
+  return static_cast<int>(total_memory);
+}
+
 }  // namespace disk_cache