evict larger entries first

net/disk_cache/simple/simple_index.cc

 // Copyright (c) 2013 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/simple/simple_index.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/pickle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/task_runner.h"
 #include "base/time/time.h"
 #include "base/trace_event/memory_usage_estimator.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
+#include "net/disk_cache/simple/simple_experiment.h"
 #include "net/disk_cache/simple/simple_histogram_macros.h"
 #include "net/disk_cache/simple/simple_index_delegate.h"
 #include "net/disk_cache/simple/simple_index_file.h"
 #include "net/disk_cache/simple/simple_synchronous_entry.h"
 #include "net/disk_cache/simple/simple_util.h"
 
 #if defined(OS_POSIX)
 #include <sys/stat.h>
 #include <sys/time.h>
 #endif
 
 namespace {
 
 // How many milliseconds we delay writing the index to disk since the last cache
 // operation has happened.
 const int kWriteToDiskDelayMSecs = 20000;
 const int kWriteToDiskOnBackgroundDelayMSecs = 100;
 
 // Divides the cache space into this amount of parts to evict when only one part
 // is left.
 const uint32_t kEvictionMarginDivisor = 20;
 
 const uint32_t kBytesInKb = 1024;
 
+// This is added to the size of each entry before using the size
+// to determine which entries to evict first. It's basically an
+// estimate of the filesystem overhead, but it also serves to flatten
+// the curve so that 1-byte entries and 2-byte entries are basically
+// treated the same.
+static const int kEstimatedEntryOverhead = 512;
+
 }  // namespace
 
 namespace disk_cache {
 
 EntryMetadata::EntryMetadata()
   : last_used_time_seconds_since_epoch_(0),
     entry_size_(0) {
 }
 
 EntryMetadata::EntryMetadata(base::Time last_used_time,
@@ skipping 240 matching lines @@
   eviction_in_progress_ = true;
   eviction_start_time_ = base::TimeTicks::Now();
   SIMPLE_CACHE_UMA(
       MEMORY_KB, "Eviction.CacheSizeOnStart2", cache_type_,
       static_cast<base::HistogramBase::Sample>(cache_size_ / kBytesInKb));
   SIMPLE_CACHE_UMA(
       MEMORY_KB, "Eviction.MaxCacheSizeOnStart2", cache_type_,
       static_cast<base::HistogramBase::Sample>(max_size_ / kBytesInKb));
 
   // Flatten for sorting.
-  std::vector<const std::pair<const uint64_t, EntryMetadata>*> entries;
+  using SortHelper = std::pair<uint64_t, const EntrySet::value_type*>;

[pasko, 2017/07/18 15:30:01]

It would be clearer with more concrete types and in one line:

std::vector<std::pair<uint64_t, const EntryMetadata*>> entries;

[hubbe, 2017/07/18 18:27:39]

I disagree, but will change it if you insist.

[pasko, 2017/07/19 14:42:28]

OK, after noting that the type I suggested was wrong, it indeed makes sense to
reference the value_type to hint that we are pointing at innards of the
entries_set_. Perhaps a short comment about that would clarify. Up to you.

However, still seeing 'SortHelper' as not useful, is it some common pattern that
makes things instantly more obvious for people?

[hubbe, 2017/07/19 17:50:33]

SortHelper was useful when the code was a lot more complicated.
It's not anymore, so I removed it.

+  std::vector<SortHelper> entries;
   entries.reserve(entries_set_.size());
+  uint32_t now = (base::Time::Now() - base::Time::UnixEpoch()).InSeconds();
+  bool use_size = false;
+  SimpleExperiment experiment = GetSimpleExperiment(cache_type_);
+  if (experiment.type == SimpleExperimentType::EVICT_WITH_SIZE &&
+      experiment.param) {

[pasko, 2017/07/18 15:30:01]

why do we need to check that param is non-zero? I thought the param is only for
being able to clear the cache when changing it ..

[hubbe, 2017/07/18 18:27:40]

If we don't check the param, how do we know if we're in the control group or
not?

[pasko, 2017/07/19 14:42:28]

Oh, I forgot, sorry, thank you for clarification. Clever.

+    use_size = true;
+  }
   for (EntrySet::const_iterator i = entries_set_.begin();
        i != entries_set_.end(); ++i) {
-    entries.push_back(&*i);
+    uint64_t sort_value = now - i->second.RawTimeForSorting();
+    if (use_size) {
+      // Will not overflow since we're multiplying two 32-bit values and storing
+      // them in a 64-bit variable.
+      sort_value *= i->second.GetEntrySize() + kEstimatedEntryOverhead;
+    }
+    // Subtract so we don't need a custom comparator.
+    entries.emplace_back(std::numeric_limits<uint64_t>::max() - sort_value,
+                         &*i);
   }
 
-  std::sort(entries.begin(), entries.end(),
-            [](const std::pair<const uint64_t, EntryMetadata>* a,
-               const std::pair<const uint64_t, EntryMetadata>* b) -> bool {
-              return a->second.RawTimeForSorting() <
-                     b->second.RawTimeForSorting();
-            });
-
-  // Remove as many entries from the index to get below |low_watermark_|,
-  // collecting least recently used hashes into |entry_hashes|.
+  uint64_t evicted_so_far_size = 0;
+  const uint64_t amount_to_evict = cache_size_ - low_watermark_;
   std::vector<uint64_t> entry_hashes;
-  std::vector<const std::pair<const uint64_t, EntryMetadata>*>::iterator it =
-      entries.begin();
-  uint64_t evicted_so_far_size = 0;
-  while (evicted_so_far_size < cache_size_ - low_watermark_) {
-    DCHECK(it != entries.end());
-    entry_hashes.push_back((*it)->first);
-    evicted_so_far_size += (*it)->second.GetEntrySize();
-    ++it;
+  auto begin = entries.begin();

[pasko, 2017/07/18 15:30:01]

something slightly shorter:

std::sort(std::begin(entries), std::end(entries));
for (const auto& score_metadata_pair : entries) {
  ...
}

Wow, I see that std::pair comparators are since C++14 [1], is it OK to use them?
Will it cause problems when building with GCC? I'm no expert here.

[1] http://en.cppreference.com/w/cpp/utility/pair/operator_cmp

[hubbe, 2017/07/18 18:27:39]

Done
No, it's been around for a little longer:
http://www.sgi.com/tech/stl/pair.html

[pasko, 2017/07/19 14:42:28]

Acknowledged. Thanks.

+  auto end = entries.end();
+  std::sort(begin, end);
+  for (auto i = begin; i < end; ++i) {
+    if (evicted_so_far_size >= amount_to_evict)
+      break;
+    evicted_so_far_size += i->second->second.GetEntrySize();
+    entry_hashes.push_back(i->second->first);
   }
 
   SIMPLE_CACHE_UMA(COUNTS_1M,
                    "Eviction.EntryCount", cache_type_, entry_hashes.size());
   SIMPLE_CACHE_UMA(TIMES,
                    "Eviction.TimeToSelectEntries", cache_type_,
                    base::TimeTicks::Now() - eviction_start_time_);
   SIMPLE_CACHE_UMA(
       MEMORY_KB, "Eviction.SizeOfEvicted2", cache_type_,
       static_cast<base::HistogramBase::Sample>(
@@ skipping 167 matching lines @@
                        start - last_write_to_disk_);
     }
   }
   last_write_to_disk_ = start;
 
   index_file_->WriteToDisk(reason, entries_set_, cache_size_, start,
                            app_on_background_, base::Closure());
 }
 
 }  // namespace disk_cache