[counters] Move waiting for more data from background-parsing into callbacks

src/parsing/scanner-character-streams.cc

 // Copyright 2011 the V8 project 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 "src/parsing/scanner-character-streams.h"
 
 #include "include/v8.h"
 #include "src/globals.h"
 #include "src/handles.h"
 #include "src/objects-inl.h"
@@ skipping 172 matching lines @@
 // Utf8ExternalStreamingStream - chunked streaming of Utf-8 data.
 //
 // This implementation is fairly complex, since data arrives in chunks which
 // may 'cut' arbitrarily into utf-8 characters. Also, seeking to a given
 // character position is tricky because the byte position cannot be dericed
 // from the character position.
 
 class Utf8ExternalStreamingStream : public BufferedUtf16CharacterStream {
  public:
   Utf8ExternalStreamingStream(
-      ScriptCompiler::ExternalSourceStream* source_stream)
+      ScriptCompiler::ExternalSourceStream* source_stream,
+      RuntimeCallStats* stats)
       : current_({0, {0, 0, unibrow::Utf8::Utf8IncrementalBuffer(0)}}),
-        source_stream_(source_stream) {}
+        source_stream_(source_stream),
+        stats_(stats) {}
   ~Utf8ExternalStreamingStream() override {
     for (size_t i = 0; i < chunks_.size(); i++) delete[] chunks_[i].data;
   }
 
  protected:
   size_t FillBuffer(size_t position) override;
 
  private:
   // A position within the data stream. It stores:
   // - The 'physical' position (# of bytes in the stream),
@@ skipping 28 matching lines @@
   void FillBufferFromCurrentChunk();
   // Fetch a new chunk (assuming current_ is at the end of the current data).
   bool FetchChunk();
   // Search through the chunks and set current_ to point to the given position.
   // (This call is potentially expensive.)
   void SearchPosition(size_t position);
 
   std::vector<Chunk> chunks_;
   Position current_;
   ScriptCompiler::ExternalSourceStream* source_stream_;
