1 // Copyright (c) 2009 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "net/tools/flip_server/ring_buffer.h" 6 #include "base/logging.h" 7 8 namespace net { 9 10 RingBuffer::RingBuffer(int buffer_size) 11 : buffer_(new char[buffer_size]), 12 buffer_size_(buffer_size), 13 bytes_used_(0), 14 read_idx_(0), 15 write_idx_(0) {} 16 17 RingBuffer::~RingBuffer() {} 18 19 int RingBuffer::ReadableBytes() const { return bytes_used_; } 20 21 int RingBuffer::BufferSize() const { return buffer_size_; } 22 23 int RingBuffer::BytesFree() const { return BufferSize() - ReadableBytes(); } 24 25 bool RingBuffer::Empty() const { return ReadableBytes() == 0; } 26 27 bool RingBuffer::Full() const { return ReadableBytes() == BufferSize(); } 28 29 // Returns the number of characters written. 30 // Appends up-to-'size' bytes to the ringbuffer. 31 int RingBuffer::Write(const char* bytes, int size) { 32 CHECK_GE(size, 0); 33 #if 1 34 char* wptr; 35 int wsize; 36 GetWritablePtr(&wptr, &wsize); 37 int bytes_remaining = size; 38 int bytes_written = 0; 39 40 while (wsize && bytes_remaining) { 41 if (wsize > bytes_remaining) { 42 wsize = bytes_remaining; 43 } 44 memcpy(wptr, bytes + bytes_written, wsize); 45 bytes_written += wsize; 46 bytes_remaining -= wsize; 47 AdvanceWritablePtr(wsize); 48 GetWritablePtr(&wptr, &wsize); 49 } 50 return bytes_written; 51 #else 52 const char* p = bytes; 53 54 int bytes_to_write = size; 55 int bytes_available = BytesFree(); 56 if (bytes_available < bytes_to_write) { 57 bytes_to_write = bytes_available; 58 } 59 const char* end = bytes + bytes_to_write; 60 61 while (p != end) { 62 this->buffer_[this->write_idx_] = *p; 63 ++p; 64 ++this->write_idx_; 65 if (this->write_idx_ >= this->buffer_size_) { 66 this->write_idx_ = 0; 67 } 68 } 69 bytes_used_ += bytes_to_write; 70 return bytes_to_write; 71 #endif 72 } 73 74 // Sets *ptr to the beginning of writable memory, and sets *size to the size 75 // available for writing using this pointer. 76 void RingBuffer::GetWritablePtr(char** ptr, int* size) const { 77 *ptr = buffer_.get() + write_idx_; 78 79 if (bytes_used_ == buffer_size_) { 80 *size = 0; 81 } else if (read_idx_ > write_idx_) { 82 *size = read_idx_ - write_idx_; 83 } else { 84 *size = buffer_size_ - write_idx_; 85 } 86 } 87 88 // Sets *ptr to the beginning of readable memory, and sets *size to the size 89 // available for reading using this pointer. 90 void RingBuffer::GetReadablePtr(char** ptr, int* size) const { 91 *ptr = buffer_.get() + read_idx_; 92 93 if (bytes_used_ == 0) { 94 *size = 0; 95 } else if (write_idx_ > read_idx_) { 96 *size = write_idx_ - read_idx_; 97 } else { 98 *size = buffer_size_ - read_idx_; 99 } 100 } 101 102 // returns the number of bytes read into 103 int RingBuffer::Read(char* bytes, int size) { 104 CHECK_GE(size, 0); 105 #if 1 106 char* rptr; 107 int rsize; 108 GetReadablePtr(&rptr, &rsize); 109 int bytes_remaining = size; 110 int bytes_read = 0; 111 112 while (rsize && bytes_remaining) { 113 if (rsize > bytes_remaining) { 114 rsize = bytes_remaining; 115 } 116 memcpy(bytes + bytes_read, rptr, rsize); 117 bytes_read += rsize; 118 bytes_remaining -= rsize; 119 AdvanceReadablePtr(rsize); 120 GetReadablePtr(&rptr, &rsize); 121 } 122 return bytes_read; 123 #else 124 char* p = bytes; 125 int bytes_to_read = size; 126 int bytes_used = ReadableBytes(); 127 if (bytes_used < bytes_to_read) { 128 bytes_to_read = bytes_used; 129 } 130 char* end = bytes + bytes_to_read; 131 132 while (p != end) { 133 *p = this->buffer_[this->read_idx_]; 134 ++p; 135 ++this->read_idx_; 136 if (this->read_idx_ >= this->buffer_size_) { 137 this->read_idx_ = 0; 138 } 139 } 140 this->bytes_used_ -= bytes_to_read; 141 return bytes_to_read; 142 #endif 143 } 144 145 void RingBuffer::Clear() { 146 bytes_used_ = 0; 147 write_idx_ = 0; 148 read_idx_ = 0; 149 } 150 151 bool RingBuffer::Reserve(int size) { 152 DCHECK_GT(size, 0); 153 char* write_ptr = NULL; 154 int write_size = 0; 155 GetWritablePtr(&write_ptr, &write_size); 156 157 if (write_size < size) { 158 char* read_ptr = NULL; 159 int read_size = 0; 160 GetReadablePtr(&read_ptr, &read_size); 161 if (size <= BytesFree()) { 162 // The fact that the total Free size is big enough but writable size is 163 // not means that the writeable region is broken into two pieces: only 164 // possible if the read_idx < write_idx. If write_idx < read_idx, then 165 // the writeable region must be contiguous: [write_idx, read_idx). There 166 // is no work to be done for the latter. 167 DCHECK_LE(read_idx_, write_idx_); 168 DCHECK_EQ(read_size, ReadableBytes()); 169 if (read_idx_ < write_idx_) { 170 // Writeable area fragmented, consolidate it. 171 memmove(buffer_.get(), read_ptr, read_size); 172 read_idx_ = 0; 173 write_idx_ = read_size; 174 } else if (read_idx_ == write_idx_) { 175 // No unconsumed data in the buffer, simply reset the indexes. 176 DCHECK_EQ(ReadableBytes(), 0); 177 read_idx_ = 0; 178 write_idx_ = 0; 179 } 180 } else { 181 Resize(ReadableBytes() + size); 182 } 183 } 184 DCHECK_LE(size, buffer_size_ - write_idx_); 185 return true; 186 } 187 188 void RingBuffer::AdvanceReadablePtr(int amount_to_consume) { 189 CHECK_GE(amount_to_consume, 0); 190 if (amount_to_consume >= bytes_used_) { 191 Clear(); 192 return; 193 } 194 read_idx_ += amount_to_consume; 195 read_idx_ %= buffer_size_; 196 bytes_used_ -= amount_to_consume; 197 } 198 199 void RingBuffer::AdvanceWritablePtr(int amount_to_produce) { 200 CHECK_GE(amount_to_produce, 0); 201 CHECK_LE(amount_to_produce, BytesFree()); 202 write_idx_ += amount_to_produce; 203 write_idx_ %= buffer_size_; 204 bytes_used_ += amount_to_produce; 205 } 206 207 void RingBuffer::Resize(int buffer_size) { 208 CHECK_GE(buffer_size, 0); 209 if (buffer_size == buffer_size_) 210 return; 211 212 char* new_buffer = new char[buffer_size]; 213 if (buffer_size < bytes_used_) { 214 // consume the oldest data. 215 AdvanceReadablePtr(bytes_used_ - buffer_size); 216 } 217 218 int bytes_written = 0; 219 int bytes_used = bytes_used_; 220 while (true) { 221 int size; 222 char* ptr; 223 GetReadablePtr(&ptr, &size); 224 if (size == 0) 225 break; 226 if (size > buffer_size) { 227 size = buffer_size; 228 } 229 memcpy(new_buffer + bytes_written, ptr, size); 230 bytes_written += size; 231 AdvanceReadablePtr(size); 232 } 233 buffer_.reset(new_buffer); 234 235 buffer_size_ = buffer_size; 236 bytes_used_ = bytes_used; 237 read_idx_ = 0; 238 write_idx_ = bytes_used_ % buffer_size_; 239 } 240 241 } // namespace net 242
