kc3-lang/angle/src/compiler/translator/tree_util/SpecializationConstant.cpp

• Show log

  Commit

• Hash : 23f213d1
  Author :
  Date : 2022-05-26T23:43:44
  

  Vulkan: Make drawable size uniform
  
  As a specialization constant, it's impossible to predict the value the
  drawable size may take, which in turn makes it impossible to warm up the
  Vulkan pipeline cache at link time.
  
  Bug: angleproject:7366
  Change-Id: Ia3d1860a4fcb8e3078fdcb8d02a2e0cd173ea028
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3671976
  Reviewed-by: Charlie Lao <cclao@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/compiler/translator/tree_util/SpecializationConstant.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.
  //
  // SpecializationConst.cpp: Add code to generate AST node for various specialization constants.
  //
  
  #include "compiler/translator/tree_util/SpecializationConstant.h"
  #include "common/PackedEnums.h"
  #include "common/angleutils.h"
  #include "compiler/translator/StaticType.h"
  #include "compiler/translator/SymbolTable.h"
  #include "compiler/translator/tree_util/IntermNode_util.h"
  
  namespace sh
  {
  
  namespace
  {
  // Specialization constant names
  constexpr ImmutableString kLineRasterEmulationSpecConstVarName =
      ImmutableString("ANGLELineRasterEmulation");
  constexpr ImmutableString kSurfaceRotationSpecConstVarName =
      ImmutableString("ANGLESurfaceRotation");
  constexpr ImmutableString kDitherSpecConstVarName = ImmutableString("ANGLEDither");
  
  const TType *MakeSpecConst(const TType &type, vk::SpecializationConstantId id)
  {
      // Create a new type with the EvqSpecConst qualifier
      TType *specConstType = new TType(type);
      specConstType->setQualifier(EvqSpecConst);
  
      // Set the constant_id of the spec const
      TLayoutQualifier layoutQualifier = TLayoutQualifier::Create();
      layoutQualifier.location         = static_cast<int>(id);
      specConstType->setLayoutQualifier(layoutQualifier);
  
      return specConstType;
  }
  }  // anonymous namespace
  
  SpecConst::SpecConst(TSymbolTable *symbolTable, ShCompileOptions compileOptions, GLenum shaderType)
      : mSymbolTable(symbolTable),
        mCompileOptions(compileOptions),
        mLineRasterEmulationVar(nullptr),
        mSurfaceRotationVar(nullptr),
        mDitherVar(nullptr)
  {
      if (shaderType == GL_FRAGMENT_SHADER || shaderType == GL_COMPUTE_SHADER)
      {
          return;
      }
  
      // Mark SpecConstUsage::Rotation unconditionally.  gl_Position is always rotated.
      if ((mCompileOptions & SH_USE_SPECIALIZATION_CONSTANT) != 0)
      {
          mUsageBits.set(vk::SpecConstUsage::Rotation);
      }
  }
  
  SpecConst::~SpecConst() {}
  
  void SpecConst::declareSpecConsts(TIntermBlock *root)
  {
      // Add specialization constant declarations.  The default value of the specialization
      // constant is irrelevant, as it will be set when creating the pipeline.
      // Only emit specialized const declaration if it has been referenced.
      if (mLineRasterEmulationVar != nullptr)
      {
          TIntermDeclaration *decl = new TIntermDeclaration();
          decl->appendDeclarator(
              new TIntermBinary(EOpInitialize, getLineRasterEmulation(), CreateBoolNode(false)));
  
          root->insertStatement(0, decl);
      }
  
      if (mSurfaceRotationVar != nullptr)
      {
          TIntermDeclaration *decl = new TIntermDeclaration();
          decl->appendDeclarator(
              new TIntermBinary(EOpInitialize, getRotation(), CreateBoolNode(false)));
  
          root->insertStatement(0, decl);
      }
  
      if (mDitherVar != nullptr)
      {
          TIntermDeclaration *decl = new TIntermDeclaration();
          decl->appendDeclarator(new TIntermBinary(EOpInitialize, getDither(), CreateUIntNode(0)));
  
          root->insertStatement(0, decl);
      }
  }
  
  TIntermSymbol *SpecConst::getLineRasterEmulation()
  {
      if ((mCompileOptions & SH_ADD_BRESENHAM_LINE_RASTER_EMULATION) == 0)
      {
          return nullptr;
      }
      if (mLineRasterEmulationVar == nullptr)
      {
          const TType *type = MakeSpecConst(*StaticType::GetBasic<EbtBool, EbpUndefined>(),
                                            vk::SpecializationConstantId::LineRasterEmulation);
  
          mLineRasterEmulationVar = new TVariable(mSymbolTable, kLineRasterEmulationSpecConstVarName,
                                                  type, SymbolType::AngleInternal);
          mUsageBits.set(vk::SpecConstUsage::LineRasterEmulation);
      }
      return new TIntermSymbol(mLineRasterEmulationVar);
  }
  
  TIntermSymbol *SpecConst::getRotation()
  {
      if (mSurfaceRotationVar == nullptr)
      {
          const TType *type = MakeSpecConst(*StaticType::GetBasic<EbtBool, EbpUndefined>(),
                                            vk::SpecializationConstantId::SurfaceRotation);
  
          mSurfaceRotationVar = new TVariable(mSymbolTable, kSurfaceRotationSpecConstVarName, type,
                                              SymbolType::AngleInternal);
      }
      return new TIntermSymbol(mSurfaceRotationVar);
  }
  
  TIntermTyped *SpecConst::getSwapXY()
  {
      if ((mCompileOptions & SH_USE_SPECIALIZATION_CONSTANT) == 0)
      {
          return nullptr;
      }
      mUsageBits.set(vk::SpecConstUsage::Rotation);
      return getRotation();
  }
  
  TIntermTyped *SpecConst::getDither()
  {
      if (mDitherVar == nullptr)
      {
          const TType *type = MakeSpecConst(*StaticType::GetBasic<EbtUInt, EbpHigh>(),
                                            vk::SpecializationConstantId::Dither);
  
          mDitherVar =
              new TVariable(mSymbolTable, kDitherSpecConstVarName, type, SymbolType::AngleInternal);
          mUsageBits.set(vk::SpecConstUsage::Dither);
      }
      return new TIntermSymbol(mDitherVar);
  }
  }  // namespace sh
  

Download