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

net/disk_cache/simple/simple_index.h

 // 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.
 
 #ifndef NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_H_
 
 #include <stdint.h>
 
 #include <list>
@@ skipping 40 matching lines @@
   base::Time GetLastUsedTime() const;
   void SetLastUsedTime(const base::Time& last_used_time);
 
   uint32_t RawTimeForSorting() const {
     return last_used_time_seconds_since_epoch_;
   }
 
   uint32_t GetEntrySize() const;
   void SetEntrySize(base::StrictNumeric<uint32_t> entry_size);
 
+  uint8_t GetMemoryEntryData() const { return memory_entry_data_; }
+  void SetMemoryEntryData(uint8_t val) { memory_entry_data_ = val; }
+
   // Serialize the data into the provided pickle.
   void Serialize(base::Pickle* pickle) const;
-  bool Deserialize(base::PickleIterator* it);
+  bool Deserialize(base::PickleIterator* it, bool has_memory_entry_data);
 
   static base::TimeDelta GetLowerEpsilonForTimeComparisons() {
     return base::TimeDelta::FromSeconds(1);
   }
   static base::TimeDelta GetUpperEpsilonForTimeComparisons() {
     return base::TimeDelta();
   }
 
   static const int kOnDiskSizeBytes = 16;
 
  private:
   friend class SimpleIndexFileTest;
 
   // There are tens of thousands of instances of EntryMetadata in memory, so the
   // size of each entry matters.  Even when the values used to set these members
   // are originally calculated as >32-bit types, the actual necessary size for
   // each shouldn't exceed 32 bits, so we use 32-bit types here.
   uint32_t last_used_time_seconds_since_epoch_;
-  uint32_t entry_size_;  // Storage size in bytes.
+  // Storage size in 256-byte blocks

[pasko, 2017/06/13 14:30:05]

4K blocks, if rounded upwards would probably be even more representative on how
much this occupies on the filesystem. WDYT?

[Maks Orlovich, 2017/06/13 14:58:47]

Hmm, maybe. Plus: it would also prevent things from changing again if we steal a
bit somewhere, and it's somewhat less arbitrary. 

OTOH, it would make cache utilization (even) less. 

@jkarlin: you know things about how cache size affects things, don't you?

+  uint32_t entry_size_ : 24;
+  uint8_t memory_entry_data_ : 8;

[pasko, 2017/06/13 14:30:05]

it would be cleaner to reserve one bit that says we did not loose the data
because of the issues with the index file. It will help with metrics and making
sure that bits set to 0 are meaningful sometimes.

[Maks Orlovich, 2017/06/13 14:58:47]

Hmm, maybe with a bool GetMemoryEntryData(uint64_t entry_hash, uint8_t* out)
const ? Could be, but I am worried about wasting bits. Really, 8 bits maybe too
much, but it makes for at least somewhat natural API.

 };
 static_assert(sizeof(EntryMetadata) == 8, "incorrect metadata size");
 
 // This class is not Thread-safe.
 class NET_EXPORT_PRIVATE SimpleIndex
     : public base::SupportsWeakPtr<SimpleIndex> {
  public:
   // Used in histograms. Please only add entries at the end.
   enum IndexInitMethod {
     INITIALIZE_METHOD_RECOVERED = 0,
@@ skipping 27 matching lines @@
   void Insert(uint64_t entry_hash);
   void Remove(uint64_t entry_hash);
 
   // Check whether the index has the entry given the hash of its key.
   bool Has(uint64_t entry_hash) const;
 
   // Update the last used time of the entry with the given key and return true
   // iff the entry exist in the index.
   bool UseIfExists(uint64_t entry_hash);
 
+  uint8_t GetMemoryEntryData(uint64_t entry_hash) const;
+  void SetMemoryEntryData(uint64_t entry_hash, uint8_t value);
+
   void WriteToDisk(IndexWriteToDiskReason reason);
 
   // Update the size (in bytes) of an entry, in the metadata stored in the
   // index. This should be the total disk-file size including all streams of the
   // entry.
   bool UpdateEntrySize(uint64_t entry_hash,
                        base::StrictNumeric<uint32_t> entry_size);
 
   using EntrySet = std::unordered_map<uint64_t, EntryMetadata>;
 
@@ skipping 105 matching lines @@
 
   // Set to true when the app is on the background. When the app is in the
   // background we can write the index much more frequently, to insure fresh
   // index on next startup.
   bool app_on_background_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_H_