SimpleCache: read small files all at once.

net/disk_cache/simple/simple_entry_impl.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_entry_impl.h"
 
 #include <algorithm>
 #include <cstring>
 #include <limits>
 #include <utility>
@@ skipping 161 matching lines @@
     OperationsMode operations_mode,
     SimpleBackendImpl* backend,
     net::NetLog* net_log)
     : cleanup_tracker_(std::move(cleanup_tracker)),
       backend_(backend->AsWeakPtr()),
       cache_type_(cache_type),
       worker_pool_(backend->worker_pool()),
       path_(path),
       entry_hash_(entry_hash),
       use_optimistic_operations_(operations_mode == OPTIMISTIC_OPERATIONS),
+      is_initial_stream1_read_(true),
       last_used_(Time::Now()),
       last_modified_(last_used_),
       sparse_data_size_(0),
       open_count_(0),
       doomed_(false),
       state_(STATE_UNINITIALIZED),
       synchronous_entry_(NULL),
       net_log_(
           net::NetLogWithSource::Make(net_log,
                                       net::NetLogSourceType::DISK_CACHE_ENTRY)),
@@ skipping 351 matching lines @@
   // I/O.  Therefore, CancelSparseIO and ReadyForSparseIO succeed instantly.
   return net::OK;
 }
 
 size_t SimpleEntryImpl::EstimateMemoryUsage() const {
   // TODO(xunjieli): crbug.com/669108. It'd be nice to have the rest of |entry|
   // measured, but the ownership of SimpleSynchronousEntry isn't straightforward
   return sizeof(SimpleSynchronousEntry) +
          base::trace_event::EstimateMemoryUsage(pending_operations_) +
          base::trace_event::EstimateMemoryUsage(executing_operation_) +
-         (stream_0_data_ ? stream_0_data_->capacity() : 0);
+         (stream_0_data_ ? stream_0_data_->capacity() : 0) +
+         (stream_1_prefetch_data_ ? stream_1_prefetch_data_->capacity() : 0);
 }
 
 SimpleEntryImpl::~SimpleEntryImpl() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(0U, pending_operations_.size());
   DCHECK(state_ == STATE_UNINITIALIZED || state_ == STATE_FAILURE);
   DCHECK(!synchronous_entry_);
   net_log_.EndEvent(net::NetLogEventType::SIMPLE_CACHE_ENTRY);
 }
 
@@ skipping 280 matching lines @@
     if (!callback.is_null())
       base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                     base::Bind(callback, 0));
     return;
   }
 
   buf_len = std::min(buf_len, GetDataSize(stream_index) - offset);
 
   // Since stream 0 data is kept in memory, it is read immediately.
   if (stream_index == 0) {
-    int ret_value = ReadStream0Data(buf, offset, buf_len);
-    if (!callback.is_null()) {
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(callback, ret_value));
+    ReadFromBufferAndPostReply(stream_0_data_.get(), offset, buf_len, buf,
+                               callback);
+    return;
+  }
+
+  // Sometimes we can read in-ram prefetched stream 1 data immediately, too.
+  if (stream_index == 1) {
+    if (is_initial_stream1_read_) {
+      SIMPLE_CACHE_UMA(BOOLEAN, "ReadStream1FromPrefetched", cache_type_,
+                       stream_1_prefetch_data_ != nullptr);
     }
-    return;
+    is_initial_stream1_read_ = false;
+
+    if (stream_1_prefetch_data_) {
+      ReadFromBufferAndPostReply(stream_1_prefetch_data_.get(), offset, buf_len,
+                                 buf, callback);
+      return;
+    }
   }
 
   state_ = STATE_IO_PENDING;
   if (!doomed_ && backend_.get())
     backend_->index()->UseIfExists(entry_hash_);
 
   // Figure out if we should be computing the checksum for this read,
   // and whether we should be verifying it, too.
   std::unique_ptr<SimpleSynchronousEntry::CRCRequest> crc_request;
   if (crc32s_end_offset_[stream_index] == offset) {
@@ skipping 73 matching lines @@
         base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                       base::Bind(callback, 0));
       }
       return;
     }
   }
   state_ = STATE_IO_PENDING;
   if (!doomed_ && backend_.get())
     backend_->index()->UseIfExists(entry_hash_);
 
