lazy allocation and early release memory in QuicStreamSequencerBuffer. Protected by --quic_reduce_s…

net/quic/core/quic_stream_sequencer_buffer.cc

 // Copyright (c) 2015 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/quic/core/quic_stream_sequencer_buffer.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_flags.h"
@@ skipping 29 matching lines @@
 
 QuicStreamSequencerBuffer::FrameInfo::FrameInfo(size_t length,
                                                 QuicTime timestamp)
     : length(length), timestamp(timestamp) {}
 
 QuicStreamSequencerBuffer::QuicStreamSequencerBuffer(size_t max_capacity_bytes)
     : max_buffer_capacity_bytes_(max_capacity_bytes),
       blocks_count_(
           ceil(static_cast<double>(max_capacity_bytes) / kBlockSizeBytes)),
       total_bytes_read_(0),
-      blocks_(blocks_count_) {
+      reduce_sequencer_buffer_memory_life_time_(
+          FLAGS_quic_reduce_sequencer_buffer_memory_life_time),  // NOLINT
+      blocks_(reduce_sequencer_buffer_memory_life_time_
+                  ? nullptr
+                  : new BufferBlock*[blocks_count_]()) {
   Clear();
 }
 
 QuicStreamSequencerBuffer::~QuicStreamSequencerBuffer() {
   Clear();
 }
 
 void QuicStreamSequencerBuffer::Clear() {
-  for (size_t i = 0; i < blocks_count_; ++i) {
-    if (blocks_[i] != nullptr) {
-      RetireBlock(i);
+  if (!reduce_sequencer_buffer_memory_life_time_ || blocks_ != nullptr) {
+    for (size_t i = 0; i < blocks_count_; ++i) {
+      if (blocks_[i] != nullptr) {
+        RetireBlock(i);
+      }
     }
   }
   num_bytes_buffered_ = 0;
   // Reset gaps_ so that buffer is in a state as if all data before
   // total_bytes_read_ has been consumed, and those after total_bytes_read_
   // has never arrived.
   gaps_ = std::list<Gap>(
       1, Gap(total_bytes_read_, std::numeric_limits<QuicStreamOffset>::max())),
   frame_arrival_time_map_.clear();
 }
@@ skipping 90 matching lines @@
 
     size_t block_capacity = GetBlockCapacity(write_block_num);
     size_t bytes_avail = block_capacity - write_block_offset;
 
     // If this write meets the upper boundary of the buffer,
     // reduce the available free bytes.
     if (offset + bytes_avail > total_bytes_read_ + max_buffer_capacity_bytes_) {
       bytes_avail = total_bytes_read_ + max_buffer_capacity_bytes_ - offset;
     }
 
+    if (reduce_sequencer_buffer_memory_life_time_ && blocks_ == nullptr) {
+      blocks_.reset(new BufferBlock*[blocks_count_]());
+      for (size_t i = 0; i < blocks_count_; ++i) {
+        blocks_[i] = nullptr;
+      }
+    }
+
     if (blocks_[write_block_num] == nullptr) {
       // TODO(danzh): Investigate if using a freelist would improve performance.
       // Same as RetireBlock().
       blocks_[write_block_num] = new BufferBlock();
     }
 
     const size_t bytes_to_copy = min<size_t>(bytes_avail, source_remaining);
     char* dest = blocks_[write_block_num]->buffer + write_block_offset;
     DVLOG(1) << "Write at offset: " << offset << " length: " << bytes_to_copy;
     memcpy(dest, source, bytes_to_copy);
@@ skipping 204 matching lines @@
   return true;
 }
 
 size_t QuicStreamSequencerBuffer::FlushBufferedFrames() {
   size_t prev_total_bytes_read = total_bytes_read_;
   total_bytes_read_ = gaps_.back().begin_offset;
   Clear();
   return total_bytes_read_ - prev_total_bytes_read;
 }
 
+void QuicStreamSequencerBuffer::ReleaseWholeBuffer() {
+  if (!reduce_sequencer_buffer_memory_life_time_) {
+    // Don't release buffer if flag is off.
+    return;
+  }
+  Clear();
+  blocks_.reset(nullptr);
+}
+
 size_t QuicStreamSequencerBuffer::ReadableBytes() const {
   return gaps_.front().begin_offset - total_bytes_read_;
 }
 
 bool QuicStreamSequencerBuffer::HasBytesToRead() const {
   return ReadableBytes() > 0;
 }
 
 QuicStreamOffset QuicStreamSequencerBuffer::BytesConsumed() const {
   return total_bytes_read_;
@@ skipping 111 matching lines @@
     QuicStreamOffset current_frame_begin_offset = it.first;
     QuicStreamOffset current_frame_end_offset =
         it.second.length + current_frame_begin_offset;
     current_frames_string +=
         RangeDebugString(current_frame_begin_offset, current_frame_end_offset);
   }
   return current_frames_string;
 }
 
 }  //  namespace net