gfx/layers/mlgpu/SharedBufferMLGPU.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "SharedBufferMLGPU.h"
   8 #include "BufferCache.h"
   9 #include "MLGDevice.h"
  10
  11 namespace mozilla {
  12 namespace layers {
  13
  14 SharedBufferMLGPU::SharedBufferMLGPU(MLGDevice* aDevice, MLGBufferType aType,
  15                                      size_t aDefaultSize)
  16     : mDevice(aDevice),
  17       mType(aType),
  18       mDefaultSize(aDefaultSize),
  19       mCanUseOffsetAllocation(true),
  20       mCurrentPosition(0),
  21       mMaxSize(0),
  22       mMap(),
  23       mMapped(false),
  24       mBytesUsedThisFrame(0),
  25       mNumSmallFrames(0) {
  26   MOZ_COUNT_CTOR(SharedBufferMLGPU);
  27 }
  28
  29 SharedBufferMLGPU::~SharedBufferMLGPU() {
  30   MOZ_COUNT_DTOR(SharedBufferMLGPU);
  31   Unmap();
  32 }
  33
  34 bool SharedBufferMLGPU::Init() {
  35   // If we can't use buffer offset binding, we never allocated shared buffers.
  36   if (!mCanUseOffsetAllocation) {
  37     return true;
  38   }
  39
  40   // If we can use offset binding, allocate an initial shared buffer now.
  41   if (!GrowBuffer(mDefaultSize)) {
  42     return false;
  43   }
  44   return true;
  45 }
  46
  47 void SharedBufferMLGPU::Reset() {
  48   // We shouldn't be mapped here, but just in case, unmap now.
  49   Unmap();
  50   mBytesUsedThisFrame = 0;
  51
  52   // If we allocated a large buffer for a particularly heavy layer tree,
  53   // but have not used most of the buffer again for many frames, we
  54   // discard the buffer. This is to prevent having to perform large
  55   // pointless uploads after visiting a single havy page - it also
  56   // lessens ping-ponging between large and small buffers.
  57   if (mBuffer && (mBuffer->GetSize() > mDefaultSize * 4) &&
  58       mNumSmallFrames >= 10) {
  59     mBuffer = nullptr;
  60   }
  61
  62   // Note that we do not aggressively map a new buffer. There's no reason to,
  63   // and it'd cause unnecessary uploads when painting empty frames.
  64 }
  65
  66 bool SharedBufferMLGPU::EnsureMappedBuffer(size_t aBytes) {
  67   if (!mBuffer || (mMaxSize - mCurrentPosition < aBytes)) {
  68     if (!GrowBuffer(aBytes)) {
  69       return false;
  70     }
  71   }
  72   if (!mMapped && !Map()) {
  73     return false;
  74   }
  75   return true;
  76 }
  77
  78 // We don't want to cache large buffers, since it results in larger uploads
  79 // that might not be needed.
  80 static const size_t kMaxCachedBufferSize = 128 * 1024;
  81
  82 bool SharedBufferMLGPU::GrowBuffer(size_t aBytes) {
  83   // We only pre-allocate buffers if we can use offset allocation.
  84   MOZ_ASSERT(mCanUseOffsetAllocation);
  85
  86   // Unmap the previous buffer. This will retain mBuffer, but free up the
  87   // address space used by its mapping.
  88   Unmap();
  89
  90   size_t maybeSize = mDefaultSize;
  91   if (mBuffer) {
  92     // Try to first grow the previous allocation size.
  93     maybeSize = std::min(kMaxCachedBufferSize, mBuffer->GetSize() * 2);
  94   }
  95
  96   size_t bytes = std::max(aBytes, maybeSize);
  97   mBuffer = mDevice->CreateBuffer(mType, bytes, MLGUsage::Dynamic);
  98   if (!mBuffer) {
  99     return false;
 100   }
 101
 102   mCurrentPosition = 0;
 103   mMaxSize = mBuffer->GetSize();
 104   return true;
 105 }
 106
 107 void SharedBufferMLGPU::PrepareForUsage() {
 108   Unmap();
 109
 110   if (mBytesUsedThisFrame <= mDefaultSize) {
 111     mNumSmallFrames++;
 112   } else {
 113     mNumSmallFrames = 0;
 114   }
 115 }
 116
 117 bool SharedBufferMLGPU::Map() {
 118   MOZ_ASSERT(mBuffer);
 119   MOZ_ASSERT(!mMapped);
 120
 121   if (!mDevice->Map(mBuffer, MLGMapType::WRITE_DISCARD, &mMap)) {
 122     // Don't retain the buffer, it's useless if we can't map it.
 123     mBuffer = nullptr;
 124     return false;
 125   }
 126
 127   mCurrentPosition = 0;
 128   mMapped = true;
 129   return true;
 130 }
 131
 132 void SharedBufferMLGPU::Unmap() {
 133   if (!mMapped) {
 134     return;
 135   }
 136
 137   mBytesUsedThisFrame += mCurrentPosition;
 138
 139   mDevice->Unmap(mBuffer);
 140   mMap = MLGMappedResource();
 141   mMapped = false;
 142 }
 143
 144 uint8_t* SharedBufferMLGPU::GetBufferPointer(size_t aBytes,
 145                                              ptrdiff_t* aOutOffset,
 146                                              RefPtr<MLGBuffer>* aOutBuffer) {
 147   if (!EnsureMappedBuffer(aBytes)) {
 148     return nullptr;
 149   }
 150
 151   ptrdiff_t newPos = mCurrentPosition + aBytes;
 152   MOZ_ASSERT(size_t(newPos) <= mMaxSize);
 153
 154   *aOutOffset = mCurrentPosition;
 155   *aOutBuffer = mBuffer;
 156
 157   uint8_t* ptr = reinterpret_cast<uint8_t*>(mMap.mData) + mCurrentPosition;
 158   mCurrentPosition = newPos;
 159   return ptr;
 160 }
 161
 162 VertexBufferSection::VertexBufferSection()
 163     : mOffset(-1), mNumVertices(0), mStride(0) {}
 164
 165 void VertexBufferSection::Init(MLGBuffer* aBuffer, ptrdiff_t aOffset,
 166                                size_t aNumVertices, size_t aStride) {
 167   mBuffer = aBuffer;
 168   mOffset = aOffset;
 169   mNumVertices = aNumVertices;
 170   mStride = aStride;
 171 }
 172
 173 ConstantBufferSection::ConstantBufferSection()
 174     : mOffset(-1), mNumBytes(0), mNumItems(0) {}
 175
 176 void ConstantBufferSection::Init(MLGBuffer* aBuffer, ptrdiff_t aOffset,
 177                                  size_t aBytes, size_t aNumItems) {
 178   mBuffer = aBuffer;
 179   mOffset = aOffset;
 180   mNumBytes = aBytes;
 181   mNumItems = aNumItems;
 182 }
 183
 184 SharedVertexBuffer::SharedVertexBuffer(MLGDevice* aDevice, size_t aDefaultSize)
 185     : SharedBufferMLGPU(aDevice, MLGBufferType::Vertex, aDefaultSize) {}
 186
 187 bool SharedVertexBuffer::Allocate(VertexBufferSection* aHolder,
 188                                   size_t aNumItems, size_t aSizeOfItem,
 189                                   const void* aData) {
 190   RefPtr<MLGBuffer> buffer;
 191   ptrdiff_t offset;
 192   size_t bytes = aSizeOfItem * aNumItems;
 193   uint8_t* ptr = GetBufferPointer(bytes, &offset, &buffer);
 194   if (!ptr) {
 195     return false;
 196   }
 197
 198   memcpy(ptr, aData, bytes);
 199   aHolder->Init(buffer, offset, aNumItems, aSizeOfItem);
 200   return true;
 201 }
 202
 203 AutoBufferUploadBase::AutoBufferUploadBase() : mPtr(nullptr) {}
 204
 205 AutoBufferUploadBase::~AutoBufferUploadBase() {
 206   if (mBuffer) {
 207     UnmapBuffer();
 208   }
 209 }
 210
 211 void AutoBufferUploadBase::Init(void* aPtr, MLGDevice* aDevice,
 212                                 MLGBuffer* aBuffer) {
 213   MOZ_ASSERT(!mPtr && aPtr);
 214   mPtr = aPtr;
 215   mDevice = aDevice;
 216   mBuffer = aBuffer;
 217 }
 218
 219 SharedConstantBuffer::SharedConstantBuffer(MLGDevice* aDevice,
 220                                            size_t aDefaultSize)
 221     : SharedBufferMLGPU(aDevice, MLGBufferType::Constant, aDefaultSize) {
 222   mMaxConstantBufferBindSize = aDevice->GetMaxConstantBufferBindSize();
 223   mCanUseOffsetAllocation = aDevice->CanUseConstantBufferOffsetBinding();
 224 }
 225
 226 bool SharedConstantBuffer::Allocate(ConstantBufferSection* aHolder,
 227                                     AutoBufferUploadBase* aPtr,
 228                                     size_t aNumItems, size_t aSizeOfItem) {
 229   MOZ_ASSERT(aSizeOfItem % 16 == 0, "Items must be padded to 16 bytes");
 230
 231   size_t bytes = aNumItems * aSizeOfItem;
 232   if (bytes > mMaxConstantBufferBindSize) {
 233     gfxWarning()
 234         << "Attempted to allocate too many bytes into a constant buffer";
 235     return false;
 236   }
 237
 238   RefPtr<MLGBuffer> buffer;
 239   ptrdiff_t offset;
 240   if (!GetBufferPointer(aPtr, bytes, &offset, &buffer)) {
 241     return false;
 242   }
 243
 244   aHolder->Init(buffer, offset, bytes, aNumItems);
 245   return true;
 246 }
 247
 248 uint8_t* SharedConstantBuffer::AllocateNewBuffer(
 249     size_t aBytes, ptrdiff_t* aOutOffset, RefPtr<MLGBuffer>* aOutBuffer) {
 250   RefPtr<MLGBuffer> buffer;
 251   if (BufferCache* cache = mDevice->GetConstantBufferCache()) {
 252     buffer = cache->GetOrCreateBuffer(aBytes);
 253   } else {
 254     buffer = mDevice->CreateBuffer(MLGBufferType::Constant, aBytes,
 255                                    MLGUsage::Dynamic);
 256   }
 257   if (!buffer) {
 258     return nullptr;
 259   }
 260
 261   MLGMappedResource map;
 262   if (!mDevice->Map(buffer, MLGMapType::WRITE_DISCARD, &map)) {
 263     return nullptr;
 264   }
 265
 266   // Signal that offsetting is not supported.
 267   *aOutOffset = -1;
 268   *aOutBuffer = buffer;
 269   return reinterpret_cast<uint8_t*>(map.mData);
 270 }
 271
 272 void AutoBufferUploadBase::UnmapBuffer() { mDevice->Unmap(mBuffer); }
 273
 274 }  // namespace layers
 275 }  // namespace mozilla