gpu/command_buffer/client/transfer_buffer.h

   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 #ifndef GPU_COMMAND_BUFFER_CLIENT_TRANSFER_BUFFER_H_
   6 #define GPU_COMMAND_BUFFER_CLIENT_TRANSFER_BUFFER_H_
   7
   8 #include "base/compiler_specific.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "gpu/command_buffer/client/ring_buffer.h"
  11 #include "gpu/command_buffer/common/buffer.h"
  12 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
  13 #include "gpu/gpu_export.h"
  14
  15 namespace gpu {
  16
  17 class CommandBufferHelper;
  18
  19 // Interface for managing the transfer buffer.
  20 class GPU_EXPORT TransferBufferInterface {
  21  public:
  22   TransferBufferInterface() { }
  23   virtual ~TransferBufferInterface() { }
  24
  25   virtual bool Initialize(
  26       unsigned int buffer_size,
  27       unsigned int result_size,
  28       unsigned int min_buffer_size,
  29       unsigned int max_buffer_size,
  30       unsigned int alignment,
  31       unsigned int size_to_flush) = 0;
  32
  33   virtual int GetShmId() = 0;
  34   virtual void* GetResultBuffer() = 0;
  35   virtual int GetResultOffset() = 0;
  36
  37   virtual void Free() = 0;
  38
  39   virtual bool HaveBuffer() const = 0;
  40
  41   // Allocates up to size bytes.
  42   virtual void* AllocUpTo(unsigned int size, unsigned int* size_allocated) = 0;
  43
  44   // Allocates size bytes.
  45   // Note: Alloc will fail if it can not return size bytes.
  46   virtual void* Alloc(unsigned int size) = 0;
  47
  48   virtual RingBuffer::Offset GetOffset(void* pointer) const = 0;
  49
  50   virtual void DiscardBlock(void* p) = 0;
  51
  52   virtual void FreePendingToken(void* p, unsigned int token) = 0;
  53
  54   virtual unsigned int GetSize() const = 0;
  55
  56   virtual unsigned int GetFreeSize() const = 0;
  57 };
  58
  59 // Class that manages the transfer buffer.
  60 class GPU_EXPORT TransferBuffer : public TransferBufferInterface {
  61  public:
  62   TransferBuffer(CommandBufferHelper* helper);
  63   ~TransferBuffer() override;
  64
  65   // Overridden from TransferBufferInterface.
  66   bool Initialize(unsigned int default_buffer_size,
  67                   unsigned int result_size,
  68                   unsigned int min_buffer_size,
  69                   unsigned int max_buffer_size,
  70                   unsigned int alignment,
  71                   unsigned int size_to_flush) override;
  72   int GetShmId() override;
  73   void* GetResultBuffer() override;
  74   int GetResultOffset() override;
  75   void Free() override;
  76   bool HaveBuffer() const override;
  77   void* AllocUpTo(unsigned int size, unsigned int* size_allocated) override;
  78   void* Alloc(unsigned int size) override;
  79   RingBuffer::Offset GetOffset(void* pointer) const override;
  80   void DiscardBlock(void* p) override;
  81   void FreePendingToken(void* p, unsigned int token) override;
  82   unsigned int GetSize() const override;
  83   unsigned int GetFreeSize() const override;
  84
  85   // These are for testing.
  86   unsigned int GetCurrentMaxAllocationWithoutRealloc() const;
  87   unsigned int GetMaxAllocation() const;
  88
  89  private:
  90   // Tries to reallocate the ring buffer if it's not large enough for size.
  91   void ReallocateRingBuffer(unsigned int size);
  92
  93   void AllocateRingBuffer(unsigned int size);
  94
  95   CommandBufferHelper* helper_;
  96   scoped_ptr<RingBuffer> ring_buffer_;
  97
  98   // size reserved for results
  99   unsigned int result_size_;
 100
 101   // default size. Size we want when starting or re-allocating
 102   unsigned int default_buffer_size_;
 103
 104   // min size we'll consider successful
 105   unsigned int min_buffer_size_;
 106
 107   // max size we'll let the buffer grow
 108   unsigned int max_buffer_size_;
 109
 110   // alignment for allocations
 111   unsigned int alignment_;
 112
 113   // Size at which to do an async flush. 0 = never.
 114   unsigned int size_to_flush_;
 115
 116   // Number of bytes since we last flushed.
 117   unsigned int bytes_since_last_flush_;
 118
 119   // the current buffer.
 120   scoped_refptr<gpu::Buffer> buffer_;
 121
 122   // id of buffer. -1 = no buffer
 123   int32 buffer_id_;
 124
 125   // address of result area
 126   void* result_buffer_;
 127
 128   // offset to result area
 129   uint32 result_shm_offset_;
 130
 131   // false if we failed to allocate min_buffer_size
 132   bool usable_;
 133 };
 134
 135 // A class that will manage the lifetime of a transferbuffer allocation.
 136 class GPU_EXPORT ScopedTransferBufferPtr {
 137  public:
 138   ScopedTransferBufferPtr(
 139       unsigned int size,
 140       CommandBufferHelper* helper,
 141       TransferBufferInterface* transfer_buffer)
 142       : buffer_(NULL),
 143         size_(0),
 144         helper_(helper),
 145         transfer_buffer_(transfer_buffer) {
 146     Reset(size);
 147   }
 148
 149   ~ScopedTransferBufferPtr() {
 150     Release();
 151   }
 152
 153   bool valid() const {
 154     return buffer_ != NULL;
 155   }
 156
 157   unsigned int size() const {
 158     return size_;
 159   }
 160
 161   int shm_id() const {
 162     return transfer_buffer_->GetShmId();
 163   }
 164
 165   RingBuffer::Offset offset() const {
 166     return transfer_buffer_->GetOffset(buffer_);
 167   }
 168
 169   void* address() const {
 170     return buffer_;
 171   }
 172
 173   void Release();
 174
 175   void Discard();
 176
 177   void Reset(unsigned int new_size);
 178
 179  private:
 180   void* buffer_;
 181   unsigned int size_;
 182   CommandBufferHelper* helper_;
 183   TransferBufferInterface* transfer_buffer_;
 184   DISALLOW_COPY_AND_ASSIGN(ScopedTransferBufferPtr);
 185 };
 186
 187 template <typename T>
 188 class ScopedTransferBufferArray : public ScopedTransferBufferPtr {
 189  public:
 190   ScopedTransferBufferArray(
 191       unsigned int num_elements,
 192       CommandBufferHelper* helper, TransferBufferInterface* transfer_buffer)
 193       : ScopedTransferBufferPtr(
 194           num_elements * sizeof(T), helper, transfer_buffer) {
 195   }
 196
 197   T* elements() {
 198     return static_cast<T*>(address());
 199   }
 200
 201   unsigned int num_elements() const {
 202     return size() / sizeof(T);
 203   }
 204 };
 205
 206 }  // namespace gpu
 207
 208 #endif  // GPU_COMMAND_BUFFER_CLIENT_TRANSFER_BUFFER_H_