Disk cache: Add support for an extra data stream for each cache entry....

net/disk_cache/disk_format.h

 // Copyright (c) 2006-2008 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.
 
 // The cache is stored on disk as a collection of block-files, plus an index
 // file plus a collection of external files.
 //
 // Any data blob bigger than kMaxBlockSize (net/addr.h) will be stored on a
 // separate file named f_xxx where x is a hexadecimal number. Shorter data will
 // be stored as a series of blocks on a block-file. In any case, CacheAddr
@@ skipping 18 matching lines @@
 // number and starting block inside the file.
 //
 // A new cache is initialized with four block files (named data_0 through
 // data_3), each one dedicated to store blocks of a given size. The number at
 // the end of the file name is the block file number (in decimal).
 //
 // There are two "special" types of blocks: an entry and a rankings node. An
 // entry keeps track of all the information related to the same cache entry,
 // such as the key, hash value, data pointers etc. A rankings node keeps track
 // of the information that is updated frequently for a given entry, such as its
-// location on the LRU list, last access time etc.
+// location on the LRU lists, last access time etc.
 //
 // The files that store internal information for the cache (blocks and index)
 // are at least partially memory mapped. They have a location that is signaled
 // every time the internal structures are modified, so it is possible to detect
 // (most of the time) when the process dies in the middle of an update.
 //
 // In order to prevent dirty data to be used as valid (after a crash), every
 // cache entry has a dirty identifier. Each running instance of the cache keeps
 // a separate identifier (maintained on the "this_id" header field) that is used
 // to mark every entry that is created or modified. When the entry is closed,
 // and all the data can be trusted, the dirty flag is cleared from the entry.
 // When the cache encounters an entry whose identifier is different than the one
 // being currently used, it means that the entry was not properly closed on a
 // previous run, so it is discarded.
 
 #ifndef NET_DISK_CACHE_DISK_FORMAT_H__
 #define NET_DISK_CACHE_DISK_FORMAT_H__
 
 #include "base/basictypes.h"
 
 namespace disk_cache {
 
 typedef uint32 CacheAddr;
 
 const int kIndexTablesize = 0x10000;
 const uint32 kIndexMagic = 0xC103CAC3;
-const uint32 kCurrentVersion = 0x10003;  // Version 1.3.
+const uint32 kCurrentVersion = 0x20000;  // Version 2.0.
+
+struct LruData {
+  CacheAddr heads[5];
+  CacheAddr tails[5];
+  CacheAddr transaction;     // In-flight operation target.
+  int32     operation;       // Actual in-flight operation.
+  int32     operation_list;  // In-flight operation list.
+  int32     pad[7];
+};
 
 // Header for the master index file.
 struct IndexHeader {
   uint32      magic;
   uint32      version;
   int32       num_entries;   // Number of entries currently stored.
   int32       num_bytes;     // Total size of the stored data.
   int32       last_file;     // Last external file created.
   int32       this_id;       // Id for all entries being changed (dirty flag).
   CacheAddr   stats;         // Storage for usage data.
   int32       table_len;     // Actual size of the table (0 == kIndexTablesize).
-  int32       pad[8];
+  int32       pad[64];
+  LruData     lru;           // Eviction control data.
   IndexHeader() {
     memset(this, 0, sizeof(*this));
     magic = kIndexMagic;
     version = kCurrentVersion;
   };
 };
 
 // The structure of the whole index file.
 struct Index {
   IndexHeader header;
   CacheAddr   table[kIndexTablesize];  // Default size. Actual size controlled
                                        // by header.table_len.
 };
 
 // Main structure for an entry on the backing storage. If the key is longer than
 // what can be stored on this structure, it will be extended on consecutive
 // blocks (adding 256 bytes each time), up to 4 blocks (1024 - 32 - 1 chars).
 // After that point, the whole key will be stored as a data block or external
 // file.
 struct EntryStore {
   uint32      hash;               // Full hash of the key.
   CacheAddr   next;               // Next entry with the same hash or bucket.
   CacheAddr   rankings_node;      // Rankings node for this entry.
+  int32       reuse_count;        // How often is this entry used.
+  int32       refetch_count;      // How often is this fetched from the net.
+  int32       state;              // Current state.
+  uint64      creation_time;
   int32       key_len;
   CacheAddr   long_key;           // Optional address of a long key.
-  int32       data_size[2];       // We can store up to 2 data chunks for each
-  CacheAddr   data_addr[2];       // entry.
-  char        key[256 - 9 * 4];   // null terminated
+  int32       data_size[4];       // We can store up to 4 data streams for each
+  CacheAddr   data_addr[4];       // entry.
+  int32       pad[6];
+  char        key[256 - 24 * 4];  // null terminated
 };
 
 COMPILE_ASSERT(sizeof(EntryStore) == 256, bad_EntyStore);
 const int kMaxInternalKeyLength = 4 * sizeof(EntryStore) -
                                   offsetof(EntryStore, key) - 1;
 
+// Possible states for a given entry.
+enum EntryState {
+  ENTRY_NORMAL = 0,
+  ENTRY_EVICTED,    // The entry was recently evicted from the cache.
+  ENTRY_DOOMED      // The entry was doomed.
+};
+
 #pragma pack(push, old, 4)
 // Rankings information for a given entry.
 struct RankingsNode {
   uint64      last_used;        // LRU info.
   uint64      last_modified;    // LRU info.
   CacheAddr   next;             // LRU list.
   CacheAddr   prev;             // LRU list.
   CacheAddr   contents;         // Address of the EntryStore.
   int32       dirty;            // The entry is being modifyied.
   void*       pointer;          // Pointer to the in-memory entry.
@@ skipping 36 matching lines @@
     version = kCurrentVersion;
   };
 };
 
 COMPILE_ASSERT(sizeof(BlockFileHeader) == kBlockHeaderSize, bad_header);
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_DISK_FORMAT_H__