kc3-lang/angle/src/libANGLE/Shader.h

• Show log

  Commit

• Hash : 955adb77
  Author :
  Date : 2022-08-12T10:14:48
  

  Cache compiled shader
  
  By storing the compiled shader in the blob cache, the time to
  recompile the same shader is reduced.
  
  Based on work by <hckim.kim@samsung.com>
  
  Bug: angleproject:7036
  Change-Id: I884ae40e715c49a9ccd12903012e8327811e3557
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3808235
  Commit-Queue: Cody Northrop <cnorthrop@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  

Download

• src/libANGLE/Shader.h

• //
  // Copyright 2002 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.
  //
  
  // Shader.h: Defines the abstract gl::Shader class and its concrete derived
  // classes VertexShader and FragmentShader. Implements GL shader objects and
  // related functionality. [OpenGL ES 2.0.24] section 2.10 page 24 and section
  // 3.8 page 84.
  
  #ifndef LIBANGLE_SHADER_H_
  #define LIBANGLE_SHADER_H_
  
  #include <list>
  #include <memory>
  #include <string>
  #include <vector>
  
  #include <GLSLANG/ShaderLang.h>
  #include "angle_gl.h"
  
  #include "common/MemoryBuffer.h"
  #include "common/Optional.h"
  #include "common/angleutils.h"
  #include "libANGLE/BinaryStream.h"
  #include "libANGLE/Caps.h"
  #include "libANGLE/Compiler.h"
  #include "libANGLE/Debug.h"
  #include "libANGLE/angletypes.h"
  
  namespace rx
  {
  class GLImplFactory;
  class ShaderImpl;
  class ShaderSh;
  class WaitableCompileEvent;
  }  // namespace rx
  
  namespace angle
  {
  class WaitableEvent;
  class WorkerThreadPool;
  }  // namespace angle
  
  namespace gl
  {
  class CompileTask;
  class Context;
  class ShaderProgramManager;
  class State;
  class BinaryInputStream;
  class BinaryOutputStream;
  
  // We defer the compile until link time, or until properties are queried.
  enum class CompileStatus
  {
      NOT_COMPILED,
      COMPILE_REQUESTED,
      COMPILED,
  };
  
  class ShaderState final : angle::NonCopyable
  {
    public:
      ShaderState(ShaderType shaderType);
      ~ShaderState();
  
      const std::string &getLabel() const { return mLabel; }
  
      const std::string &getSource() const { return mSource; }
      bool isCompiledToBinary() const { return !mCompiledBinary.empty(); }
      const std::string &getTranslatedSource() const { return mTranslatedSource; }
      const sh::BinaryBlob &getCompiledBinary() const { return mCompiledBinary; }
  
      ShaderType getShaderType() const { return mShaderType; }
      int getShaderVersion() const { return mShaderVersion; }
  
      const std::vector<sh::ShaderVariable> &getInputVaryings() const { return mInputVaryings; }
      const std::vector<sh::ShaderVariable> &getOutputVaryings() const { return mOutputVaryings; }
      const std::vector<sh::ShaderVariable> &getUniforms() const { return mUniforms; }
      const std::vector<sh::InterfaceBlock> &getUniformBlocks() const { return mUniformBlocks; }
      const std::vector<sh::InterfaceBlock> &getShaderStorageBlocks() const
      {
          return mShaderStorageBlocks;
      }
      const std::vector<sh::ShaderVariable> &getActiveAttributes() const { return mActiveAttributes; }
      const std::vector<sh::ShaderVariable> &getAllAttributes() const { return mAllAttributes; }
      const std::vector<sh::ShaderVariable> &getActiveOutputVariables() const
      {
          return mActiveOutputVariables;
      }
  
      bool compilePending() const { return mCompileStatus == CompileStatus::COMPILE_REQUESTED; }
  
      const sh::WorkGroupSize &getLocalSize() const { return mLocalSize; }
  
      bool hasDiscard() const { return mHasDiscard; }
      bool enablesPerSampleShading() const { return mEnablesPerSampleShading; }
      rx::SpecConstUsageBits getSpecConstUsageBits() const { return mSpecConstUsageBits; }
  
      int getNumViews() const { return mNumViews; }
  
      Optional<PrimitiveMode> getGeometryShaderInputPrimitiveType() const
      {
          return mGeometryShaderInputPrimitiveType;
      }
  
      Optional<PrimitiveMode> getGeometryShaderOutputPrimitiveType() const
      {
          return mGeometryShaderOutputPrimitiveType;
      }
  
      Optional<GLint> geoGeometryShaderMaxVertices() const { return mGeometryShaderMaxVertices; }
  
      Optional<GLint> getGeometryShaderInvocations() const { return mGeometryShaderInvocations; }
  
      CompileStatus getCompileStatus() const { return mCompileStatus; }
  
    private:
      friend class Shader;
  
      std::string mLabel;
  
      ShaderType mShaderType;
      int mShaderVersion;
      std::string mTranslatedSource;
      sh::BinaryBlob mCompiledBinary;
      std::string mSource;
  
      sh::WorkGroupSize mLocalSize;
  
      std::vector<sh::ShaderVariable> mInputVaryings;
      std::vector<sh::ShaderVariable> mOutputVaryings;
      std::vector<sh::ShaderVariable> mUniforms;
      std::vector<sh::InterfaceBlock> mUniformBlocks;
      std::vector<sh::InterfaceBlock> mShaderStorageBlocks;
      std::vector<sh::ShaderVariable> mAllAttributes;
      std::vector<sh::ShaderVariable> mActiveAttributes;
      std::vector<sh::ShaderVariable> mActiveOutputVariables;
  
      bool mHasDiscard;
      bool mEnablesPerSampleShading;
      BlendEquationBitSet mAdvancedBlendEquations;
      rx::SpecConstUsageBits mSpecConstUsageBits;
  
      // ANGLE_multiview.
      int mNumViews;
  
      // Geometry Shader.
      Optional<PrimitiveMode> mGeometryShaderInputPrimitiveType;
      Optional<PrimitiveMode> mGeometryShaderOutputPrimitiveType;
      Optional<GLint> mGeometryShaderMaxVertices;
      int mGeometryShaderInvocations;
  
      // Tessellation Shader
      int mTessControlShaderVertices;
      GLenum mTessGenMode;
      GLenum mTessGenSpacing;
      GLenum mTessGenVertexOrder;
      GLenum mTessGenPointMode;
  
      // Indicates if this shader has been successfully compiled
      CompileStatus mCompileStatus;
  };
  
  class Shader final : angle::NonCopyable, public LabeledObject
  {
    public:
      Shader(ShaderProgramManager *manager,
             rx::GLImplFactory *implFactory,
             const gl::Limitations &rendererLimitations,
             ShaderType type,
             ShaderProgramID handle);
  
      void onDestroy(const Context *context);
  
      angle::Result setLabel(const Context *context, const std::string &label) override;
      const std::string &getLabel() const override;
  
      ShaderType getType() const { return mType; }
      ShaderProgramID getHandle() const;
  
      rx::ShaderImpl *getImplementation() const { return mImplementation.get(); }
  
      void setSource(GLsizei count, const char *const *string, const GLint *length);
      int getInfoLogLength(const Context *context);
      void getInfoLog(const Context *context, GLsizei bufSize, GLsizei *length, char *infoLog);
      std::string getInfoLogString() const { return mInfoLog; }
      int getSourceLength() const;
      const std::string &getSourceString() const { return mState.getSource(); }
      void getSource(GLsizei bufSize, GLsizei *length, char *buffer) const;
      int getTranslatedSourceLength(const Context *context);
      int getTranslatedSourceWithDebugInfoLength(const Context *context);
      const std::string &getTranslatedSource(const Context *context);
      void getTranslatedSource(const Context *context,
                               GLsizei bufSize,
                               GLsizei *length,
                               char *buffer);
      void getTranslatedSourceWithDebugInfo(const Context *context,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            char *buffer);
      const sh::BinaryBlob &getCompiledBinary(const Context *context);
  
      void compile(const Context *context);
      bool isCompiled(const Context *context);
      bool isCompleted();
  
      void addRef();
      void release(const Context *context);
      unsigned int getRefCount() const;
      bool isFlaggedForDeletion() const;
      void flagForDeletion();
      bool hasDiscard() const { return mState.mHasDiscard; }
      bool enablesPerSampleShading() const { return mState.mEnablesPerSampleShading; }
      BlendEquationBitSet getAdvancedBlendEquations() const { return mState.mAdvancedBlendEquations; }
      rx::SpecConstUsageBits getSpecConstUsageBits() const { return mState.mSpecConstUsageBits; }
  
      int getShaderVersion(const Context *context);
  
      const std::vector<sh::ShaderVariable> &getInputVaryings(const Context *context);
      const std::vector<sh::ShaderVariable> &getOutputVaryings(const Context *context);
      const std::vector<sh::ShaderVariable> &getUniforms(const Context *context);
      const std::vector<sh::InterfaceBlock> &getUniformBlocks(const Context *context);
      const std::vector<sh::InterfaceBlock> &getShaderStorageBlocks(const Context *context);
      const std::vector<sh::ShaderVariable> &getActiveAttributes(const Context *context);
      const std::vector<sh::ShaderVariable> &getAllAttributes(const Context *context);
      const std::vector<sh::ShaderVariable> &getActiveOutputVariables(const Context *context);
  
      // Returns mapped name of a transform feedback varying. The original name may contain array
      // brackets with an index inside, which will get copied to the mapped name. The varying must be
      // known to be declared in the shader.
      std::string getTransformFeedbackVaryingMappedName(const Context *context,
                                                        const std::string &tfVaryingName);
  
      const sh::WorkGroupSize &getWorkGroupSize(const Context *context);
  
      int getNumViews(const Context *context);
  
      Optional<PrimitiveMode> getGeometryShaderInputPrimitiveType(const Context *context);
      Optional<PrimitiveMode> getGeometryShaderOutputPrimitiveType(const Context *context);
      int getGeometryShaderInvocations(const Context *context);
      Optional<GLint> getGeometryShaderMaxVertices(const Context *context);
      int getTessControlShaderVertices(const Context *context);
      GLenum getTessGenMode(const Context *context);
      GLenum getTessGenSpacing(const Context *context);
      GLenum getTessGenVertexOrder(const Context *context);
      GLenum getTessGenPointMode(const Context *context);
  
      const std::string &getCompilerResourcesString() const;
  
      const ShaderState &getState() const { return mState; }
  
      GLuint getCurrentMaxComputeWorkGroupInvocations() const
      {
          return mCurrentMaxComputeWorkGroupInvocations;
      }
  
      unsigned int getMaxComputeSharedMemory() const { return mMaxComputeSharedMemory; }
      bool hasBeenDeleted() const { return mDeleteStatus; }
  
      // Block until compiling is finished and resolve it.
      void resolveCompile(const Context *context);
  
      // Writes a shader's binary to the output memory buffer.
      angle::Result serialize(const Context *context, angle::MemoryBuffer *binaryOut) const;
      angle::Result deserialize(const Context *context, BinaryInputStream &stream);
      angle::Result loadBinary(const Context *context, const void *binary, GLsizei length);
  
    private:
      struct CompilingState;
  
      ~Shader() override;
      static void GetSourceImpl(const std::string &source,
                                GLsizei bufSize,
                                GLsizei *length,
                                char *buffer);
  
      ShaderState mState;
      std::unique_ptr<rx::ShaderImpl> mImplementation;
      const gl::Limitations mRendererLimitations;
      const ShaderProgramID mHandle;
      const ShaderType mType;
      unsigned int mRefCount;  // Number of program objects this shader is attached to
      bool mDeleteStatus;  // Flag to indicate that the shader can be deleted when no longer in use
      std::string mInfoLog;
  
      // We keep a reference to the translator in order to defer compiles while preserving settings.
      BindingPointer<Compiler> mBoundCompiler;
      std::unique_ptr<CompilingState> mCompilingState;
      std::string mCompilerResourcesString;
  
      ShaderProgramManager *mResourceManager;
  
      GLuint mCurrentMaxComputeWorkGroupInvocations;
      unsigned int mMaxComputeSharedMemory;
  };
  
  bool CompareShaderVar(const sh::ShaderVariable &x, const sh::ShaderVariable &y);
  
  const char *GetShaderTypeString(ShaderType type);
  }  // namespace gl
  
  #endif  // LIBANGLE_SHADER_H_
  

Download