RFC: use some in-memory state in SimpleCache to quickly cache-miss some CantConditionalize cases

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>
@@ skipping 42 matching lines @@
 
 namespace disk_cache {
 
 EntryMetadata::EntryMetadata()
   : last_used_time_seconds_since_epoch_(0),
     entry_size_(0) {
 }
 
 EntryMetadata::EntryMetadata(base::Time last_used_time,
                              base::StrictNumeric<uint32_t> entry_size)
-    : last_used_time_seconds_since_epoch_(0), entry_size_(entry_size) {
+    : last_used_time_seconds_since_epoch_(0), entry_size_(0) {
+  SetEntrySize(entry_size);  // to round/pack properly.
   SetLastUsedTime(last_used_time);
 }
 
 base::Time EntryMetadata::GetLastUsedTime() const {
   // Preserve nullity.
   if (last_used_time_seconds_since_epoch_ == 0)
     return base::Time();
 
   return base::Time::UnixEpoch() +
       base::TimeDelta::FromSeconds(last_used_time_seconds_since_epoch_);
 }
 
 void EntryMetadata::SetLastUsedTime(const base::Time& last_used_time) {
   // Preserve nullity.
   if (last_used_time.is_null()) {
     last_used_time_seconds_since_epoch_ = 0;
     return;
   }
 
   last_used_time_seconds_since_epoch_ = base::saturated_cast<uint32_t>(
       (last_used_time - base::Time::UnixEpoch()).InSeconds());
   // Avoid accidental nullity.
   if (last_used_time_seconds_since_epoch_ == 0)
     last_used_time_seconds_since_epoch_ = 1;
 }
 
 uint32_t EntryMetadata::GetEntrySize() const {
-  return entry_size_;
+  return entry_size_ & 0xFFFFFF00;

[jkarlin, 2017/06/08 14:44:06]

I'd rather add a byte (or a uint32_t even) to the index than hide a byte within
the existing struct. Hiding just complicates the code's logic and makes
GetEntrySize less precise.

+}
+
+uint8_t EntryMetadata::GetOracleByte() const {
+  return entry_size_ & 0xFF;
 }
 
 void EntryMetadata::SetEntrySize(base::StrictNumeric<uint32_t> entry_size) {
-  entry_size_ = entry_size;
+  uint8_t save_oracle_byte = GetOracleByte();
+  // ### what happens if we overflow here?
+  entry_size_ = ((static_cast<uint32_t>(entry_size) + 255) & 0xFFFFFF00) |
+                save_oracle_byte;
+}
+
+void EntryMetadata::SetOracleByte(uint8_t oracle_byte) {
+  uint32_t save_size = GetEntrySize();
+  entry_size_ = (save_size | oracle_byte);
 }
 
 void EntryMetadata::Serialize(base::Pickle* pickle) const {
   DCHECK(pickle);
   int64_t internal_last_used_time = GetLastUsedTime().ToInternalValue();
   // If you modify the size of the size of the pickle, be sure to update
   // kOnDiskSizeBytes.
   pickle->WriteInt64(internal_last_used_time);
   pickle->WriteUInt64(entry_size_);
 }
 
-bool EntryMetadata::Deserialize(base::PickleIterator* it) {
+bool EntryMetadata::Deserialize(base::PickleIterator* it,
+                                bool has_oracle_byte) {
   DCHECK(it);
   int64_t tmp_last_used_time;
   uint64_t tmp_entry_size;
   if (!it->ReadInt64(&tmp_last_used_time) || !it->ReadUInt64(&tmp_entry_size) ||
       tmp_entry_size > std::numeric_limits<decltype(entry_size_)>::max())
     return false;
   SetLastUsedTime(base::Time::FromInternalValue(tmp_last_used_time));
-  entry_size_ = static_cast<uint32_t>(tmp_entry_size);
+  if (has_oracle_byte) {
+    entry_size_ = static_cast<uint32_t>(tmp_entry_size);
+  } else {
+    SetEntrySize(static_cast<uint32_t>(tmp_entry_size));
+    SetOracleByte(0);
+  }
   return true;
 }
 
 SimpleIndex::SimpleIndex(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread,
     SimpleIndexDelegate* delegate,
     net::CacheType cache_type,
     std::unique_ptr<SimpleIndexFile> index_file)
     : delegate_(delegate),
       cache_type_(cache_type),
@@ skipping 148 matching lines @@
     removed_entries_.insert(entry_hash);
   PostponeWritingToDisk();
 }
 
 bool SimpleIndex::Has(uint64_t hash) const {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   // If not initialized, always return true, forcing it to go to the disk.
   return !initialized_ || entries_set_.count(hash) > 0;
 }
 
+bool SimpleIndex::HasWithOracleByte(uint64_t entry_hash, uint8_t* oracle_byte) {
+  EntrySet::iterator it = entries_set_.find(entry_hash);
+  if (it == entries_set_.end())
+    // If not initialized, always return true, forcing it to go to the disk.
+    return !initialized_;
+  *oracle_byte = it->second.GetOracleByte();
+  return true;
+}
+
 bool SimpleIndex::UseIfExists(uint64_t entry_hash) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   // Always update the last used time, even if it is during initialization.
   // It will be merged later.
   EntrySet::iterator it = entries_set_.find(entry_hash);
   if (it == entries_set_.end())
     // If not initialized, always return true, forcing it to go to the disk.
     return !initialized_;
   it->second.SetLastUsedTime(base::Time::Now());
   PostponeWritingToDisk();
@@ skipping 62 matching lines @@
   EntrySet::iterator it = entries_set_.find(entry_hash);
   if (it == entries_set_.end())
     return false;
 
   UpdateEntryIteratorSize(&it, entry_size);
   PostponeWritingToDisk();
   StartEvictionIfNeeded();
   return true;
 }
 
+void SimpleIndex::UpdateEntryOracleByte(uint64_t entry_hash,
+                                        uint8_t oracle_byte) {
+  DCHECK(io_thread_checker_.CalledOnValidThread());
+  EntrySet::iterator it = entries_set_.find(entry_hash);
+  if (it == entries_set_.end())
+    return;
+  it->second.SetOracleByte(oracle_byte);
+  PostponeWritingToDisk();
+}
+
 void SimpleIndex::EvictionDone(int result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
 
   // Ignore the result of eviction. We did our best.
   eviction_in_progress_ = false;
   SIMPLE_CACHE_UMA(BOOLEAN, "Eviction.Result", cache_type_, result == net::OK);
   SIMPLE_CACHE_UMA(TIMES,
                    "Eviction.TimeToDone", cache_type_,
                    base::TimeTicks::Now() - eviction_start_time_);
   SIMPLE_CACHE_UMA(
@@ skipping 27 matching lines @@
       FROM_HERE, base::TimeDelta::FromMilliseconds(delay), write_to_disk_cb_);
 }
 
 void SimpleIndex::UpdateEntryIteratorSize(
     EntrySet::iterator* it,
     base::StrictNumeric<uint32_t> entry_size) {
   // Update the total cache size with the new entry size.
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK_GE(cache_size_, (*it)->second.GetEntrySize());
   cache_size_ -= (*it)->second.GetEntrySize();
-  cache_size_ += static_cast<uint32_t>(entry_size);
   (*it)->second.SetEntrySize(entry_size);
+  // We use GetEntrySize to get consistent rounding.
+  cache_size_ += (*it)->second.GetEntrySize();
 }
 
 void SimpleIndex::MergeInitializingSet(
     std::unique_ptr<SimpleIndexLoadResult> load_result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(load_result->did_load);
 
   EntrySet* index_file_entries = &load_result->entries;
 
   for (std::unordered_set<uint64_t>::const_iterator it =
@@ skipping 89 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