kc3-lang/angle/src/common/CompiledShaderState.h

• Show log

  Commit

• Hash : 68bfa1ed
  Author :
  Date : 2023-08-22T22:02:15
  

  Support for link to be entirely parallelized
  
  The link job is split as such:
  
  - Front-end link
  - Back-end link
  - Independent back-end link subtasks (typically native driver compile
    jobs)
  - Post-link finalization
  
  Each step depends on the previous.  These steps are executed as such:
  
  1. Program::link calls into ProgramImpl::link
    - ProgramImpl::link runs whatever needs the Context, such as releasing
      resources
    - ProgramImpl::link returns a LinkTask
  2. Program::link implements a closure that calls the front-end link and
     passes the results to the backend's LinkTask.
  3. The LinkTask potentially returns a set of LinkSubTasks to be
     scheduled by the worker pool
  4. Once the link is resolved, the post-link finalization is run
  
  In the above, steps 1 and 4 are done under the share group lock.  Steps
  2 and 3 can be done in threads or without holding the share group lock
  if the backend supports it.  Step 2 is not yet made independent of the
  Context on some backends, and a frontend feature is used to make that
  step either run on the main thread or as a worker thread.
  
  Bug: angleproject:8297
  Change-Id: I12f1e6bbaf365543dfcac969e166e0b5aa622104
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4808191
  Reviewed-by: Charlie Lao <cclao@google.com>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@google.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/common/CompiledShaderState.h

• //
  // Copyright 2022 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.
  //
  // CompiledShaderState.h:
  //   Defines a struct containing any data that is needed to build
  //   a ShaderState from a TCompiler.
  //
  
  #ifndef COMMON_COMPILEDSHADERSTATE_H_
  #define COMMON_COMPILEDSHADERSTATE_H_
  
  #include "common/BinaryStream.h"
  #include "common/Optional.h"
  #include "common/PackedEnums.h"
  
  #include <GLSLANG/ShaderLang.h>
  #include <GLSLANG/ShaderVars.h>
  
  #include <memory>
  #include <string>
  
  namespace sh
  {
  struct BlockMemberInfo;
  }
  
  namespace gl
  {
  
  // @todo this type is also defined in compiler/Compiler.h and libANGLE/renderer_utils.h. Move this
  // to a single common definition?
  using SpecConstUsageBits = angle::PackedEnumBitSet<sh::vk::SpecConstUsage, uint32_t>;
  
  // Helper functions for serializing shader variables
  void WriteShaderVar(gl::BinaryOutputStream *stream, const sh::ShaderVariable &var);
  void LoadShaderVar(gl::BinaryInputStream *stream, sh::ShaderVariable *var);
  
  void WriteShInterfaceBlock(gl::BinaryOutputStream *stream, const sh::InterfaceBlock &block);
  void LoadShInterfaceBlock(gl::BinaryInputStream *stream, sh::InterfaceBlock *block);
  
  bool CompareShaderVar(const sh::ShaderVariable &x, const sh::ShaderVariable &y);
  
  struct CompiledShaderState
  {
      CompiledShaderState(gl::ShaderType shaderType);
      ~CompiledShaderState();
  
      void buildCompiledShaderState(const ShHandle compilerHandle, const bool isBinaryOutput);
  
      void serialize(gl::BinaryOutputStream &stream) const;
      void deserialize(gl::BinaryInputStream &stream);
  
      const gl::ShaderType shaderType;
  
      bool successfullyCompiled;
  
      int shaderVersion;
      std::string translatedSource;
      sh::BinaryBlob compiledBinary;
      sh::WorkGroupSize localSize;
  
      std::vector<sh::ShaderVariable> inputVaryings;
      std::vector<sh::ShaderVariable> outputVaryings;
      std::vector<sh::ShaderVariable> uniforms;
      std::vector<sh::InterfaceBlock> uniformBlocks;
      std::vector<sh::InterfaceBlock> shaderStorageBlocks;
      std::vector<sh::ShaderVariable> allAttributes;
      std::vector<sh::ShaderVariable> activeAttributes;
      std::vector<sh::ShaderVariable> activeOutputVariables;
  
      bool hasClipDistance;
      bool hasDiscard;
      bool enablesPerSampleShading;
      gl::BlendEquationBitSet advancedBlendEquations;
      SpecConstUsageBits specConstUsageBits;
  
      // GL_OVR_multiview / GL_OVR_multiview2
      int numViews;
  
      // Geometry Shader
      Optional<gl::PrimitiveMode> geometryShaderInputPrimitiveType;
      Optional<gl::PrimitiveMode> geometryShaderOutputPrimitiveType;
      Optional<GLint> geometryShaderMaxVertices;
      int geometryShaderInvocations;
  
      // Tessellation Shader
      int tessControlShaderVertices;
      GLenum tessGenMode;
      GLenum tessGenSpacing;
      GLenum tessGenVertexOrder;
      GLenum tessGenPointMode;
  };
  
  using SharedCompiledShaderState = std::shared_ptr<CompiledShaderState>;
  }  // namespace gl
  
  #endif  // COMMON_COMPILEDSHADERSTATE_H_
  

Download