SimpleCache: read small files all at once.

net/disk_cache/simple/simple_synchronous_entry.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_SYNCHRONOUS_ENTRY_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_
 
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 61 matching lines @@
   int32_t data_size_[kSimpleEntryStreamCount];
   int32_t sparse_data_size_;
 };
 
 struct SimpleEntryCreationResults {
   explicit SimpleEntryCreationResults(SimpleEntryStat entry_stat);
   ~SimpleEntryCreationResults();
 
   SimpleSynchronousEntry* sync_entry;
   scoped_refptr<net::GrowableIOBuffer> stream_0_data;
+
+  // |stream_1_data| may be null (in which case stream_1_crc32 will be unset)
+  scoped_refptr<net::GrowableIOBuffer> stream_1_data;
   SimpleEntryStat entry_stat;
   uint32_t stream_0_crc32;
+  uint32_t stream_1_crc32;

[pasko, 2017/07/18 13:46:31]

are you packing this to make the sizeof(SimpleEntryCreationResults) smaller? I
think saving a few bytes is not important here, while readability would improve
if we group the data and the crc fields together, possibly wrapped in a separate
struct.

[Maks Orlovich, 2017/07/21 18:37:34]

Done.

   int result;
 };
 
 // Worker thread interface to the very simple cache. This interface is not
 // thread safe, and callers must ensure that it is only ever accessed from
 // a single thread between synchronization points.
 class SimpleSynchronousEntry {
  public:
   struct CRCRecord {
     CRCRecord();
@@ skipping 89 matching lines @@
                 CRCRequest* crc_request,
                 SimpleEntryStat* entry_stat,
                 net::IOBuffer* out_buf,
                 int* out_result);
   void WriteData(const EntryOperationData& in_entry_op,
                  net::IOBuffer* in_buf,
                  SimpleEntryStat* out_entry_stat,
                  int* out_result);
   int CheckEOFRecord(int index,
                      const SimpleEntryStat& entry_stat,
-                     uint32_t expected_crc32) const;
+                     uint32_t expected_crc32);
 
   void ReadSparseData(const EntryOperationData& in_entry_op,
                       net::IOBuffer* out_buf,
                       base::Time* out_last_used,
                       int* out_result);
   void WriteSparseData(const EntryOperationData& in_entry_op,
                        net::IOBuffer* in_buf,
                        uint64_t max_sparse_data_size,
                        SimpleEntryStat* out_entry_stat,
                        int* out_result);
@@ skipping 71 matching lines @@
 
   // Read the header and key at the beginning of the file, and validate that
   // they are correct. If this entry was opened with a key, the key is checked
   // for a match. If not, then the |key_| member is set based on the value in
   // this header. Records histograms if any check is failed.
   bool CheckHeaderAndKey(int file_index);
 
   // Returns a net error, i.e. net::OK on success.
   int InitializeForOpen(SimpleEntryStat* out_entry_stat,
                         scoped_refptr<net::GrowableIOBuffer>* stream_0_data,
-                        uint32_t* out_stream_0_crc32);
+                        uint32_t* out_stream_0_crc32,
+                        scoped_refptr<net::GrowableIOBuffer>* stream_1_data,
+                        uint32_t* out_stream_1_crc32);
 
   // Writes the header and key to a newly-created stream file. |index| is the
   // index of the stream. Returns true on success; returns false and sets
   // |*out_result| on failure.
   bool InitializeCreatedFile(int index, CreateEntryResult* out_result);
 
   // Returns a net error, including net::OK on success and net::FILE_EXISTS
   // when the entry already exists.
   int InitializeForCreate(SimpleEntryStat* out_entry_stat);
 
   // Allocates and fills a buffer with stream 0 data in |stream_0_data|, then
-  // checks its crc32.
+  // checks its crc32. May also optionally read in |stream_1_data| and its
+  // crc, but might decide not to.
   int ReadAndValidateStream0(
       int file_size,
       SimpleEntryStat* out_entry_stat,
       scoped_refptr<net::GrowableIOBuffer>* stream_0_data,
-      uint32_t* out_stream_0_crc32);
+      uint32_t* out_stream_0_crc32,
+      scoped_refptr<net::GrowableIOBuffer>* stream_1_data,
+      uint32_t* out_stream_1_crc32);
 
-  int GetEOFRecordData(int index,
+  // Reads the EOF record for stream |stream_index| from the appropriate file,
+  // or in memory prefetched version in [prefetch_buf, prefetch_buf + file_size)
+  // using |entry_stat| for layout info, and putting result into
+  // |*eof_record|. Sanity-checks the result.
+  // Returns net status, and records any failures to UMA.
+  //
+  // Note that non-null |prefetch_buf| may only be specified if stream_index is
+  // 0 or 1.
+  int GetEOFRecordData(char* prefetch_buf,
+                       int file_size,
+                       int stream_index,
                        const SimpleEntryStat& entry_stat,
-                       bool* out_has_crc32,
-                       bool* out_has_key_sha256,
-                       uint32_t* out_crc32,
-                       int32_t* out_data_size) const;
+                       SimpleFileEOF* eof_record);
+
+  // Reads either from |prefetch_buf| --- if that's not null --- or files_[0].
+  // Range-checks all the in-memory reads.
+  bool ReadFromFileOrPrefetched(char* prefetch_buf,
+                                int file_size,
+                                int offset,
+                                int size,
+                                char* dest);
+
+  // Extracts out the payload of stream |stream_index|, reading either from
+  // [prefetch_buf, prefetch_buf + file_size), if |prefetch_buf| is non-null,
+  // or the file. |entry_stat| will be used to determine file layout, though
+  // |extra_size| additional bytes will be read past the stream payload end.
+  //
+  // |*stream_data| will be pointed to a fresh buffer with the results,
+  // and |*out_crc32| will get the checksum, which will be verified against
+  // |eof_record|.
+  int PreReadStreamPayload(char* prefetch_buf,
+                           int file_size,
+                           int stream_index,
+                           int extra_size,
+                           const SimpleEntryStat& entry_stat,
+                           const SimpleFileEOF& eof_record,
+                           scoped_refptr<net::GrowableIOBuffer>* stream_data,
+                           uint32_t* out_crc32);
+
   void Doom() const;
 
   // Opens the sparse data file and scans it if it exists.
   bool OpenSparseFileIfExists(int32_t* out_sparse_data_size);
 
   // Creates and initializes the sparse data file.
   bool CreateSparseFile();
 
   // Closes the sparse data file.
   void CloseSparseFile();
@@ skipping 69 matching lines @@
   int64_t sparse_tail_offset_;
 
   // True if the entry was created, or false if it was opened. Used to log
   // SimpleCache.*.EntryCreatedWithStream2Omitted only for created entries.
   bool files_created_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_