+  // Any stream 1 write invalidates the prefetched data.
+  if (stream_index == 1)
+    stream_1_prefetch_data_ = nullptr;
+
   AdvanceCrc(buf, offset, buf_len, stream_index);
 
   // |entry_stat| needs to be initialized before modifying |data_size_|.
   std::unique_ptr<SimpleEntryStat> entry_stat(new SimpleEntryStat(
       last_used_, last_modified_, data_size_, sparse_data_size_));
   if (truncate) {
     data_size_[stream_index] = offset + buf_len;
   } else {
     data_size_[stream_index] = std::max(offset + buf_len,
                                         GetDataSize(stream_index));
@@ skipping 177 matching lines @@
     MakeUninitialized();
     return;
   }
   // If out_entry is NULL, it means we already called ReturnEntryToCaller from
   // the optimistic Create case.
   if (out_entry)
     ReturnEntryToCaller(out_entry);
 
   state_ = STATE_READY;
   synchronous_entry_ = in_results->sync_entry;
-  if (in_results->stream_0_data.get()) {
-    stream_0_data_ = in_results->stream_0_data;
-    // The crc was read in SimpleSynchronousEntry.
-    crc_check_state_[0] = CRC_CHECK_DONE;
-    crc32s_[0] = in_results->stream_0_crc32;
-    crc32s_end_offset_[0] = in_results->entry_stat.data_size(0);
+
+  // Copy over any pre-fetched data and its CRCs.
+  for (int stream = 0; stream < 2; ++stream) {
+    const SimpleStreamPrefetchData& prefetched =
+        in_results->stream_prefetch_data[stream];
+    if (prefetched.data.get()) {
+      if (stream == 0)
+        stream_0_data_ = prefetched.data;
+      else
+        stream_1_prefetch_data_ = prefetched.data;
+
+      // The crc was read in SimpleSynchronousEntry.
+      crc_check_state_[stream] = CRC_CHECK_DONE;
+      crc32s_[stream] = prefetched.stream_crc32;
+      crc32s_end_offset_[stream] = in_results->entry_stat.data_size(stream);
+    }
   }
+
   // If this entry was opened by hash, key_ could still be empty. If so, update
   // it with the key read from the synchronous entry.
   if (key_.empty()) {
     SetKey(synchronous_entry_->key());
   } else {
     // This should only be triggered when creating an entry. In the open case
     // the key is either copied from the arguments to open, or checked
     // in the synchronous entry.
     DCHECK_EQ(key_, synchronous_entry_->key());
   }
@@ skipping 275 matching lines @@
     } else {
       type = conflicting ? WRITE_FOLLOWS_CONFLICTING_WRITE
                          : WRITE_FOLLOWS_NON_CONFLICTING_WRITE;
     }
   }
   SIMPLE_CACHE_UMA(ENUMERATION,
                    "WriteDependencyType", cache_type_,
                    type, WRITE_DEPENDENCY_TYPE_MAX);
 }
 
-int SimpleEntryImpl::ReadStream0Data(net::IOBuffer* buf,
-                                     int offset,
-                                     int buf_len) {
+void SimpleEntryImpl::ReadFromBufferAndPostReply(
+    net::GrowableIOBuffer* in_buf,
+    int offset,
+    int buf_len,
+    net::IOBuffer* out_buf,
+    const CompletionCallback& callback) {
+  int rv;
   if (buf_len < 0) {
     RecordReadResult(cache_type_, READ_RESULT_SYNC_READ_FAILURE);
-    return 0;
+    rv = 0;
+  } else {
+    memcpy(out_buf->data(), in_buf->data() + offset, buf_len);
+    UpdateDataFromEntryStat(SimpleEntryStat(base::Time::Now(), last_modified_,
+                                            data_size_, sparse_data_size_));
+    RecordReadResult(cache_type_, READ_RESULT_SUCCESS);
+    rv = buf_len;
   }
-  memcpy(buf->data(), stream_0_data_->data() + offset, buf_len);
-  UpdateDataFromEntryStat(
-      SimpleEntryStat(base::Time::Now(), last_modified_, data_size_,
-                      sparse_data_size_));
-  RecordReadResult(cache_type_, READ_RESULT_SUCCESS);
-  return buf_len;
+  if (!callback.is_null()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  base::Bind(callback, rv));
+  }
 }
 
 int SimpleEntryImpl::SetStream0Data(net::IOBuffer* buf,
                                     int offset,
                                     int buf_len,
                                     bool truncate) {
   // Currently, stream 0 is only used for HTTP headers, and always writes them
   // with a single, truncating write. Detect these writes and record the size
   // changes of the headers. Also, support writes to stream 0 that have
   // different access patterns, as required by the API contract.
@@ skipping 46 matching lines @@
     }
     crc32s_end_offset_[stream_index] = offset + length;
   } else if (offset < crc32s_end_offset_[stream_index]) {
     // If a range for which the crc32 was already computed is rewritten, the
     // computation of the crc32 need to start from 0 again.
     crc32s_end_offset_[stream_index] = 0;
   }
 }
 
 }  // namespace disk_cache