Add CopyOnWriteBuffer class

webrtc/base/buffer.h

 /*
  *  Copyright 2004 The WebRTC 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 in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifndef WEBRTC_BASE_BUFFER_H_
 #define WEBRTC_BASE_BUFFER_H_
 
 #include <algorithm>  // std::swap (pre-C++11)
 #include <cassert>
 #include <cstring>
 #include <memory>
 #include <utility>  // std::swap (C++11 and later)
 
 #include "webrtc/base/constructormagic.h"
+#include "webrtc/base/atomicops.h"
 #include "webrtc/base/deprecation.h"
 
 namespace rtc {
 
 namespace internal {
 
 // (Internal; please don't use outside this file.) ByteType<T>::t is int if T
 // is uint8_t, int8_t, or char; otherwise, it's a compilation error. Use like
 // this:
 //
 //   template <typename T, typename ByteType<T>::t = 0>
 //   void foo(T* x);
 //
 // to let foo<T> be defined only for byte-sized integers.
 template <typename T>
 struct ByteType {
  private:
   static int F(uint8_t*);
   static int F(int8_t*);
   static int F(char*);
 
  public:
   using t = decltype(F(static_cast<T*>(nullptr)));
 };
 
 }  // namespace internal
 
+// Data stored in a buffer. RefCounted and will be shared between buffers that
+// are cloned to avoid unnecessary allocations / copies.
+class BufferData {

[tommi, 2016/02/14 09:03:42]

should this be in the 'internal' namespace? I'm assuming it's not supposed to be
used outside this header.

[joachim, 2016/02/14 11:10:19]

You are right, changed.

+ public:
+  BufferData();
+
+  explicit BufferData(const BufferData& data);
+
+  // Construct data with the specified number of uninitialized bytes.
+  explicit BufferData(size_t size);
+  BufferData(size_t size, size_t capacity);
+
+  // Construct data and copy the specified number of bytes into it.
+  BufferData(const void* data, size_t size);
+  BufferData(const void* data, size_t size, size_t capacity);
+
+  size_t size() const {
+    assert(IsConsistent());

[tommi, 2016/02/14 09:03:42]

use RTC_DCHECK instead of assert()

[joachim, 2016/02/14 11:10:18]

Changed here and in other places.

+    return size_;
+  }
+  size_t capacity() const {
+    assert(IsConsistent());
+    return capacity_;
+  }
+  uint8_t* data() const {
+    assert(IsConsistent());
+    return data_.get();
+  }
+
+  void SetData(const void* data, size_t size) {
+    assert(IsConsistent());
+    size_ = 0;
+    AppendData(data, size);
+  }
+
+  void AppendData(const void* data, size_t size) {
+    assert(IsConsistent());
+    const size_t new_size = size_ + size;
+    EnsureCapacity(new_size);
+    std::memcpy(data_.get() + size_, data, size);
+    size_ = new_size;
+    assert(IsConsistent());
+  }
+
+  // Sets the size of the data. If the new size is smaller than the old, the
+  // data contents will be kept but truncated; if the new size is greater,
+  // the existing contents will be kept and the new space will be
+  // uninitialized.
+  void SetSize(size_t size) {
+    EnsureCapacity(size);
+    size_ = size;
+  }
+
+  // Ensure that the data size can be increased to at least capacity without
+  // further reallocation. (Of course, this operation might need to reallocate
+  // the buffer.)
+  void EnsureCapacity(size_t capacity) {
+    assert(IsConsistent());
+    if (capacity <= capacity_) {
+      return;
+    }
+
+    std::unique_ptr<uint8_t[]> new_data(new uint8_t[capacity]);
+    std::memcpy(new_data.get(), data_.get(), size_);
+    data_ = std::move(new_data);
+    capacity_ = capacity;
+    assert(IsConsistent());
+  }
+
+  // Resets the data to zero size and capacity.
+  void Clear() {
+    data_.reset();
+    size_ = 0;
+    capacity_ = 0;
+    assert(IsConsistent());
+  }
+
+  // Reimplement parts of RefCountedObject which is not in rtc_base_approved.

[joachim, 2016/02/13 16:08:46]

Are there plans to move "refcount.h" into "rtc_base_approved"? This would allow
removing this code duplication.

[tommi, 2016/02/14 09:03:42]

Yes, that should be trivial.
Btw, does the refcount always have to be thread safe?  Depending on how we'll
use this code, we might want to have thread safety abstracted away in a traits
class.  That way we could have one that uses atomic ops, and another that
DCHECKs correct thread usage and is single threaded.

[joachim, 2016/02/14 11:10:18]

Thanks for your CL to move it, please see my last comment about also moving
"scoped_ref_ptr.h". This makes the code here clearer and you wouldn't have to
call AddRef/Release manually.
Hmm, for the buffers it probably doesn't need to be thread safe, though I didn't
check yet. I will look into making the refcounting more flexible in a separate
CL so we could change this later.

+
+  int AddRef() const {
+    return AtomicOps::Increment(&ref_count_);
+  }
+
+  int Release() const {
+    int count = AtomicOps::Decrement(&ref_count_);
+    if (!count) {
+      delete this;
+    }
+    return count;
+  }
+
+  // Returns true if the data is only used for a single Buffer.
+  bool HasOneRef() const {
+    return AtomicOps::AcquireLoad(&ref_count_) == 1;
+  }
+
+ private:
+  friend class Buffer;
+
+  ~BufferData();
+
+  // Precondition for all methods except Clear and the destructor.
+  // Postcondition for all methods except move construction and move
+  // assignment, which leave the moved-from object in a possibly inconsistent
+  // state.
+  bool IsConsistent() const {
+    return (data_ || capacity_ == 0) && capacity_ >= size_;
+  }
+
+#ifndef NDEBUG
+  // Called when *this has been moved from. Conceptually it's a no-op, but we
+  // can mutate the state slightly to help subsequent sanity checks catch bugs.
+  void OnMovedFrom() {
+    // Ensure that *this is always inconsistent, to provoke bugs.
+    size_ = 1;
+    capacity_ = 0;
+  }
+#endif
+
+  mutable volatile int ref_count_;
+
+  size_t size_;
+  size_t capacity_;
+  std::unique_ptr<uint8_t[]> data_;
+};
+
 // Basic buffer class, can be grown and shrunk dynamically.
 // Unlike std::string/vector, does not initialize data when expanding capacity.
+// The underlying memory is shared between copies of buffers and cloned if a
+// shared buffer is being modified.
 class Buffer {
  public:
   Buffer();                   // An empty buffer.
   Buffer(const Buffer& buf);  // Copy size and contents of an existing buffer.
   Buffer(Buffer&& buf);       // Move contents from an existing buffer.
 
   // Construct a buffer with the specified number of uninitialized bytes.
   explicit Buffer(size_t size);
   Buffer(size_t size, size_t capacity);
 
   // Construct a buffer and copy the specified number of bytes into it. The
   // source array may be (const) uint8_t*, int8_t*, or char*.
   template <typename T, typename internal::ByteType<T>::t = 0>
   Buffer(const T* data, size_t size)
       : Buffer(data, size, size) {}
   template <typename T, typename internal::ByteType<T>::t = 0>
   Buffer(const T* data, size_t size, size_t capacity)
       : Buffer(size, capacity) {
-    std::memcpy(data_.get(), data, size);
+    std::memcpy(data_->data(), data, size);
   }
 
   // Construct a buffer from the contents of an array.
   template <typename T, size_t N, typename internal::ByteType<T>::t = 0>
-  Buffer(const T(&array)[N])
+  Buffer(const T(&array)[N])  // NOLINT: runtime/explicit
       : Buffer(array, N) {}
 
   ~Buffer();
 
   // Get a pointer to the data. Just .data() will give you a (const) uint8_t*,
   // but you may also use .data<int8_t>() and .data<char>().
   template <typename T = uint8_t, typename internal::ByteType<T>::t = 0>
   const T* data() const {
     assert(IsConsistent());
-    return reinterpret_cast<T*>(data_.get());
+    return reinterpret_cast<T*>(data_->data());
   }
+  // Get writable pointer to the data. This will create a copy of the underlying
+  // data if it is shared with other buffers.
   template <typename T = uint8_t, typename internal::ByteType<T>::t = 0>
   T* data() {
-    assert(IsConsistent());
-    return reinterpret_cast<T*>(data_.get());
+    CloneDataIfReferenced();
+    return reinterpret_cast<T*>(data_->data());
   }
 
   size_t size() const {
     assert(IsConsistent());
-    return size_;
+    return data_->size();
   }
   size_t capacity() const {
     assert(IsConsistent());
-    return capacity_;
+    return data_->capacity();
   }
 
   Buffer& operator=(const Buffer& buf) {
-    if (&buf != this)
-      SetData(buf.data(), buf.size());
+    if (&buf != this) {
+      SetData(buf);
+    }
     return *this;
   }
   Buffer& operator=(Buffer&& buf) {
-    assert(IsConsistent());
-    assert(buf.IsConsistent());
-    size_ = buf.size_;
-    capacity_ = buf.capacity_;
-    data_ = std::move(buf.data_);
-    buf.OnMovedFrom();
+    if (&buf != this) {
+      assert(IsConsistent());
+      assert(buf.IsConsistent());
+      data_->Release();
+      data_ = std::move(buf.data_);
+      buf.OnMovedFrom();
+    }
     return *this;
   }
 
   bool operator==(const Buffer& buf) const {
-    assert(IsConsistent());
-    return size_ == buf.size() && memcmp(data_.get(), buf.data(), size_) == 0;
+    return data_ == buf.data_ ||
+           (size() == buf.size() && memcmp(data(), buf.data(), size()) == 0);
   }
 
   bool operator!=(const Buffer& buf) const { return !(*this == buf); }
 
   // Replace the contents of the buffer. Accepts the same types as the
   // constructors.
   template <typename T, typename internal::ByteType<T>::t = 0>
   void SetData(const T* data, size_t size) {
     assert(IsConsistent());
-    size_ = 0;
-    AppendData(data, size);
+    if (!data_->HasOneRef()) {
+      data_->Release();
+      data_ = new BufferData(data, size);
+    } else {
+      data_->SetData(data, size);
+    }
   }
   template <typename T, size_t N, typename internal::ByteType<T>::t = 0>
   void SetData(const T(&array)[N]) {
     SetData(array, N);
   }
-  void SetData(const Buffer& buf) { SetData(buf.data(), buf.size()); }
+  void SetData(const Buffer& buf) {
+    if (&buf != this) {
+      assert(IsConsistent());
+      assert(buf.IsConsistent());
+      buf.data_->AddRef();
+      data_->Release();
+      data_ = buf.data_;
+    }
+  }
 
   // Append data to the buffer. Accepts the same types as the constructors.
   template <typename T, typename internal::ByteType<T>::t = 0>
   void AppendData(const T* data, size_t size) {
-    assert(IsConsistent());
-    const size_t new_size = size_ + size;
-    EnsureCapacity(new_size);
-    std::memcpy(data_.get() + size_, data, size);
-    size_ = new_size;
-    assert(IsConsistent());
+    CloneDataIfReferenced();
+    data_->AppendData(data, size);
   }
   template <typename T, size_t N, typename internal::ByteType<T>::t = 0>
   void AppendData(const T(&array)[N]) {
     AppendData(array, N);
   }
   void AppendData(const Buffer& buf) { AppendData(buf.data(), buf.size()); }
 
   // Sets the size of the buffer. If the new size is smaller than the old, the
   // buffer contents will be kept but truncated; if the new size is greater,
   // the existing contents will be kept and the new space will be
   // uninitialized.
   void SetSize(size_t size) {
-    EnsureCapacity(size);
-    size_ = size;
+    CloneDataIfReferenced();
+    data_->SetSize(size);
   }
 
   // Ensure that the buffer size can be increased to at least capacity without
   // further reallocation. (Of course, this operation might need to reallocate
   // the buffer.)
   void EnsureCapacity(size_t capacity) {
     assert(IsConsistent());
-    if (capacity <= capacity_)
+    if (capacity <= data_->capacity())
       return;
-    std::unique_ptr<uint8_t[]> new_data(new uint8_t[capacity]);
-    std::memcpy(new_data.get(), data_.get(), size_);
-    data_ = std::move(new_data);
-    capacity_ = capacity;
-    assert(IsConsistent());
+
+    CloneDataIfReferenced();
+    data_->EnsureCapacity(capacity);
   }
 
   // b.Pass() does the same thing as std::move(b).
   // Deprecated; remove in March 2016 (bug 5373).
   RTC_DEPRECATED Buffer&& Pass() { return DEPRECATED_Pass(); }
   Buffer&& DEPRECATED_Pass() {
     assert(IsConsistent());
     return std::move(*this);
   }
 
-  // Resets the buffer to zero size and capacity. Works even if the buffer has
-  // been moved from.
+  // Resets the buffer to zero size and capacity.
   void Clear() {
-    data_.reset();
-    size_ = 0;
-    capacity_ = 0;
+    if (!data_->HasOneRef()) {
+      data_->Release();
+      data_ = new BufferData();
+    } else {
+      data_->Clear();
+    }
     assert(IsConsistent());
   }
 
-  // Swaps two buffers. Also works for buffers that have been moved from.
+  // Swaps two buffers.
   friend void swap(Buffer& a, Buffer& b) {
-    using std::swap;
-    swap(a.size_, b.size_);
-    swap(a.capacity_, b.capacity_);
-    swap(a.data_, b.data_);
+    std::swap(a.data_, b.data_);
   }
 
  private:
   // Precondition for all methods except Clear and the destructor.
   // Postcondition for all methods except move construction and move
   // assignment, which leave the moved-from object in a possibly inconsistent
   // state.
   bool IsConsistent() const {
-    return (data_ || capacity_ == 0) && capacity_ >= size_;
+    return data_ != nullptr && data_->IsConsistent();
   }
 
   // Called when *this has been moved from. Conceptually it's a no-op, but we
   // can mutate the state slightly to help subsequent sanity checks catch bugs.
   void OnMovedFrom() {
-#ifdef NDEBUG
-    // Make *this consistent and empty. Shouldn't be necessary, but better safe
-    // than sorry.
-    size_ = 0;
-    capacity_ = 0;
-#else
+    data_ = new BufferData();
+#ifndef NDEBUG
     // Ensure that *this is always inconsistent, to provoke bugs.
-    size_ = 1;
-    capacity_ = 0;
+    data_->OnMovedFrom();
 #endif
   }
 
-  size_t size_;
-  size_t capacity_;
-  std::unique_ptr<uint8_t[]> data_;
+  // Create a copy of the underlying data if it is referenced from other Buffer
+  // objects.
+  void CloneDataIfReferenced() {
+    assert(IsConsistent());
+    if (data_->HasOneRef()) {
+      return;
+    }
+
+    BufferData* new_data = new BufferData(*data_);
+    data_->Release();
+    data_ = new_data;
+  }
+
+  BufferData* data_;
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_BUFFER_H_