kc3-lang/angle/src/compiler/translator/tree_ops/vulkan/RewriteInterpolateAtOffset.cpp

• Show log

  Commit

• Hash : 2df17a12
  Author :
  Date : 2022-05-25T16:18:37
  

  Vulkan: Pack driver uniforms
  
  Previously 5 vec4s were used for driver uniforms + 2 vec4s if
  specialization constants couldn't be supported.
  
  The driver uniforms are rearranged and packed such that only 2 vec4s are
  normally used, which include fallback for specialization constants as
  well.  In the future, most of the specialization constants may turn into
  uniforms, and this change prepares for that.
  
  Additional uniforms are used (3 vec4s) only if common extensions are
  missing; transform feedback and bresenham lines.
  
  This change makes it more practical for driver uniforms to be turned
  into push constants.  Additionally, these uniforms could potentially be
  loaded and cached at the beginning of the shader for more efficient
  memory access.
  
  On Pixel6, with this change, the traces show no difference in wall time.
  On most traces, CPU time shows up to ~7% improvement.
  
  Bug: angleproject:7366
  Change-Id: I0f47f863955af06a19c69d1f1d7c45b97d95476e
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3668151
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Charlie Lao <cclao@google.com>
  

Download

• src/compiler/translator/tree_ops/vulkan/RewriteInterpolateAtOffset.cpp

• //
  // Copyright 2020 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.
  //
  // Implementation of InterpolateAtOffset viewport transformation.
  // See header for more info.
  
  #include "compiler/translator/tree_ops/vulkan/RewriteInterpolateAtOffset.h"
  
  #include "common/angleutils.h"
  #include "compiler/translator/StaticType.h"
  #include "compiler/translator/SymbolTable.h"
  #include "compiler/translator/TranslatorVulkan.h"
  #include "compiler/translator/tree_util/DriverUniform.h"
  #include "compiler/translator/tree_util/IntermNode_util.h"
  #include "compiler/translator/tree_util/IntermTraverse.h"
  #include "compiler/translator/tree_util/SpecializationConstant.h"
  
  namespace sh
  {
  
  namespace
  {
  
  class Traverser : public TIntermTraverser
  {
    public:
      Traverser(TSymbolTable *symbolTable, SpecConst *specConst, const DriverUniform *driverUniforms);
  
      bool update(TCompiler *compiler, TIntermBlock *root);
  
    private:
      bool visitAggregate(Visit visit, TIntermAggregate *node) override;
  
      const TFunction *getRotateFunc();
  
      SpecConst *mSpecConst                = nullptr;
      const DriverUniform *mDriverUniforms = nullptr;
  
      TIntermFunctionDefinition *mRotateFunc = nullptr;
  };
  
  Traverser::Traverser(TSymbolTable *symbolTable,
                       SpecConst *specConst,
                       const DriverUniform *driverUniforms)
      : TIntermTraverser(true, false, false, symbolTable),
        mSpecConst(specConst),
        mDriverUniforms(driverUniforms)
  {}
  
  bool Traverser::update(TCompiler *compiler, TIntermBlock *root)
  {
      if (mRotateFunc != nullptr)
      {
          const size_t firstFunctionIndex = FindFirstFunctionDefinitionIndex(root);
          root->insertStatement(firstFunctionIndex, mRotateFunc);
      }
  
      return updateTree(compiler, root);
  }
  
  bool Traverser::visitAggregate(Visit visit, TIntermAggregate *node)
  {
      // Decide if the node represents the call of texelFetchOffset.
      if (!BuiltInGroup::IsBuiltIn(node->getOp()))
      {
          return true;
      }
  
      ASSERT(node->getFunction()->symbolType() == SymbolType::BuiltIn);
      if (node->getFunction()->name() != "interpolateAtOffset")
      {
          return true;
      }
  
      const TIntermSequence *sequence = node->getSequence();
      ASSERT(sequence->size() == 2u);
  
      // offset
      TIntermTyped *offsetNode = sequence->at(1)->getAsTyped();
      ASSERT(offsetNode->getType().getBasicType() == EbtFloat &&
             offsetNode->getType().getNominalSize() == 2);
  
      // Rotate the offset as necessary.
      const TFunction *rotateFunc = getRotateFunc();
  
      TIntermSequence args = {
          offsetNode,
      };
      TIntermTyped *correctedOffset = TIntermAggregate::CreateFunctionCall(*rotateFunc, &args);
      correctedOffset->setLine(offsetNode->getLine());
  
      // Replace the offset by the rotated one.
      queueReplacementWithParent(node, offsetNode, correctedOffset, OriginalNode::IS_DROPPED);
  
      return true;
  }
  
  const TFunction *Traverser::getRotateFunc()
  {
      if (mRotateFunc != nullptr)
      {
          return mRotateFunc->getFunction();
      }
  
      // The function prototype is vec2 ANGLERotateInterpolateOffset(vec2 offset)
      const TType *vec2Type = StaticType::GetBasic<EbtFloat, EbpMedium, 2>();
  
      TType *offsetType = new TType(*vec2Type);
      offsetType->setQualifier(EvqParamIn);
  
      TVariable *offsetParam = new TVariable(mSymbolTable, ImmutableString("offset"), offsetType,
                                             SymbolType::AngleInternal);
  
      TFunction *function =
          new TFunction(mSymbolTable, ImmutableString("ANGLERotateInterpolateOffset"),
                        SymbolType::AngleInternal, vec2Type, true);
      function->addParameter(offsetParam);
  
      // The function body is as such:
      //
      //     return (swap ? offset.yx : offset) * flip;
  
      TIntermTyped *swapXY = mSpecConst->getSwapXY();
      if (swapXY == nullptr)
      {
          swapXY = mDriverUniforms->getSwapXY();
      }
  
      TIntermTyped *flipXY = mDriverUniforms->getFlipXY(mSymbolTable, DriverUniformFlip::Fragment);
  
      TIntermSwizzle *offsetYX = new TIntermSwizzle(new TIntermSymbol(offsetParam), {1, 0});
  
      TIntermTyped *swapped = new TIntermTernary(swapXY, offsetYX, new TIntermSymbol(offsetParam));
      TIntermTyped *flipped = new TIntermBinary(EOpMul, swapped, flipXY);
      TIntermBranch *returnStatement = new TIntermBranch(EOpReturn, flipped);
  
      TIntermBlock *body = new TIntermBlock;
      body->appendStatement(returnStatement);
  
      mRotateFunc = new TIntermFunctionDefinition(new TIntermFunctionPrototype(function), body);
      return function;
  }
  
  }  // anonymous namespace
  
  bool RewriteInterpolateAtOffset(TCompiler *compiler,
                                  TIntermBlock *root,
                                  TSymbolTable *symbolTable,
                                  int shaderVersion,
                                  SpecConst *specConst,
                                  const DriverUniform *driverUniforms)
  {
      // interpolateAtOffset is only valid in GLSL 3.0 and later.
      if (shaderVersion < 300)
      {
          return true;
      }
  
      Traverser traverser(symbolTable, specConst, driverUniforms);
      root->traverse(&traverser);
      return traverser.update(compiler, root);
  }
  
  }  // namespace sh
  

Download