IPC pickling optimization for render passes.

base/pickle.cc

 // Copyright (c) 2012 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 "base/pickle.h"
 
 #include <stdlib.h>
 
 #include <algorithm>  // for max()
 
@@ skipping 177 matching lines @@
   if (!header_size_)
     header_ = NULL;
 }
 
 Pickle::Pickle(const Pickle& other)
     : header_(NULL),
       header_size_(other.header_size_),
       capacity_(0),
       variable_buffer_offset_(other.variable_buffer_offset_) {
   size_t payload_size = header_size_ + other.header_->payload_size;
-  bool resized = Resize(payload_size);
-  CHECK(resized);  // Realloc failed.
+  Resize(payload_size);
   memcpy(header_, other.header_, payload_size);
 }
 
 Pickle::~Pickle() {
   if (capacity_ != kCapacityReadOnly)
     free(header_);
 }
 
 Pickle& Pickle::operator=(const Pickle& other) {
   if (this == &other) {
     NOTREACHED();
     return *this;
   }
   if (capacity_ == kCapacityReadOnly) {
     header_ = NULL;
     capacity_ = 0;
   }
   if (header_size_ != other.header_size_) {
     free(header_);
     header_ = NULL;
     header_size_ = other.header_size_;
   }
-  bool resized = Resize(other.header_size_ + other.header_->payload_size);
-  CHECK(resized);  // Realloc failed.
+  Resize(other.header_size_ + other.header_->payload_size);
   memcpy(header_, other.header_,
          other.header_size_ + other.header_->payload_size);
   variable_buffer_offset_ = other.variable_buffer_offset_;
   return *this;
 }
 
 bool Pickle::WriteString(const std::string& value) {
   if (!WriteInt(static_cast<int>(value.size())))
     return false;
 
@@ skipping 63 matching lines @@
   if (new_length < 0 || new_length > *cur_length) {
     NOTREACHED() << "Invalid length in TrimWriteData.";
     return;
   }
 
   // Update the payload size and variable buffer size
   header_->payload_size -= (*cur_length - new_length);
   *cur_length = new_length;
 }
 
+void Pickle::Reserve(size_t length) {
+  // write at a uint32-aligned offset from the beginning of the header
+  size_t offset = AlignInt(header_->payload_size, sizeof(uint32));
+
+  size_t new_size = offset + length;
+  size_t needed_size = header_size_ + new_size;
+  if (needed_size > capacity_)
+    Resize(capacity_ * 2 + needed_size);

[Tom Sepez, 2013/10/24 17:48:06]

Why 2x? Also, this should be a bool return value, see below.

[danakj, 2013/10/24 17:51:38]

Same reason as in BeginWrite, in order to amortize the cost of expanding the
size of the array.

+}
+
 char* Pickle::BeginWrite(size_t length) {
   // write at a uint32-aligned offset from the beginning of the header
   size_t offset = AlignInt(header_->payload_size, sizeof(uint32));
 
   size_t new_size = offset + length;
   size_t needed_size = header_size_ + new_size;
-  if (needed_size > capacity_ && !Resize(std::max(capacity_ * 2, needed_size)))
-    return NULL;
+  if (needed_size > capacity_)
+    Resize(std::max(capacity_ * 2, needed_size));
 
 #ifdef ARCH_CPU_64_BITS
   DCHECK_LE(length, kuint32max);
 #endif
 
   header_->payload_size = static_cast<uint32>(new_size);
   return mutable_payload() + offset;
 }
 
 void Pickle::EndWrite(char* dest, int length) {
   // Zero-pad to keep tools like valgrind from complaining about uninitialized
   // memory.
   if (length % sizeof(uint32))
     memset(dest + length, 0, sizeof(uint32) - (length % sizeof(uint32)));
 }
 
-bool Pickle::Resize(size_t new_capacity) {
+void Pickle::Resize(size_t new_capacity) {
+  CHECK_NE(capacity_, kCapacityReadOnly);

[Tom Sepez, 2013/10/24 17:48:06]

There's a minor problem here in that if realloc fails, the old memory block is
not freed.  So you'd leak here if you don't check the return codes as was done
previously.

[danakj, 2013/10/24 17:51:38]

if realloc fails, we will crash inside tcmalloc no?

+
   new_capacity = AlignInt(new_capacity, kPayloadUnit);
-
-  CHECK_NE(capacity_, kCapacityReadOnly);
   void* p = realloc(header_, new_capacity);
-  if (!p)
-    return false;
-
   header_ = reinterpret_cast<Header*>(p);
   capacity_ = new_capacity;
-  return true;
 }
 
 // static
 const char* Pickle::FindNext(size_t header_size,
                              const char* start,
                              const char* end) {
   DCHECK_EQ(header_size, AlignInt(header_size, sizeof(uint32)));
   DCHECK_LE(header_size, static_cast<size_t>(kPayloadUnit));
 
   if (static_cast<size_t>(end - start) < sizeof(Header))
     return NULL;
 
   const Header* hdr = reinterpret_cast<const Header*>(start);
   const char* payload_base = start + header_size;
   const char* payload_end = payload_base + hdr->payload_size;
   if (payload_end < payload_base)
     return NULL;
 
   return (payload_end > end) ? NULL : payload_end;
 }