kc3-lang/angle/src/libANGLE/renderer/BufferImpl.h

• Show log

  Commit

• Hash : 3bbdee0f
  Author :
  Date : 2025-03-28T11:55:24
  

  Vulkan: Remove Subject/Observer from BufferImpl
  
  Right now the gl::Buffer back end send message to the front end and then
  gl::Buffer propagate the message to the observers (vertex array,
  textures, transform feedback). We are seeing many of these kind of
  message passing (mainly to vertexArray), and each message is a virtual
  function call. The message call also lacks of context information that
  we can not do certain optimizations. This CL adopts the new API feedback
  argument approach for buffer APIs from the back end to the front end.
  The only difficulty I ran into is D3D backend where the message could be
  delivered from draw calls. For now the subject/observer code path is
  still kept in the gl::Buffer, but no back end will use it except D3D11.
  That will be removed in the later CL when D3D11 switch to use feedback
  mechanism.
  
  BYPASS_LARGE_CHANGE_WARNING
  
  Bug: angleproject:400711938
  Change-Id: I5fb3b660fd4260b9ba691239ad777b575b31e2ab
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6408892
  Commit-Queue: Charlie Lao <cclao@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/BufferImpl.h

• //
  // 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.
  //
  
  // BufferImpl.h: Defines the abstract rx::BufferImpl class.
  
  #ifndef LIBANGLE_RENDERER_BUFFERIMPL_H_
  #define LIBANGLE_RENDERER_BUFFERIMPL_H_
  
  #include "common/PackedEnums.h"
  #include "common/angleutils.h"
  #include "common/mathutil.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/Observer.h"
  #include "libANGLE/angletypes.h"
  
  #include <stdint.h>
  
  namespace gl
  {
  class BufferState;
  class Context;
  }  // namespace gl
  
  namespace rx
  {
  struct BufferFeedback
  {
      bool hasFeedback() const { return internalMemoryAllocationChanged || bufferStateChanged; }
      // buffer's backend storage was reallocated due to optimizations to prevent having to flush
      // pending commands and waiting for the GPU to become idle.
      bool internalMemoryAllocationChanged = false;
      // The buffer's state (size, storage etc) have changed.
      bool bufferStateChanged = false;
  };
  // We use two set of Subject messages. The CONTENTS_CHANGED message is signaled whenever data
  // changes, to trigger re-translation or other events. Some buffers only need to be updated when the
  // underlying driver object changes - this is notified via the STORAGE_CHANGED message.
  class BufferImpl : public angle::Subject
  {
    public:
      BufferImpl(const gl::BufferState &state) : mState(state) {}
      virtual ~BufferImpl() override {}
      virtual void destroy(const gl::Context *context) {}
  
      virtual angle::Result setDataWithUsageFlags(const gl::Context *context,
                                                  gl::BufferBinding target,
                                                  GLeglClientBufferEXT clientBuffer,
                                                  const void *data,
                                                  size_t size,
                                                  gl::BufferUsage usage,
                                                  GLbitfield flags,
                                                  gl::BufferStorage bufferStorage,
                                                  BufferFeedback *feedback);
      virtual angle::Result setData(const gl::Context *context,
                                    gl::BufferBinding target,
                                    const void *data,
                                    size_t size,
                                    gl::BufferUsage usage,
                                    BufferFeedback *feedback)     = 0;
      virtual angle::Result setSubData(const gl::Context *context,
                                       gl::BufferBinding target,
                                       const void *data,
                                       size_t size,
                                       size_t offset,
                                       BufferFeedback *feedback)  = 0;
      virtual angle::Result copySubData(const gl::Context *context,
                                        BufferImpl *source,
                                        GLintptr sourceOffset,
                                        GLintptr destOffset,
                                        GLsizeiptr size,
                                        BufferFeedback *feedback) = 0;
      virtual angle::Result map(const gl::Context *context,
                                GLenum access,
                                void **mapPtr,
                                BufferFeedback *feedback)         = 0;
      virtual angle::Result mapRange(const gl::Context *context,
                                     size_t offset,
                                     size_t length,
                                     GLbitfield access,
                                     void **mapPtr,
                                     BufferFeedback *feedback)    = 0;
      virtual angle::Result unmap(const gl::Context *context,
                                  GLboolean *result,
                                  BufferFeedback *feedback)       = 0;
  
      virtual angle::Result getIndexRange(const gl::Context *context,
                                          gl::DrawElementsType type,
                                          size_t offset,
                                          size_t count,
                                          bool primitiveRestartEnabled,
                                          gl::IndexRange *outRange) = 0;
  
      virtual angle::Result getSubData(const gl::Context *context,
                                       GLintptr offset,
                                       GLsizeiptr size,
                                       void *outData);
  
      virtual angle::Result onLabelUpdate(const gl::Context *context);
  
      // Override if accurate native memory size information is available
      virtual GLint64 getMemorySize() const;
  
      virtual void onDataChanged() {}
  
    protected:
      const gl::BufferState &mState;
  };
  
  inline GLint64 BufferImpl::getMemorySize() const
  {
      return 0;
  }
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_BUFFERIMPL_H_
  

Download