+  RuntimeCallStats* stats_;
 };
 
 bool Utf8ExternalStreamingStream::SkipToPosition(size_t position) {
   DCHECK_LE(current_.pos.chars, position);  // We can only skip forward.
 
   // Already there? Then return immediately.
   if (current_.pos.chars == position) return true;
 
   const Chunk& chunk = chunks_[current_.chunk_no];
   DCHECK(current_.pos.bytes >= chunk.start.bytes);
@@ skipping 70 matching lines @@
 
   current_.pos.bytes = chunk.start.bytes + it;
   current_.pos.chars += (cursor - buffer_end_);
   current_.pos.incomplete_char = incomplete_char;
   current_.chunk_no += (it == chunk.length);
 
   buffer_end_ = cursor;
 }
 
 bool Utf8ExternalStreamingStream::FetchChunk() {
+  RuntimeCallTimerScope scope(stats_, &RuntimeCallStats::GetMoreDataCallback);

[vogelheim, 2016/12/05 12:35:28]

Why does this compile without a new #include? I guess counters.h is included
somewhere from the include/v8.h or objects.h mega-headers?

Maybe in include-what-you-need fashion we should include this directly, in case
of later #include-cleanups?

   DCHECK_EQ(current_.chunk_no, chunks_.size());
   DCHECK(chunks_.empty() || chunks_.back().length != 0);
 
   const uint8_t* chunk = nullptr;
   size_t length = source_stream_->GetMoreData(&chunk);
   chunks_.push_back({chunk, length, current_.pos});
   return length > 0;
 }
 
 void Utf8ExternalStreamingStream::SearchPosition(size_t position) {
@@ skipping 111 matching lines @@
 
 typedef std::vector<struct Chunk> Chunks;
 
 void DeleteChunks(Chunks& chunks) {
   for (size_t i = 0; i < chunks.size(); i++) delete[] chunks[i].data;
 }
 
 // Return the chunk index for the chunk containing position.
 // If position is behind the end of the stream, the index of the last,
 // zero-length chunk is returned.
-size_t FindChunk(Chunks& chunks, ScriptCompiler::ExternalSourceStream* source_,
-                 size_t position) {
+size_t FindChunk(Chunks& chunks, ScriptCompiler::ExternalSourceStream* source,
+                 size_t position, RuntimeCallStats* stats) {
   size_t end_pos =
       chunks.empty() ? 0 : (chunks.back().byte_pos + chunks.back().byte_length);
 
   // Get more data if needed. We usually won't enter the loop body.
   bool out_of_data = !chunks.empty() && chunks.back().byte_length == 0;
-  while (!out_of_data && end_pos <= position + 1) {
-    const uint8_t* chunk = nullptr;
-    size_t len = source_->GetMoreData(&chunk);
+  {
+    RuntimeCallTimerScope scope(stats, &RuntimeCallStats::GetMoreDataCallback);
+    while (!out_of_data && end_pos <= position + 1) {
+      const uint8_t* chunk = nullptr;
+      size_t len = source->GetMoreData(&chunk);
 
-    chunks.push_back({chunk, len, end_pos});
-    end_pos += len;
-    out_of_data = (len == 0);
+      chunks.push_back({chunk, len, end_pos});
+      end_pos += len;
+      out_of_data = (len == 0);
+    }
   }
 
   // Here, we should always have at least one chunk, and we either have the
   // chunk we were looking for, or we're out of data. Also, out_of_data and
   // end_pos are current (and designate whether we have exhausted the stream,
   // and the length of data received so far, respectively).
   DCHECK(!chunks.empty());
   DCHECK_EQ(end_pos, chunks.back().byte_pos + chunks.back().byte_length);
   DCHECK_EQ(out_of_data, chunks.back().byte_length == 0);
   DCHECK(position < end_pos || out_of_data);
@@ skipping 20 matching lines @@
 }  // anonymous namespace
 
 // ----------------------------------------------------------------------------
 // OneByteExternalStreamingStream
 //
 // A stream of latin-1 encoded, chunked data.
 
 class OneByteExternalStreamingStream : public BufferedUtf16CharacterStream {
  public:
   explicit OneByteExternalStreamingStream(
-      ScriptCompiler::ExternalSourceStream* source)
-      : source_(source) {}
+      ScriptCompiler::ExternalSourceStream* source, RuntimeCallStats* stats)
+      : source_(source), stats_(stats) {}
   ~OneByteExternalStreamingStream() override { DeleteChunks(chunks_); }
 
  protected:
   size_t FillBuffer(size_t position) override;
 
  private:
   Chunks chunks_;
   ScriptCompiler::ExternalSourceStream* source_;
+  RuntimeCallStats* stats_;
 };
 
 size_t OneByteExternalStreamingStream::FillBuffer(size_t position) {
-  const Chunk& chunk = chunks_[FindChunk(chunks_, source_, position)];
+  const Chunk& chunk = chunks_[FindChunk(chunks_, source_, position, stats_)];
   if (chunk.byte_length == 0) return 0;
 
   size_t start_pos = position - chunk.byte_pos;
   size_t len = i::Min(kBufferSize, chunk.byte_length - start_pos);
   i::CopyCharsUnsigned(buffer_, chunk.data + start_pos, len);
   return len;
 }
 
 #if !(V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64)
 // ----------------------------------------------------------------------------
 // TwoByteExternalStreamingStream
 //
 // A stream of ucs-2 data, delivered in chunks. Chunks may be 'cut' into the
 // middle of characters (or even contain only one byte), which adds a bit
 // of complexity. This stream avoid all data copying, except for characters
 // that cross chunk boundaries.
 
 class TwoByteExternalStreamingStream : public Utf16CharacterStream {
  public:
   explicit TwoByteExternalStreamingStream(
-      ScriptCompiler::ExternalSourceStream* source);
+      ScriptCompiler::ExternalSourceStream* source, RuntimeCallStats* stats);
   ~TwoByteExternalStreamingStream() override;
 
  protected:
   bool ReadBlock() override;
 
   Chunks chunks_;
   ScriptCompiler::ExternalSourceStream* source_;
+  RuntimeCallStats* stats_;
   uc16 one_char_buffer_;
 };
 
 TwoByteExternalStreamingStream::TwoByteExternalStreamingStream(
-    ScriptCompiler::ExternalSourceStream* source)
+    ScriptCompiler::ExternalSourceStream* source, RuntimeCallStats* stats)
     : Utf16CharacterStream(&one_char_buffer_, &one_char_buffer_,
                            &one_char_buffer_, 0),
       source_(source),
