WebRTC源码分析——写时复制缓存CopyOnWriteBuffer

最新推荐文章于 2022-11-02 10:07:50 发布

ice_ly000

最新推荐文章于 2022-11-02 10:07:50 发布

阅读量1.2k

点赞数 1

分类专栏： WebRTC源码分析

本文链接：https://blog.csdn.net/ice_ly000/article/details/106720359

版权

WebRTC源码分析专栏收录该内容

38 篇文章 180 订阅

订阅专栏

1. 引言

在WebRTC中，不论是发送接收数据通道的数据、还是发送接收音视频数据，数据本身都存储于一个临时的Buffer中，这个Buffer的实现类为CopyOnWriteBuffer。顾名思义，该Buffer实现了 “写时复制” 的技术。那么什么是写时复制？写时复制带来了什么好处？

2. 什么是写时复制

写入时复制（Copy-on-write，简称COW）是一种计算机程序设计领域的优化策略。其核心思想是，如果有多个调用者（callers）同时请求相同资源（如内存或磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者试图修改资源的内容时，系统才会真正复制一份专用副本（private copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这过程对其他的调用者都是透明的（transparently），也即调用者无法感知的。此作法主要的优点是如果调用者没有修改该资源，就不会有副本（private copy）被创建，因此多个调用者只是读取操作时可以共享同一份资源。

计算机技术中哪些地方使用了写时复制呢？举一些例子：

虚拟内存管理中的写时复制：一般把被共享访问的页面标记为只读。当一个task试图向内存中写入数据时，内存管理单元（MMU）抛出一个异常，内核处理该异常时为该task分配一份物理内存并复制数据到此内存，重新向MMU发出执行该task的写操作。
数据存储中的写时复制：Linux等的文件管理系统使用了写时复制策略。数据库服务器也一般采用了写时复制策略，为用户提供一份snapshot。
软件应用中的写时复制：C++标准程序库中的std::string类，在C++98/C++03标准中是允许写时复制策略。但在C++11标准中为了提高并行性取消了这一策略。

3. CopyOnWriteBuffer实现

根据写时拷贝的概念，CopyOnWriteBuffer提供一种机制，可以存在多个CopyOnWriteBuffer的实例引用同一块存储。

当从进行复制操作时，产生新的CopyOnWriteBuffer也会引用原始的存储；
某个CopyOnWriteBuffer实例的读操作不会引发创建新的底层存储；
某个CopyOnWriteBuffer实例的写操作会触发该实例创建新的底层存储。
接下来我们看看CopyOnWriteBuffer的具体实现。

3.1 CopyOnWriteBuffer的成员变量

CopyOnWriteBuffer提供了3个成员以支撑它所提供的特性：

scoped_refptr<RefCountedObject<Buffer>> buffer_ ：共享智能指针buffer_，相当于C++11中的std::shared_ptr<buffer>，实现方式详见 WebRTC源码分析——引用计数系统。该成员提供共享式的存储资源，是写时复制的实现基础。
size_t offset_ && size_t size_ ：为支撑CopyOnWriteBuffer的分片功能，让CopyOnWriteBuffer可以是原始存储buffer_的一个分片，即buffer_的一部分数据。offset_表示为buffer_的偏移，size_为该分片的大小。

3.2 CopyOnWriteBuffer的成员方法

正如前文所述，CopyOnWriteBuffer实现COW，必须保证在进行复制操作时，共享“别的”CopyOnWriteBuffer的实际存储；在进行读操作时，不更改（生成新的）底层的实际存储；在进行写操作时，开辟新的底层实际存储，复制原来实际存储的内容，并根据写操作写入新的内存。后文从上述三个方面来阐述CopyOnWriteBuffer的构造、读方法、写方法的实现。

3.2.1 CopyOnWriteBuffer的构造

我们知道C++的构造方法有很多种，站在CopyOnWriteBuffer实现COW技术的角度上来看，可以分成三类：

1、一般参数的构造(包括默认构造)——初始化一个全新的、与别的CopyOnWriteBuffer不相干的CopyOnWriteBuffer对象。这些构造有：

// An empty buffer.
CopyOnWriteBuffer::CopyOnWriteBuffer() : offset_(0), size_(0) {
RTC_DCHECK(IsConsistent());
}
// Construct a buffer from a string, convenient for unittests.
CopyOnWriteBuffer::CopyOnWriteBuffer(const std::string& s)
    : CopyOnWriteBuffer(s.data(), s.length()) {}
