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

net/quic/core/quic_stream_sequencer_buffer_test.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 <algorithm>
 #include <limits>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 42 matching lines @@
     QuicStreamSequencerBuffer::kBlockSizeBytes;
 typedef QuicStreamSequencerBuffer::BufferBlock BufferBlock;
 typedef QuicStreamSequencerBuffer::Gap Gap;
 typedef QuicStreamSequencerBuffer::FrameInfo FrameInfo;
 
 class QuicStreamSequencerBufferPeer {
  public:
   explicit QuicStreamSequencerBufferPeer(QuicStreamSequencerBuffer* buffer)
       : buffer_(buffer) {}
 
-  // Read from this buffer_->into the given destination buffer_-> up to the
+  // Read from this buffer_ into the given destination buffer_ up to the
   // size of the destination. Returns the number of bytes read. Reading from
   // an empty buffer_->returns 0.
   size_t Read(char* dest_buffer, size_t size) {
     iovec dest;
     dest.iov_base = dest_buffer, dest.iov_len = size;
     return buffer_->Readv(&dest, 1);
   }
 
   // If buffer is empty, the blocks_ array must be empty, which means all
   // blocks are deallocated.
   bool CheckEmptyInvariants() {
     return !buffer_->Empty() || IsBlockArrayEmpty();
   }
 
   bool IsBlockArrayEmpty() {
+    if (FLAGS_quic_reduce_sequencer_buffer_memory_life_time &&  // NOLINT
+        buffer_->blocks_ == nullptr) {
+      return true;
+    }
+
     size_t count = buffer_->blocks_count_;
     for (size_t i = 0; i < count; i++) {
       if (buffer_->blocks_[i] != nullptr) {
         return false;
       }
     }
     return true;
   }
 
   bool CheckInitialState() {
@@ skipping 54 matching lines @@
   std::map<QuicStreamOffset, FrameInfo>* frame_arrival_time_map() {
     return &(buffer_->frame_arrival_time_map_);
   }
 
   void set_total_bytes_read(QuicStreamOffset total_bytes_read) {
     buffer_->total_bytes_read_ = total_bytes_read;
   }
 
   void set_gaps(const std::list<Gap>& gaps) { buffer_->gaps_ = gaps; }
 
+  bool IsBufferAllocated() { return buffer_->blocks_ != nullptr; }
+
  private:
   QuicStreamSequencerBuffer* buffer_;
 };
 
 namespace {
 
 class QuicStreamSequencerBufferTest : public testing::Test {
  public:
   void SetUp() override { Initialize(); }
 
@@ skipping 38 matching lines @@
 
 TEST_F(QuicStreamSequencerBufferTest, OnStreamData0length) {
   size_t written;
   QuicErrorCode error = buffer_->OnStreamData(800, "", clock_.ApproximateNow(),
                                               &written, &error_details_);
   EXPECT_EQ(error, QUIC_EMPTY_STREAM_FRAME_NO_FIN);
   EXPECT_TRUE(helper_->CheckBufferInvariants());
 }
 
 TEST_F(QuicStreamSequencerBufferTest, OnStreamDataWithinBlock) {
+  if (FLAGS_quic_reduce_sequencer_buffer_memory_life_time) {  // NOLINT
+    EXPECT_FALSE(helper_->IsBufferAllocated());
+  }
   string source(1024, 'a');
   size_t written;
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
   QuicTime t = clock_.ApproximateNow();
   EXPECT_EQ(QUIC_NO_ERROR,
             buffer_->OnStreamData(800, source, t, &written, &error_details_));
   BufferBlock* block_ptr = helper_->GetBlock(0);
   for (size_t i = 0; i < source.size(); ++i) {
     ASSERT_EQ('a', block_ptr->buffer[helper_->GetInBlockOffset(800) + i]);
   }
   EXPECT_EQ(2, helper_->GapSize());
   std::list<Gap> gaps = helper_->GetGaps();
   EXPECT_EQ(800u, gaps.front().end_offset);
   EXPECT_EQ(1824u, gaps.back().begin_offset);
   auto* frame_map = helper_->frame_arrival_time_map();
   EXPECT_EQ(1u, frame_map->size());
   EXPECT_EQ(800u, frame_map->begin()->first);
   EXPECT_EQ(t, (*frame_map)[800].timestamp);
   EXPECT_TRUE(helper_->CheckBufferInvariants());
+  EXPECT_TRUE(helper_->IsBufferAllocated());
 }
 
 TEST_F(QuicStreamSequencerBufferTest, OnStreamDataWithOverlap) {
   string source(1024, 'a');
   // Write something into [800, 1824)
   size_t written;
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
   QuicTime t1 = clock_.ApproximateNow();
   EXPECT_EQ(QUIC_NO_ERROR,
             buffer_->OnStreamData(800, source, t1, &written, &error_details_));
@@ skipping 294 matching lines @@
 }
 
 TEST_F(QuicStreamSequencerBufferTest, GetReadableRegionsEmpty) {
   iovec iovs[2];
   int iov_count = buffer_->GetReadableRegions(iovs, 2);
   EXPECT_EQ(0, iov_count);
   EXPECT_EQ(nullptr, iovs[iov_count].iov_base);
   EXPECT_EQ(0u, iovs[iov_count].iov_len);
 }
 
+TEST_F(QuicStreamSequencerBufferTest, ReleaseWholeBuffer) {
+  // Tests that buffer is not deallocated unless ReleaseWholeBuffer() is called.
+  if (!FLAGS_quic_reduce_sequencer_buffer_memory_life_time) {  // NOLINT
+    // Won't release buffer when flag is off.
+    return;
+  }
+
+  string source(100, 'b');
+  clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
+  QuicTime t1 = clock_.ApproximateNow();
+  // Write something into [0, 100).
+  size_t written;
+  buffer_->OnStreamData(0, source, t1, &written, &error_details_);
+  EXPECT_TRUE(buffer_->HasBytesToRead());
+  char dest[120];
+  iovec iovecs[3]{iovec{dest, 40}, iovec{dest + 40, 40}, iovec{dest + 80, 40}};
+  size_t read = buffer_->Readv(iovecs, 3);
+  EXPECT_EQ(100u, read);
+  EXPECT_EQ(100u, buffer_->BytesConsumed());
+  EXPECT_TRUE(helper_->CheckBufferInvariants());
+  EXPECT_TRUE(helper_->IsBufferAllocated());
+  buffer_->ReleaseWholeBuffer();
+  EXPECT_FALSE(helper_->IsBufferAllocated());
+}
+
 TEST_F(QuicStreamSequencerBufferTest, GetReadableRegionsBlockedByGap) {
   // Write into [1, 1024).
   string source(1023, 'a');
   size_t written;
   buffer_->OnStreamData(1, source, clock_.ApproximateNow(), &written,
                         &error_details_);
   // Try to get readable regions, but none is there.
   iovec iovs[2];
   int iov_count = buffer_->GetReadableRegions(iovs, 2);
   EXPECT_EQ(0, iov_count);
@@ skipping 524 matching lines @@
   EXPECT_LE(bytes_to_buffer_, total_bytes_read_) << "iterations: "
                                                  << iterations;
   EXPECT_LE(bytes_to_buffer_, total_bytes_written_);
 }
 
 }  // anonymous namespace
 
 }  // namespace test
 
 }  // namespace net