+      stats_(stats),
       one_char_buffer_(0) {}
 
 TwoByteExternalStreamingStream::~TwoByteExternalStreamingStream() {
   DeleteChunks(chunks_);
 }
 
 bool TwoByteExternalStreamingStream::ReadBlock() {
   size_t position = pos();
 
   // We'll search for the 2nd byte of our character, to make sure we
   // have enough data for at least one character.
-  size_t chunk_no = FindChunk(chunks_, source_, 2 * position + 1);
+  size_t chunk_no = FindChunk(chunks_, source_, 2 * position + 1, stats_);
 
   // Out of data? Return 0.
   if (chunks_[chunk_no].byte_length == 0) {
     buffer_cursor_ = buffer_start_;
     buffer_end_ = buffer_start_;
     return false;
   }
 
   Chunk& current = chunks_[chunk_no];
 
@@ skipping 37 matching lines @@
   buffer_end_ = buffer_start_ + number_chars;
   buffer_pos_ = (current.byte_pos + odd_start) / 2;
   buffer_cursor_ = buffer_start_ + (position - buffer_pos_);
   DCHECK_EQ(position, pos());
   return true;
 }
 
 #else
 
 // ----------------------------------------------------------------------------
-// TwoByteExternalBufferedStream
+// woByteExternalBufferedStream

[Camillo Bruni, 2016/12/05 12:33:19]

Spurious change.

[vogelheim, 2016/12/05 12:35:28]

Huh? (Editing error, I guess?)

 //
 // This class is made specifically to address unaligned access to 16-bit data
 // in MIPS and ARM architectures. It replaces class
 // TwoByteExternalStreamingStream which in some cases does have unaligned
 // accesse to 16-bit data
 
 class TwoByteExternalBufferedStream : public Utf16CharacterStream {
  public:
   explicit TwoByteExternalBufferedStream(
-      ScriptCompiler::ExternalSourceStream* source);
+      ScriptCompiler::ExternalSourceStream* source, RuntimeCallStats* stats);
   ~TwoByteExternalBufferedStream();
 
  protected:
   static const size_t kBufferSize = 512;
 
   bool ReadBlock() override;
 
   // FillBuffer should read up to kBufferSize characters at position and store
   // them into buffer_[0..]. It returns the number of characters stored.
   size_t FillBuffer(size_t position, size_t chunk_no);
 
   // Fixed sized buffer that this class reads from.
   // The base class' buffer_start_ should always point to buffer_.
   uc16 buffer_[kBufferSize];
 
   Chunks chunks_;
   ScriptCompiler::ExternalSourceStream* source_;