// Construct a buffer with the specified number of uninitialized bytes.
CopyOnWriteBuffer::CopyOnWriteBuffer(size_t size)
    : buffer_(size > 0 ? new RefCountedObject<Buffer>(size) : nullptr),
      offset_(0),
      size_(size) {
  RTC_DCHECK(IsConsistent());
}
CopyOnWriteBuffer::CopyOnWriteBuffer(size_t size, size_t capacity)
    : buffer_(size > 0 || capacity > 0
                  ? new RefCountedObject<Buffer>(size, capacity)
                  : nullptr),
      offset_(0),
      size_(size) {
  RTC_DCHECK(IsConsistent());
}
// 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 std::enable_if<
              internal::BufferCompat<uint8_t, T>::value>::type* = nullptr>
CopyOnWriteBuffer(const T* data, size_t size)
    : CopyOnWriteBuffer(data, size, size) {}
template <typename T,
          typename std::enable_if<
              internal::BufferCompat<uint8_t, T>::value>::type* = nullptr>
CopyOnWriteBuffer(const T* data, size_t size, size_t capacity)
    : CopyOnWriteBuffer(size, capacity) {
  if (buffer_) {
    std::memcpy(buffer_->data(), data, size);
    offset_ = 0;
    size_ = size;
  }
}
// Construct a buffer from the contents of an array.
template <typename T,
          size_t N,
          typename std::enable_if<
              internal::BufferCompat<uint8_t, T>::value>::type* = nullptr>
CopyOnWriteBuffer(const T (&array)[N])  // NOLINT: runtime/explicit
    : CopyOnWriteBuffer(array, N) {}

注意：底层的存储scoped_refptr<RefCountedObject<Buffer>> buffer_ 成员Buffer类中用来存储数据的是uint8_t[]数组。当我们以外部数据来初始化CopyOnWriteBuffer时，支持uint8_t*, int8_t*, char*数组，它们的基础单位都是一个字节，被认为是“兼容的”（internal::BufferCompat<uint8_t, T>::value为真），此时，使用 std::memcpy(buffer_->data(), data, size);直接进行内存拷贝。
2、移动构造——实现转移语义，偷取别的CopyOnWriteBuffer的实际存储，从而得到一个新的CopyOnWriteBuffer，由于“别的”CopyOnWriteBuffer实际存储被偷，从而使得实际的存储资源并没有增多，但“别的”CopyOnWriteBuffer再也无法访问它原来的存储了。源码如下：

CopyOnWriteBuffer::CopyOnWriteBuffer(CopyOnWriteBuffer&& buf)
    : buffer_(std::move(buf.buffer_)), offset_(buf.offset_), size_(buf.size_) {
  buf.offset_ = 0;
  buf.size_ = 0;
  RTC_DCHECK(IsConsistent());
}

CopyOnWriteBuffer& operator=(CopyOnWriteBuffer&& buf) {
  RTC_DCHECK(IsConsistent());
  RTC_DCHECK(buf.IsConsistent());
  buffer_ = std::move(buf.buffer_);
  offset_ = buf.offset_;
  size_ = buf.size_;
  buf.offset_ = 0;
  buf.size_ = 0;
  return *this;
}

3、拷贝构造(包括赋值操作、拷贝构造)——实现拷贝语义，由于COW机制，实际上不进行实质上的拷贝，“新的”CopyOnWriteBuffer对象与“别的”CopyOnWriteBuffer共享存储。源码如下：buf的成员buffer_的引用计数将+1

CopyOnWriteBuffer::CopyOnWriteBuffer(const CopyOnWriteBuffer& buf)
    : buffer_(buf.buffer_), offset_(buf.offset_), size_(buf.size_) {}

CopyOnWriteBuffer& operator=(const CopyOnWriteBuffer& buf) {
  RTC_DCHECK(IsConsistent());
  RTC_DCHECK(buf.IsConsistent());
  if (&buf != this) {
    buffer_ = buf.buffer_;
    offset_ = buf.offset_;
    size_ = buf.size_;
  }
  return *this;
}

3.2.2 CopyOnWriteBuffer的读方法

访问CopyOnWriteBuffer中数据的方式如下源码所示：

// 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 std::enable_if<
              internal::BufferCompat<uint8_t, T>::value>::type* = nullptr>
const T* data() const {
  return cdata<T>();
}

// Get const pointer to the data. This will not create a copy of the
// underlying data if it is shared with other buffers.
template <typename T = uint8_t,
          typename std::enable_if<
              internal::BufferCompat<uint8_t, T>::value>::type* = nullptr>
const T* cdata() const {
  RTC_DCHECK(IsConsistent());
  if (!buffer_) {
    return nullptr;
  }
  return buffer_->data<T>() + offset_;
}
  
