kc3-lang/angle/src/common/MemoryBuffer.cpp

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Geoff Lang
  Date : 2020-02-03 17:10:58
  Hash : aa6dd50d
  Message : Share scratch buffers between contexts. The Display now owns scratch buffers and loans them out to contexts while they are current. This allows us to to only allocate one scratch buffer in a single-threaded use case. Tick the scratch buffers every time a new context is made current. Lower the lifetime from 1000 to 64 to ensure that in the worst case, the buffers are cleared after not being used for ~1 second. BUG=chromium:1030835 BUG=angleproject:4363 Change-Id: I83552424e2beac62b9e41152876b04fc84f53692 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2031698 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: Zhenyao Mo <zmo@chromium.org>

• src/common/MemoryBuffer.cpp

• //
  // Copyright 2014 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  #include "common/MemoryBuffer.h"
  
  #include <algorithm>
  #include <cstdlib>
  
  #include "common/debug.h"
  
  namespace angle
  {
  
  // MemoryBuffer implementation.
  MemoryBuffer::~MemoryBuffer()
  {
      free(mData);
      mData = nullptr;
  }
  
  bool MemoryBuffer::resize(size_t size)
  {
      if (size == 0)
      {
          free(mData);
          mData = nullptr;
          mSize = 0;
          return true;
      }
  
      if (size == mSize)
      {
          return true;
      }
  
      // Only reallocate if the size has changed.
      uint8_t *newMemory = static_cast<uint8_t *>(malloc(sizeof(uint8_t) * size));
      if (newMemory == nullptr)
      {
          return false;
      }
  
      if (mData)
      {
          // Copy the intersection of the old data and the new data
          std::copy(mData, mData + std::min(mSize, size), newMemory);
          free(mData);
      }
  
      mData = newMemory;
      mSize = size;
  
      return true;
  }
  
  void MemoryBuffer::fill(uint8_t datum)
  {
      if (!empty())
      {
          std::fill(mData, mData + mSize, datum);
      }
  }
  
  MemoryBuffer::MemoryBuffer(MemoryBuffer &&other) : MemoryBuffer()
  {
      *this = std::move(other);
  }
  
  MemoryBuffer &MemoryBuffer::operator=(MemoryBuffer &&other)
  {
      std::swap(mSize, other.mSize);
      std::swap(mData, other.mData);
      return *this;
  }
  
  namespace
  {
  static constexpr uint32_t kDefaultScratchBufferLifetime = 1000u;
  
  }  // anonymous namespace
  
  // ScratchBuffer implementation.
  ScratchBuffer::ScratchBuffer() : ScratchBuffer(kDefaultScratchBufferLifetime) {}
  
  ScratchBuffer::ScratchBuffer(uint32_t lifetime) : mLifetime(lifetime), mResetCounter(lifetime) {}
  
  ScratchBuffer::~ScratchBuffer() {}
  
  ScratchBuffer::ScratchBuffer(ScratchBuffer &&other)
  {
      *this = std::move(other);
  }
  
  ScratchBuffer &ScratchBuffer::operator=(ScratchBuffer &&other)
  {
      std::swap(mLifetime, other.mLifetime);
      std::swap(mResetCounter, other.mResetCounter);
      std::swap(mScratchMemory, other.mScratchMemory);
      return *this;
  }
  
  bool ScratchBuffer::get(size_t requestedSize, MemoryBuffer **memoryBufferOut)
  {
      return getImpl(requestedSize, memoryBufferOut, Optional<uint8_t>::Invalid());
  }
  
  bool ScratchBuffer::getInitialized(size_t requestedSize,
                                     MemoryBuffer **memoryBufferOut,
                                     uint8_t initValue)
  {
      return getImpl(requestedSize, memoryBufferOut, Optional<uint8_t>(initValue));
  }
  
  bool ScratchBuffer::getImpl(size_t requestedSize,
                              MemoryBuffer **memoryBufferOut,
                              Optional<uint8_t> initValue)
  {
      if (mScratchMemory.size() == requestedSize)
      {
          mResetCounter    = mLifetime;
          *memoryBufferOut = &mScratchMemory;
          return true;
      }
  
      if (mScratchMemory.size() > requestedSize)
      {
          tick();
      }
  
      if (mScratchMemory.size() < requestedSize)
      {
          if (!mScratchMemory.resize(requestedSize))
          {
              return false;
          }
          mResetCounter = mLifetime;
          if (initValue.valid())
          {
              mScratchMemory.fill(initValue.value());
          }
      }
  
      ASSERT(mScratchMemory.size() >= requestedSize);
  
      *memoryBufferOut = &mScratchMemory;
      return true;
  }
  
  void ScratchBuffer::tick()
  {
      if (mResetCounter > 0)
      {
          --mResetCounter;
          if (mResetCounter == 0)
          {
              clear();
          }
      }
  }
  
  void ScratchBuffer::clear()
  {
      mResetCounter = mLifetime;
      if (mScratchMemory.size() > 0)
      {
          mScratchMemory.clear();
      }
  }
  
  }  // namespace angle