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 527 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));
-    }
+    ReadInMemoryStreamData(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 && stream_1_prefetch_data_) {
+    ReadInMemoryStreamData(stream_1_prefetch_data_.get(), offset, buf_len, buf,

[pasko, 2017/07/11 13:24:12]

perhaps we could record how much time it takes to do so? this may help to reason
about speedups/slowdowns?

adding prefethes to netlog may be less trivial, though close to something my
inner perf nerd would put in a wishlist. WDYT?

also, record how much of stream data invalidation is happening?

[Maks Orlovich, 2017/07/11 14:34:06]

It's a memcpy? Doesn't sound that interesting... The Sync analogue may be more
important since that does CRC, at least. 
net_log_ isn't wired at SimpleSyncEntry, but we could log on this end at around
l.1162 if a separate event sounds interesting?
Hmm, maybe rather record prefetches done vs. prefetches read? That seems a
little easier to interpret, and also includes the case of data prefetched, not
used, but not actively invalidated (can happen e.g. in the cant_conditionalize
case).

[pasko, 2017/07/11 16:17:31]

sorry, wrong pointer, I was asking whether we can time the interval of
prefetching from disk.
Yeah, I was not sure whether you can provide a custom time interval to a netlog
..
Neat! I like it.

[Maks Orlovich, 2017/07/12 16:06:09]

It's not really a separate event, since it replaces all the disk I/O we would be
normally doing, so ... kinda?
Time interval? You kinda lost me here...

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

lulz :) I was writing it without knowing that you decided to read the whole file
first and then figure out which parts are which. So yeah, while it's a good fast
way, I should take back my attempts at measuring time it took to "read
potentially unnecessary parts".

So I guess I should say "Acknowledged".

Acknowledged

+                           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) {
     crc_request.reset(new SimpleSynchronousEntry::CRCRequest());
 
@@ skipping 71 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 184 matching lines @@
 
   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);
   }
+
+  if (in_results->stream_1_data.get()) {

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

almost a copy of the block above, perhaps make stream_data_ an array and
parametrize this?

[Maks Orlovich, 2017/07/28 17:27:35]

Done.

+    stream_1_prefetch_data_ = in_results->stream_1_data;
+    // The crc was read in SimpleSynchronousEntry.
+    crc_check_state_[1] = CRC_CHECK_DONE;
+    crc32s_[1] = in_results->stream_1_crc32;
+    crc32s_end_offset_[1] = in_results->entry_stat.data_size(1);
+  }
+
   // 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::ReadInMemoryStreamData(
+    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