uint8_t operator[](size_t index) const {
 RTC_DCHECK_LT(index, size());
 return cdata()[index];
}

可以看到不论是通过data() 还是 cdata()访问，最终得到是内部存储的直接地址，不过加了修饰符const使得无法通过该指针来修改存储内容，不会另外创建一个新的Buffer。另外，实现了[]运算符，以便读取某个位置的单个元素值，由于以const修饰，因此，也不会修改存储内容。

3.2.3 CopyOnWriteBuffer的写方法

修改CopyOnWriteBuffer的方式有好几种：
1、通过内部存储的直接地址修改：CopyOnWriteBuffer不仅提供了const修饰的data()方法，以便只读；也提供了非const修饰的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 std::enable_if<
              internal::BufferCompat<uint8_t, T>::value>::type* = nullptr>
T* data() {
  RTC_DCHECK(IsConsistent());
  if (!buffer_) {
    return nullptr;
  }
  UnshareAndEnsureCapacity(capacity());
  return buffer_->data<T>() + offset_;
}

void CopyOnWriteBuffer::UnshareAndEnsureCapacity(size_t new_capacity) {
  if (buffer_->HasOneRef() && new_capacity <= capacity()) {
    return;
  }

  buffer_ = new RefCountedObject<Buffer>(buffer_->data() + offset_, size_,
                                         new_capacity);
  offset_ = 0;
  RTC_DCHECK(IsConsistent());
}

需要注意一点：当底层buffer的引用计数只有一个时，不会创建新的底层存储，引为没有必要。当有多个CopyOnWriteBuffer共享了底层存储，则会创建一个新的。

2、通过单个元素的引用来修改：调用了上述的data()方法。

uint8_t& operator[](size_t index) {
  RTC_DCHECK_LT(index, size());
  return data()[index];
}

3、通过SetData方法设置底层存储中的数据：由于代码比较简单，因此，不需要多说。但特别注意一点，当以另外一个CopyOnWriteBuffer对象引用为参数时，并不会创建新的底层存储，而是将buffer_指向了传入对象的底层存储，这比新建一个存储，复制数据要来得高效。

// Replace the contents of the buffer. Accepts the same types as the
// constructors.
template <typename T,
          typename std::enable_if<
              internal::BufferCompat<uint8_t, T>::value>::type* = nullptr>
void SetData(const T* data, size_t size) {
  RTC_DCHECK(IsConsistent());
  if (!buffer_) {
    buffer_ = size > 0 ? new RefCountedObject<Buffer>(data, size) : nullptr;
  } else if (!buffer_->HasOneRef()) {
    buffer_ = new RefCountedObject<Buffer>(data, size, capacity());
  } else {
    buffer_->SetData(data, size);
  }
  offset_ = 0;
  size_ = size;

  RTC_DCHECK(IsConsistent());
}

template <typename T,
          size_t N,
          typename std::enable_if<
              internal::BufferCompat<uint8_t, T>::value>::type* = nullptr>
void SetData(const T (&array)[N]) {
  SetData(array, N);
}

void SetData(const CopyOnWriteBuffer& buf) {
  RTC_DCHECK(IsConsistent());
  RTC_DCHECK(buf.IsConsistent());
  if (&buf != this) {
    buffer_ = buf.buffer_;
    offset_ = buf.offset_;
    size_ = buf.size_;
  }
}

4、使用AppendData追加数据：

// Append data to the buffer. Accepts the same types as the constructors.
template <typename T,
          typename std::enable_if<
              internal::BufferCompat<uint8_t, T>::value>::type* = nullptr>
void AppendData(const T* data, size_t size) {
  RTC_DCHECK(IsConsistent());
  if (!buffer_) {
    buffer_ = new RefCountedObject<Buffer>(data, size);
    offset_ = 0;
    size_ = size;
    RTC_DCHECK(IsConsistent());
    return;
  }

  UnshareAndEnsureCapacity(std::max(capacity(), size_ + size));

  buffer_->SetSize(offset_ +
                   size_);  // Remove data to the right of the slice.
  buffer_->AppendData(data, size);
  size_ += size;

  RTC_DCHECK(IsConsistent());
}

template <typename T,
          size_t N,
          typename std::enable_if<
              internal::BufferCompat<uint8_t, T>::value>::type* = nullptr>
void AppendData(const T (&array)[N]) {
  AppendData(array, N);
}

void AppendData(const CopyOnWriteBuffer& buf) {
  AppendData(buf.data(), buf.size());
}