kc3-lang/angle/src/libANGLE/Uniform.cpp

• Show log

  Commit

• Hash : 01f629e3
  Author :
  Date : 2023-05-26T10:23:20
  

  Vulkan: Remove the loop when calling updateShaderBuffers
  
  Right now there is a loop of getLinkedShaderStages when calling
  mShaderBuffersDescriptorDesc.updateShaderBuffers. The shaderType
  variable is only used to check if block is active or not, and get
  info.binding. They can be retrieved without loop of shaderType. This CL
  removes the loop so that we call
  DescriptorSetDescBuilder::updateShaderBuffers only once. Similar thing
  is applied to atomic counter buffer and images.
  
  Bug: b/282194402
  Change-Id: I03f3b4a391e773dfc162877802a2f940311866b8
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4554625
  Commit-Queue: Charlie Lao <cclao@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/Uniform.cpp

• //
  // Copyright 2010 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 "libANGLE/Uniform.h"
  
  #include <cstring>
  
  namespace gl
  {
  
  ActiveVariable::ActiveVariable() {}
  
  ActiveVariable::~ActiveVariable() {}
  
  ActiveVariable::ActiveVariable(const ActiveVariable &rhs)            = default;
  ActiveVariable &ActiveVariable::operator=(const ActiveVariable &rhs) = default;
  
  void ActiveVariable::setActive(ShaderType shaderType, bool used)
  {
      ASSERT(shaderType != ShaderType::InvalidEnum);
      mActiveUseBits.set(shaderType, used);
  }
  
  void ActiveVariable::unionReferencesWith(const ActiveVariable &other)
  {
      mActiveUseBits |= other.mActiveUseBits;
  }
  
  LinkedUniform::LinkedUniform()
      : typeInfo(nullptr),
        bufferIndex(-1),
        blockInfo(sh::kDefaultBlockMemberInfo),
        outerArrayOffset(0)
  {}
  
  LinkedUniform::LinkedUniform(GLenum typeIn,
                               GLenum precisionIn,
                               const std::string &nameIn,
                               const std::vector<unsigned int> &arraySizesIn,
                               const int bindingIn,
                               const int offsetIn,
                               const int locationIn,
                               const int bufferIndexIn,
                               const sh::BlockMemberInfo &blockInfoIn)
      : typeInfo(&GetUniformTypeInfo(typeIn)),
        bufferIndex(bufferIndexIn),
        blockInfo(blockInfoIn),
        outerArrayOffset(0)
  {
      type       = typeIn;
      precision  = precisionIn;
      name       = nameIn;
      arraySizes = arraySizesIn;
      binding    = bindingIn;
      offset     = offsetIn;
      location   = locationIn;
      ASSERT(!isArrayOfArrays());
      ASSERT(!isArray() || !isStruct());
  }
  
  LinkedUniform::LinkedUniform(const sh::ShaderVariable &uniform)
      : sh::ShaderVariable(uniform),
        typeInfo(&GetUniformTypeInfo(type)),
        bufferIndex(-1),
        blockInfo(sh::kDefaultBlockMemberInfo)
  {
      ASSERT(!isArrayOfArrays());
      ASSERT(!isArray() || !isStruct());
  }
  
  LinkedUniform::LinkedUniform(const LinkedUniform &uniform)
      : sh::ShaderVariable(uniform),
        ActiveVariable(uniform),
        typeInfo(uniform.typeInfo),
        bufferIndex(uniform.bufferIndex),
        blockInfo(uniform.blockInfo),
        outerArraySizes(uniform.outerArraySizes),
        outerArrayOffset(uniform.outerArrayOffset)
  {}
  
  LinkedUniform &LinkedUniform::operator=(const LinkedUniform &uniform)
  {
      sh::ShaderVariable::operator=(uniform);
      ActiveVariable::operator=(uniform);
      typeInfo         = uniform.typeInfo;
      bufferIndex      = uniform.bufferIndex;
      blockInfo        = uniform.blockInfo;
      outerArraySizes  = uniform.outerArraySizes;
      outerArrayOffset = uniform.outerArrayOffset;
      return *this;
  }
  
  LinkedUniform::~LinkedUniform() {}
  
  BufferVariable::BufferVariable()
      : bufferIndex(-1), blockInfo(sh::kDefaultBlockMemberInfo), topLevelArraySize(-1)
  {}
  
  BufferVariable::BufferVariable(GLenum typeIn,
                                 GLenum precisionIn,
                                 const std::string &nameIn,
                                 const std::vector<unsigned int> &arraySizesIn,
                                 const int bufferIndexIn,
                                 const sh::BlockMemberInfo &blockInfoIn)
      : bufferIndex(bufferIndexIn), blockInfo(blockInfoIn), topLevelArraySize(-1)
  {
      type       = typeIn;
      precision  = precisionIn;
      name       = nameIn;
      arraySizes = arraySizesIn;
  }
  
  BufferVariable::~BufferVariable() {}
  
  ShaderVariableBuffer::ShaderVariableBuffer() : binding(0), dataSize(0) {}
  
  ShaderVariableBuffer::ShaderVariableBuffer(const ShaderVariableBuffer &other) = default;
  
  ShaderVariableBuffer::~ShaderVariableBuffer() {}
  
  int ShaderVariableBuffer::numActiveVariables() const
  {
      return static_cast<int>(memberIndexes.size());
  }
  
  InterfaceBlock::InterfaceBlock() : isArray(false), isReadOnly(false), arrayElement(0) {}
  
  InterfaceBlock::InterfaceBlock(const std::string &nameIn,
                                 const std::string &mappedNameIn,
                                 bool isArrayIn,
                                 bool isReadOnlyIn,
                                 unsigned int arrayElementIn,
                                 unsigned int firstFieldArraySizeIn,
                                 int bindingIn)
      : name(nameIn),
        mappedName(mappedNameIn),
        isArray(isArrayIn),
        isReadOnly(isReadOnlyIn),
        arrayElement(arrayElementIn),
        firstFieldArraySize(firstFieldArraySizeIn)
  {
      binding = bindingIn;
  }
  
  InterfaceBlock::InterfaceBlock(const InterfaceBlock &other) = default;
  
  std::string InterfaceBlock::nameWithArrayIndex() const
  {
      std::stringstream fullNameStr;
      fullNameStr << name;
      if (isArray)
      {
          fullNameStr << "[" << arrayElement << "]";
      }
  
      return fullNameStr.str();
  }
  
  std::string InterfaceBlock::mappedNameWithArrayIndex() const
  {
      std::stringstream fullNameStr;
      fullNameStr << mappedName;
      if (isArray)
      {
          fullNameStr << "[" << arrayElement << "]";
      }
  
      return fullNameStr.str();
  }
  }  // namespace gl
  

Download