New disk cache eviction algorithm.

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 34 matching lines @@
 //
 // 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__
+#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 = 0x20000;  // Version 2.0.
 
 struct LruData {
+  int32     pad1[3];
+  int32     sizes[5];
   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];
+  int32     pad2[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       crash;         // Signals a previous crash.
   int32       experiment;    // Id of an ongoing test.
-  int32       pad[62];
+  int32       pad[54];
   LruData     lru;           // Eviction control data.
   IndexHeader() {
     memset(this, 0, sizeof(*this));
     magic = kIndexMagic;
     version = kCurrentVersion;
   };
 };
 
 // The structure of the whole index file.
 struct Index {
@@ skipping 81 matching lines @@
     memset(this, 0, sizeof(BlockFileHeader));
     magic = kBlockMagic;
     version = kCurrentVersion;
   };
 };
 
 COMPILE_ASSERT(sizeof(BlockFileHeader) == kBlockHeaderSize, bad_header);
 
 }  // namespace disk_cache
 
-#endif  // NET_DISK_CACHE_DISK_FORMAT_H__
+#endif  // NET_DISK_CACHE_DISK_FORMAT_H_