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