kc3-lang/angle/src/libANGLE/renderer/vulkan/BufferVk.h

• Show log

  Commit

• Hash : 60a8b593
  Author :
  Date : 2022-01-05T11:06:16
  

  Vulkan: Remove std::unique_ptr usage from BufferVk::mBuffer
  
  BufferVk::mBuffer is std::unique_ptr mostly because BufferHelper object
  itself does not support move assignment. Now crrev.com/c/3366855 added
  move assignment support, we can now use BufferHelper directly. The main
  downside I can see is that in BufferVk::ghostMappedBuffer() and
  BufferVk::acquireAndUpdate() functions where we have to use move
  assignment of mBuffer object, it becomes slightly more expensive than
  moving pointer. But switch to using BufferHelper directly makes code
  simpler and other access to mBuffer (which is more common usage)
  slightly cheaper by removing one pointer indirection.
  
  Bug: b/208323792
  Change-Id: Ia7e7731e284eb6c76db954fef194e9d1de82174b
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3362252
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Tim Van Patten <timvp@google.com>
  Commit-Queue: Charlie Lao <cclao@google.com>
  

Download

• src/libANGLE/renderer/vulkan/BufferVk.h

• //
  // Copyright 2016 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.
  //
  // BufferVk.h:
  //    Defines the class interface for BufferVk, implementing BufferImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_VULKAN_BUFFERVK_H_
  #define LIBANGLE_RENDERER_VULKAN_BUFFERVK_H_
  
  #include "libANGLE/Buffer.h"
  #include "libANGLE/Observer.h"
  #include "libANGLE/renderer/BufferImpl.h"
  #include "libANGLE/renderer/vulkan/vk_helpers.h"
  
  namespace rx
  {
  class RendererVk;
  
  // Conversion buffers hold translated index and vertex data.
  struct ConversionBuffer
  {
      ConversionBuffer(RendererVk *renderer,
                       VkBufferUsageFlags usageFlags,
                       size_t initialSize,
                       size_t alignment,
                       bool hostVisible);
      ~ConversionBuffer();
  
      ConversionBuffer(ConversionBuffer &&other);
  
      // One state value determines if we need to re-stream vertex data.
      bool dirty;
  
      // Where the conversion data is stored.
      std::unique_ptr<vk::BufferHelper> data;
  };
  
  enum class BufferUpdateType
  {
      StorageRedefined,
      ContentsUpdate,
  };
  
  VkBufferUsageFlags GetDefaultBufferUsageFlags(RendererVk *renderer);
  size_t GetDefaultBufferAlignment(RendererVk *renderer);
  
  class BufferVk : public BufferImpl
  {
    public:
      BufferVk(const gl::BufferState &state);
      ~BufferVk() override;
      void destroy(const gl::Context *context) override;
  
      angle::Result setExternalBufferData(const gl::Context *context,
                                          gl::BufferBinding target,
                                          GLeglClientBufferEXT clientBuffer,
                                          size_t size,
                                          VkMemoryPropertyFlags memoryPropertyFlags);
      angle::Result setDataWithUsageFlags(const gl::Context *context,
                                          gl::BufferBinding target,
                                          GLeglClientBufferEXT clientBuffer,
                                          const void *data,
                                          size_t size,
                                          gl::BufferUsage usage,
                                          GLbitfield flags) override;
      angle::Result setData(const gl::Context *context,
                            gl::BufferBinding target,
                            const void *data,
                            size_t size,
                            gl::BufferUsage usage) override;
      angle::Result setSubData(const gl::Context *context,
                               gl::BufferBinding target,
                               const void *data,
                               size_t size,
                               size_t offset) override;
      angle::Result copySubData(const gl::Context *context,
                                BufferImpl *source,
                                GLintptr sourceOffset,
                                GLintptr destOffset,
                                GLsizeiptr size) override;
      angle::Result map(const gl::Context *context, GLenum access, void **mapPtr) override;
      angle::Result mapRange(const gl::Context *context,
                             size_t offset,
                             size_t length,
                             GLbitfield access,
                             void **mapPtr) override;
      angle::Result unmap(const gl::Context *context, GLboolean *result) override;
      angle::Result getSubData(const gl::Context *context,
                               GLintptr offset,
                               GLsizeiptr size,
                               void *outData) override;
  
      angle::Result getIndexRange(const gl::Context *context,
                                  gl::DrawElementsType type,
                                  size_t offset,
                                  size_t count,
                                  bool primitiveRestartEnabled,
                                  gl::IndexRange *outRange) override;
  
      GLint64 getSize() const { return mState.getSize(); }
  
      void onDataChanged() override;
  
      vk::BufferHelper &getBuffer()
      {
          ASSERT(isBufferValid());
          // Always mark the BufferHelper as referenced by the GPU, whether or not there's a pending
          // submission, since this function is only called when trying to get the underlying
          // BufferHelper object so it can be used in a command.
          mHasBeenReferencedByGPU = true;
          return mBuffer;
      }
  
      bool isBufferValid() const { return mBuffer.valid(); }
      bool isCurrentlyInUse(ContextVk *contextVk) const;
  
      angle::Result mapImpl(ContextVk *contextVk, GLbitfield access, void **mapPtr);
      angle::Result mapRangeImpl(ContextVk *contextVk,
                                 VkDeviceSize offset,
                                 VkDeviceSize length,
                                 GLbitfield access,
                                 void **mapPtr);
      angle::Result unmapImpl(ContextVk *contextVk);
      angle::Result ghostMappedBuffer(ContextVk *contextVk,
                                      VkDeviceSize offset,
                                      VkDeviceSize length,
                                      GLbitfield access,
                                      void **mapPtr);
  
      ConversionBuffer *getVertexConversionBuffer(RendererVk *renderer,
                                                  angle::FormatID formatID,
                                                  GLuint stride,
                                                  size_t offset,
                                                  bool hostVisible);
  
    private:
      angle::Result updateBuffer(ContextVk *contextVk,
                                 const uint8_t *data,
                                 size_t size,
                                 size_t offset);
      angle::Result directUpdate(ContextVk *contextVk,
                                 const uint8_t *data,
                                 size_t size,
                                 size_t offset);
      angle::Result stagedUpdate(ContextVk *contextVk,
                                 const uint8_t *data,
                                 size_t size,
                                 size_t offset);
      angle::Result allocStagingBuffer(ContextVk *contextVk,
                                       vk::MemoryCoherency coherency,
                                       VkDeviceSize size,
                                       uint8_t **mapPtr);
      angle::Result flushStagingBuffer(ContextVk *contextVk, VkDeviceSize offset, VkDeviceSize size);
      angle::Result acquireAndUpdate(ContextVk *contextVk,
                                     const uint8_t *data,
                                     size_t updateSize,
                                     size_t offset,
                                     BufferUpdateType updateType);
      angle::Result setDataWithMemoryType(const gl::Context *context,
                                          gl::BufferBinding target,
                                          const void *data,
                                          size_t size,
                                          VkMemoryPropertyFlags memoryPropertyFlags,
                                          bool persistentMapRequired,
                                          gl::BufferUsage usage);
      angle::Result handleDeviceLocalBufferMap(ContextVk *contextVk,
                                               VkDeviceSize offset,
                                               VkDeviceSize size,
                                               uint8_t **mapPtr);
      angle::Result setDataImpl(ContextVk *contextVk,
                                const uint8_t *data,
                                size_t size,
                                size_t offset,
                                BufferUpdateType updateType);
      void release(ContextVk *context);
      void dataUpdated();
  
      angle::Result acquireBufferHelper(ContextVk *contextVk,
                                        size_t sizeInBytes,
                                        BufferUpdateType updateType);
  
      struct VertexConversionBuffer : public ConversionBuffer
      {
          VertexConversionBuffer(RendererVk *renderer,
                                 angle::FormatID formatIDIn,
                                 GLuint strideIn,
                                 size_t offsetIn,
                                 bool hostVisible);
          ~VertexConversionBuffer();
  
          VertexConversionBuffer(VertexConversionBuffer &&other);
  
          // The conversion is identified by the triple of {format, stride, offset}.
          angle::FormatID formatID;
          GLuint stride;
          size_t offset;
      };
  
      vk::BufferHelper mBuffer;
  
      uint32_t mMemoryTypeIndex;
      // Memory/Usage property that will be used for memory allocation.
      VkMemoryPropertyFlags mMemoryPropertyFlags;
  
      // The staging buffer to aid map operations. This is used when buffers are not host visible or
      // for performance optimization when only a smaller range of buffer is mapped.
      vk::BufferHelper mStagingBuffer;
  
      // A cache of converted vertex data.
      std::vector<VertexConversionBuffer> mVertexConversionBuffers;
  
      // Tracks whether mStagingBuffer has been mapped to user or not
      bool mIsStagingBufferMapped;
  
      // Tracks if BufferVk object has valid data or not.
      bool mHasValidData;
  
      // TODO: https://issuetracker.google.com/201826021 Remove this once we have a full fix.
      // Tracks if BufferVk's data is ever been referenced by GPU since new storage has been
      // allocated. Due to sub-allocation, we may get a new sub-allocated range in the same
      // BufferHelper object. Because we track GPU progress by the BufferHelper object, this flag will
      // help us to avoid detecting we are still GPU busy even though no one has used it yet since
      // we got last sub-allocation.
      bool mHasBeenReferencedByGPU;
  };
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_BUFFERVK_H_
  

Download