gpu/command_buffer/client/transfer_buffer.cc

   1 // Copyright (c) 2012 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 // A class to Manage a growing transfer buffer.
   6
   7 #include "gpu/command_buffer/client/transfer_buffer.h"
   8
   9 #include "base/logging.h"
  10 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
  11
  12 namespace gpu {
  13
  14 AlignedRingBuffer::~AlignedRingBuffer() {
  15 }
  16
  17 TransferBuffer::TransferBuffer(
  18     CommandBufferHelper* helper)
  19     : helper_(helper),
  20       result_size_(0),
  21       default_buffer_size_(0),
  22       min_buffer_size_(0),
  23       max_buffer_size_(0),
  24       alignment_(0),
  25       size_to_flush_(0),
  26       bytes_since_last_flush_(0),
  27       buffer_id_(-1),
  28       result_buffer_(NULL),
  29       result_shm_offset_(0),
  30       usable_(true) {
  31 }
  32
  33 TransferBuffer::~TransferBuffer() {
  34   Free();
  35 }
  36
  37 bool TransferBuffer::Initialize(
  38     unsigned int default_buffer_size,
  39     unsigned int result_size,
  40     unsigned int min_buffer_size,
  41     unsigned int max_buffer_size,
  42     unsigned int alignment,
  43     unsigned int size_to_flush) {
  44   result_size_ = result_size;
  45   default_buffer_size_ = default_buffer_size;
  46   min_buffer_size_ = min_buffer_size;
  47   max_buffer_size_ = max_buffer_size;
  48   alignment_ = alignment;
  49   size_to_flush_ = size_to_flush;
  50   ReallocateRingBuffer(default_buffer_size_ - result_size);
  51   return HaveBuffer();
  52 }
  53
  54 void TransferBuffer::Free() {
  55   if (HaveBuffer()) {
  56     helper_->Finish();
  57     helper_->command_buffer()->DestroyTransferBuffer(buffer_id_);
  58     buffer_id_ = -1;
  59     buffer_.ptr = NULL;
  60     buffer_.size = 0;
  61     result_buffer_ = NULL;
  62     result_shm_offset_ = 0;
  63     ring_buffer_.reset();
  64     bytes_since_last_flush_ = 0;
  65   }
  66 }
  67
  68 bool TransferBuffer::HaveBuffer() const {
  69   return buffer_id_ != -1;
  70 }
  71
  72 RingBuffer::Offset TransferBuffer::GetOffset(void* pointer) const {
  73   return ring_buffer_->GetOffset(pointer);
  74 }
  75
  76 void TransferBuffer::FreePendingToken(void* p, unsigned int token) {
  77   ring_buffer_->FreePendingToken(p, token);
  78   if (bytes_since_last_flush_ >= size_to_flush_ && size_to_flush_ > 0) {
  79     helper_->Flush();
  80     bytes_since_last_flush_ = 0;
  81   }
  82 }
  83
  84 void TransferBuffer::AllocateRingBuffer(unsigned int size) {
  85   for (;size >= min_buffer_size_; size /= 2) {
  86     int32 id = -1;
  87     gpu::Buffer buffer =
  88         helper_->command_buffer()->CreateTransferBuffer(size, &id);
  89     if (id != -1) {
  90       buffer_ = buffer;
  91       ring_buffer_.reset(new AlignedRingBuffer(
  92           alignment_,
  93           id,
  94           result_size_,
  95           buffer_.size - result_size_,
  96           helper_,
  97           static_cast<char*>(buffer_.ptr) + result_size_));
  98       buffer_id_ = id;
  99       result_buffer_ = buffer_.ptr;
 100       result_shm_offset_ = 0;
 101       return;
 102     }
 103     // we failed so don't try larger than this.
 104     max_buffer_size_ = size / 2;
 105   }
 106   usable_ = false;
 107 }
 108
 109 // Returns the integer i such as 2^i <= n < 2^(i+1)
 110 static int Log2Floor(uint32 n) {
 111   if (n == 0)
 112     return -1;
 113   int log = 0;
 114   uint32 value = n;
 115   for (int i = 4; i >= 0; --i) {
 116     int shift = (1 << i);
 117     uint32 x = value >> shift;
 118     if (x != 0) {
 119       value = x;
 120       log += shift;
 121     }
 122   }
 123   DCHECK_EQ(value, 1u);
 124   return log;
 125 }
 126
 127 // Returns the integer i such as 2^(i-1) < n <= 2^i
 128 static int Log2Ceiling(uint32 n) {
 129   if (n == 0) {
 130     return -1;
 131   } else {
 132     // Log2Floor returns -1 for 0, so the following works correctly for n=1.
 133     return 1 + Log2Floor(n - 1);
 134   }
 135 }
 136
 137 static unsigned int ComputePOTSize(unsigned int dimension) {
 138   return (dimension == 0) ? 0 : 1 << Log2Ceiling(dimension);
 139 }
 140
 141 void TransferBuffer::ReallocateRingBuffer(unsigned int size) {
 142   // What size buffer would we ask for if we needed a new one?
 143   unsigned int needed_buffer_size = ComputePOTSize(size + result_size_);
 144   needed_buffer_size = std::max(needed_buffer_size, min_buffer_size_);
 145   needed_buffer_size = std::max(needed_buffer_size, default_buffer_size_);
 146   needed_buffer_size = std::min(needed_buffer_size, max_buffer_size_);
 147
 148   if (usable_ && (!HaveBuffer() || needed_buffer_size > buffer_.size)) {
 149     if (HaveBuffer()) {
 150       Free();
 151     }
 152     AllocateRingBuffer(needed_buffer_size);
 153   }
 154 }
 155
 156 void* TransferBuffer::AllocUpTo(
 157     unsigned int size, unsigned int* size_allocated) {
 158   DCHECK(size_allocated);
 159
 160   ReallocateRingBuffer(size);
 161
 162   if (!HaveBuffer()) {
 163     return NULL;
 164   }
 165
 166   unsigned int max_size = ring_buffer_->GetLargestFreeOrPendingSize();
 167   *size_allocated = std::min(max_size, size);
 168   bytes_since_last_flush_ += *size_allocated;
 169   return ring_buffer_->Alloc(*size_allocated);
 170 }
 171
 172 void* TransferBuffer::Alloc(unsigned int size) {
 173   ReallocateRingBuffer(size);
 174
 175   if (!HaveBuffer()) {
 176     return NULL;
 177   }
 178
 179   unsigned int max_size = ring_buffer_->GetLargestFreeOrPendingSize();
 180   if (size > max_size) {
 181     return NULL;
 182   }
 183
 184   bytes_since_last_flush_ += size;
 185   return ring_buffer_->Alloc(size);
 186 }
 187
 188 void* TransferBuffer::GetResultBuffer() {
 189   ReallocateRingBuffer(result_size_);
 190   return result_buffer_;
 191 }
 192
 193 int TransferBuffer::GetResultOffset() {
 194   ReallocateRingBuffer(result_size_);
 195   return result_shm_offset_;
 196 }
 197
 198 int TransferBuffer::GetShmId() {
 199   ReallocateRingBuffer(result_size_);
 200   return buffer_id_;
 201 }
 202
 203 unsigned int TransferBuffer::GetCurrentMaxAllocationWithoutRealloc() const {
 204   return HaveBuffer() ? ring_buffer_->GetLargestFreeOrPendingSize() : 0;
 205 }
 206
 207 unsigned int TransferBuffer::GetMaxAllocation() const {
 208   return HaveBuffer() ? max_buffer_size_ - result_size_ : 0;
 209 }
 210
 211 void ScopedTransferBufferPtr::Release() {
 212   if (buffer_) {
 213     transfer_buffer_->FreePendingToken(buffer_, helper_->InsertToken());
 214     buffer_ = NULL;
 215     size_ = 0;
 216   }
 217 }
 218
 219 void ScopedTransferBufferPtr::Reset(unsigned int new_size) {
 220   Release();
 221   // NOTE: we allocate buffers of size 0 so that HaveBuffer will be true, so
 222   // that address will return a pointer just like malloc, and so that GetShmId
 223   // will be valid. That has the side effect that we'll insert a token on free.
 224   // We could add code skip the token for a zero size buffer but it doesn't seem
 225   // worth the complication.
 226   buffer_ = transfer_buffer_->AllocUpTo(new_size, &size_);
 227 }
 228
 229 }  // namespace gpu