+  RuntimeCallStats* stats_;
 };
 
 TwoByteExternalBufferedStream::TwoByteExternalBufferedStream(
-    ScriptCompiler::ExternalSourceStream* source)
-    : Utf16CharacterStream(buffer_, buffer_, buffer_, 0), source_(source) {}
+    ScriptCompiler::ExternalSourceStream* source, RuntimeCallStats* stats)
+    : Utf16CharacterStream(buffer_, buffer_, buffer_, 0),
+      source_(source),
+      stats_(stats) {}
 
 TwoByteExternalBufferedStream::~TwoByteExternalBufferedStream() {
   DeleteChunks(chunks_);
 }
 
 bool TwoByteExternalBufferedStream::ReadBlock() {
   size_t position = pos();
   // Find chunk in which the position belongs
-  size_t chunk_no = FindChunk(chunks_, source_, 2 * position + 1);
+  size_t chunk_no = FindChunk(chunks_, source_, 2 * position + 1, stats_);
 
   // Out of data? Return 0.
   if (chunks_[chunk_no].byte_length == 0) {
     buffer_cursor_ = buffer_start_;
     buffer_end_ = buffer_start_;
     return false;
   }
 
   Chunk& current = chunks_[chunk_no];
 
@@ skipping 25 matching lines @@
 }
 
 size_t TwoByteExternalBufferedStream::FillBuffer(size_t position,
                                                  size_t chunk_no) {
   DCHECK_EQ(chunks_[chunk_no].byte_pos % 2, 1u);
   bool odd_start = true;
   // Align buffer_pos_ to the size of the buffer.
   {
     size_t new_pos = position / kBufferSize * kBufferSize;
     if (new_pos != position) {
-      chunk_no = FindChunk(chunks_, source_, 2 * new_pos + 1);
+      chunk_no = FindChunk(chunks_, source_, 2 * new_pos + 1, stats_);
       buffer_pos_ = new_pos;
       buffer_cursor_ = buffer_start_ + (position - buffer_pos_);
       position = new_pos;
       odd_start = chunks_[chunk_no].byte_pos % 2;
     }
   }
 
   Chunk* current = &chunks_[chunk_no];
 
   // Annoying edge case: Chunks may not be 2-byte aligned, meaning that a
@@ skipping 21 matching lines @@
   size_t bytes_to_move =
       i::Min(2 * kBufferSize - lonely_byte,
              current->byte_length - 2 * chunk_pos + start_offset);
   i::MemMove(reinterpret_cast<uint8_t*>(buffer_) + lonely_byte,
              current->data + 2 * chunk_pos - start_offset, bytes_to_move);
 
   // Fill up the rest of the buffer if there is space and data left.
   totalLength += bytes_to_move;
   position = (current->byte_pos + current->byte_length) / 2;
   if (position - buffer_pos_ < kBufferSize) {
-    chunk_no = FindChunk(chunks_, source_, 2 * position + 1);
+    chunk_no = FindChunk(chunks_, source_, 2 * position + 1, stats_);
     current = &chunks_[chunk_no];
     odd_start = current->byte_pos % 2;
     bytes_to_move = i::Min(2 * kBufferSize - totalLength, current->byte_length);
     while (bytes_to_move) {
       // Common case: character is in current chunk.
       DCHECK_LE(current->byte_pos, 2 * position + odd_start);
       DCHECK_LT(2 * position + 1, current->byte_pos + current->byte_length);
 
       i::MemMove(reinterpret_cast<uint8_t*>(buffer_) + totalLength,
                  current->data, bytes_to_move);
       totalLength += bytes_to_move;
       position = (current->byte_pos + current->byte_length) / 2;
-      chunk_no = FindChunk(chunks_, source_, 2 * position + 1);
+      chunk_no = FindChunk(chunks_, source_, 2 * position + 1, stats_);
       current = &chunks_[chunk_no];
       odd_start = current->byte_pos % 2;
       bytes_to_move =
           i::Min(2 * kBufferSize - totalLength, current->byte_length);
     }
   }
   return totalLength / 2;
 }
 #endif
 
@@ skipping 26 matching lines @@
 }
 
 std::unique_ptr<Utf16CharacterStream> ScannerStream::ForTesting(
     const char* data, size_t length) {
   return std::unique_ptr<Utf16CharacterStream>(
       new ExternalOneByteStringUtf16CharacterStream(data, length));
 }
 
 Utf16CharacterStream* ScannerStream::For(
     ScriptCompiler::ExternalSourceStream* source_stream,
-    v8::ScriptCompiler::StreamedSource::Encoding encoding) {
+    v8::ScriptCompiler::StreamedSource::Encoding encoding,
+    RuntimeCallStats* stats) {
   switch (encoding) {
     case v8::ScriptCompiler::StreamedSource::TWO_BYTE:
 #if !(V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64)
-      return new TwoByteExternalStreamingStream(source_stream);
+      return new TwoByteExternalStreamingStream(source_stream, stats);
 #else
-      return new TwoByteExternalBufferedStream(source_stream);
+      return new TwoByteExternalBufferedStream(source_stream, stats);
 #endif
     case v8::ScriptCompiler::StreamedSource::ONE_BYTE:
-      return new OneByteExternalStreamingStream(source_stream);
+      return new OneByteExternalStreamingStream(source_stream, stats);
     case v8::ScriptCompiler::StreamedSource::UTF8:
-      return new Utf8ExternalStreamingStream(source_stream);
+      return new Utf8ExternalStreamingStream(source_stream, stats);
   }
   UNREACHABLE();
   return nullptr;
 }
 
 }  // namespace internal
 }  // namespace v8