kc3-lang/angle/src/common/RingBufferAllocator.h

• Show log

  Commit

• Hash : c3a1cae4
  Author :
  Date : 2024-04-15T14:58:55
  

  Use angle::SimpleMutex everywhere in libGLESv2
  
  Only cases left that use std::mutex are:
  
  - Share group and the context ErrorSet mutexes as they need try_lock()
  - Anywhere mutexes are used in conjunction with std::condition_variables
    (as they explicitly require std::mutex)
  
  Bug: angleproject:8667
  Change-Id: Ib6d68938b0886f9e7c43e023162557990ecfb300
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5453294
  Reviewed-by: Roman Lavrov <romanl@google.com>
  Reviewed-by: Charlie Lao <cclao@google.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/common/RingBufferAllocator.h

• //
  // Copyright 2022 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.
  //
  // RingBufferAllocator.h:
  //    Classes used to implement ring buffer allocators.
  //
  
  #ifndef COMMON_RING_BUFFER_ALLOCATOR_H_
  #define COMMON_RING_BUFFER_ALLOCATOR_H_
  
  #include "angleutils.h"
  #include "common/SimpleMutex.h"
  #include "common/debug.h"
  
  #include <atomic>
  
  namespace angle
  {
  
  static constexpr uint32_t kMinRingBufferAllocationCapacity = 1024;
  static constexpr uint32_t kDefaultDecaySpeedFactor         = 10;
  
  // Only called from RingBufferAllocator::allocate(). Other function may also change the fragment.
  class RingBufferAllocateListener
  {
    public:
      virtual void onRingBufferNewFragment() = 0;
      virtual void onRingBufferFragmentEnd() = 0;
  
    protected:
      ~RingBufferAllocateListener() = default;
  };
  
  class RingBufferAllocatorCheckPoint final
  {
    public:
      void reset() { *this = {}; }
      bool valid() const { return (mReleasePtr != nullptr); }
  
    private:
      friend class RingBufferAllocator;
      uint64_t mBufferId   = 0;
      uint8_t *mReleasePtr = nullptr;
  };
  
  class RingBufferAllocatorBuffer final
  {
    public:
      static constexpr uint32_t kBaseOffset = alignof(std::max_align_t);
  
      void resize(uint32_t size) { mStorage.resize(size + kBaseOffset); }
      uint8_t *data() { return mStorage.data() + kBaseOffset; }
  
      uint8_t *decClamped(uint8_t *ptr, uint32_t offset) const
      {
          ASSERT(ptr >= mStorage.data() + kBaseOffset && ptr <= mStorage.data() + mStorage.size());
          return ptr - std::min(offset, static_cast<uint32_t>(ptr - mStorage.data()));
      }
  
      uint64_t getId() const { return mId; }
      void resetId() { mId = 0; }
      void incrementId() { ++mId; }
  
      bool isEmpty() const { return mStorage.empty(); }
  
    private:
      uint64_t mId = 0;
      std::vector<uint8_t> mStorage;
  };
  
  class RingBufferAllocator final : angle::NonCopyable
  {
    public:
      RingBufferAllocator() = default;
      RingBufferAllocator(RingBufferAllocator &&other);
      RingBufferAllocator &operator=(RingBufferAllocator &&other);
  
      void reset();
      bool valid() const { return (getPointer() != nullptr); }
  
      void setListener(RingBufferAllocateListener *listener);
  
      void setDecaySpeedFactor(uint32_t decaySpeedFactor);
  
      void setFragmentReserve(uint32_t reserve);
  
      uint8_t *allocate(uint32_t size)
      {
          ASSERT(valid());
          if (ANGLE_LIKELY(mFragmentEndR - mDataEnd >= static_cast<ptrdiff_t>(size)))
          {
              uint8_t *const result = mDataEnd;
              mDataEnd              = result + size;
              return result;
          }
          return allocateInNewFragment(size);
      }
  
      uint8_t *getPointer() const { return mDataEnd; }
      uint32_t getFragmentSize() const
      {
          ASSERT(mFragmentEnd >= mDataEnd);
          return static_cast<uint32_t>(mFragmentEnd - mDataEnd);
      }
  
      RingBufferAllocatorCheckPoint getReleaseCheckPoint() const;
      void release(const RingBufferAllocatorCheckPoint &checkPoint);
  
    private:
      void release(uint8_t *releasePtr);
      uint32_t getNumAllocatedInBuffer() const;
      void resetPointers();
  
      uint8_t *allocateInNewFragment(uint32_t size);
      void resize(uint32_t newCapacity);
  
      RingBufferAllocateListener *mListener = nullptr;
  
      std::vector<RingBufferAllocatorBuffer> mOldBuffers;
      RingBufferAllocatorBuffer mBuffer;
      uint8_t *mDataBegin       = nullptr;
      uint8_t *mDataEnd         = nullptr;
      uint8_t *mFragmentEnd     = nullptr;
      uint8_t *mFragmentEndR    = nullptr;
      uint32_t mFragmentReserve = 0;
  
      uint32_t mMinCapacity      = 0;
      uint32_t mCurrentCapacity  = 0;
      uint32_t mAllocationMargin = 0;
  
      // 1 - fastest decay speed.
      // 2 - 2x slower than fastest, and so on.
      uint32_t mDecaySpeedFactor = 0;
  };
  
  class SharedRingBufferAllocatorCheckPoint final : angle::NonCopyable
  {
    public:
      void releaseAndUpdate(RingBufferAllocatorCheckPoint *newValue);
  
    private:
      friend class SharedRingBufferAllocator;
      RingBufferAllocatorCheckPoint pop();
      angle::SimpleMutex mMutex;
      RingBufferAllocatorCheckPoint mValue;
  
  #if defined(ANGLE_ENABLE_ASSERTS)
      std::atomic<uint32_t> mRefCount{1};
  #endif
  };
  
  class SharedRingBufferAllocator final : angle::NonCopyable
  {
    public:
      SharedRingBufferAllocator();
      ~SharedRingBufferAllocator();
  
      RingBufferAllocator &get() { return mAllocator; }
  
      // Once shared - always shared
      bool isShared() const { return mSharedCP != nullptr; }
  
      // Once acquired must be released with releaseAndUpdate().
      SharedRingBufferAllocatorCheckPoint *acquireSharedCP();
      void releaseToSharedCP();
  
    private:
      RingBufferAllocator mAllocator;
      SharedRingBufferAllocatorCheckPoint *mSharedCP = nullptr;
  };
  
  }  // namespace angle
  
  #endif  // COMMON_RING_BUFFER_ALLOCATOR_H_
  

Download