kc3-lang/angle/src/libANGLE/renderer/ProgramImpl.h

• Show log

  Commit

• Hash : 3680a5dc
  Author :
  Date : 2023-11-17T13:51:07
  

  Vulkan: Let program warmup continue passed link
  
  The warmup task does not actually affect the link results, so there is
  no reason to wait for it when the application queries the link status.
  This change allows the warm up task to continue in parallel until the
  program is used at draw time.  This allows the warm up to be more
  efficient when the link itself is not parallelized.
  
  For applications that create programs in the middle of every frame, it's
  still likely best to disable warm up (as the following immediate draw
  will already effectively do the warm up).
  
  Note that currently the warm up code in the Vulkan backend is not
  completely thread-safe, and so the program still blocks on that task
  before the first draw can happen (or the program is modified in any
  way).
  
  Bug: angleproject:8417
  Change-Id: I0877fef39a0585c3279e32699ce817d4643d7cd6
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5037538
  Reviewed-by: Charlie Lao <cclao@google.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/ProgramImpl.h

• //
  // Copyright 2014 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.
  //
  
  // ProgramImpl.h: Defines the abstract rx::ProgramImpl class.
  
  #ifndef LIBANGLE_RENDERER_PROGRAMIMPL_H_
  #define LIBANGLE_RENDERER_PROGRAMIMPL_H_
  
  #include "common/BinaryStream.h"
  #include "common/WorkerThread.h"
  #include "common/angleutils.h"
  #include "libANGLE/Constants.h"
  #include "libANGLE/Program.h"
  #include "libANGLE/Shader.h"
  
  #include <functional>
  #include <map>
  
  namespace gl
  {
  class Context;
  struct ProgramLinkedResources;
  }  // namespace gl
  
  namespace sh
  {
  struct BlockMemberInfo;
  }
  
  namespace rx
  {
  // 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.
  class LinkSubTask : public angle::Closure
  {
    public:
      ~LinkSubTask() override                                                           = default;
      virtual angle::Result getResult(const gl::Context *context, gl::InfoLog &infoLog) = 0;
  };
  class LinkTask
  {
    public:
      virtual ~LinkTask() = default;
      // Used for link()
      virtual std::vector<std::shared_ptr<LinkSubTask>> link(
          const gl::ProgramLinkedResources &resources,
          const gl::ProgramMergedVaryings &mergedVaryings,
          bool *areSubTasksOptionalOut);
      // Used for load()
      virtual std::vector<std::shared_ptr<LinkSubTask>> load(bool *areSubTasksOptionalOut);
      virtual angle::Result getResult(const gl::Context *context, gl::InfoLog &infoLog) = 0;
  
      // Used by the GL backend to query whether the driver is linking in parallel internally.
      virtual bool isLinkingInternally();
  };
  
  class ProgramImpl : angle::NonCopyable
  {
    public:
      ProgramImpl(const gl::ProgramState &state) : mState(state) {}
      virtual ~ProgramImpl() {}
      virtual void destroy(const gl::Context *context) {}
  
      virtual angle::Result load(const gl::Context *context,
                                 gl::BinaryInputStream *stream,
                                 std::shared_ptr<LinkTask> *loadTaskOut,
                                 bool *successOut)                                  = 0;
      virtual void save(const gl::Context *context, gl::BinaryOutputStream *stream) = 0;
      virtual void setBinaryRetrievableHint(bool retrievable)                       = 0;
      virtual void setSeparable(bool separable)                                     = 0;
  
      virtual void prepareForLink(const gl::ShaderMap<ShaderImpl *> &shaders) {}
      virtual angle::Result link(const gl::Context *context,
                                 std::shared_ptr<LinkTask> *linkTaskOut) = 0;
      virtual GLboolean validate(const gl::Caps &caps)                   = 0;
  
      // Implementation-specific method for ignoring unreferenced uniforms. Some implementations may
      // perform more extensive analysis and ignore some locations that ANGLE doesn't detect as
      // unreferenced. This method is not required to be overriden by a back-end.
      virtual void markUnusedUniformLocations(std::vector<gl::VariableLocation> *uniformLocations,
                                              std::vector<gl::SamplerBinding> *samplerBindings,
                                              std::vector<gl::ImageBinding> *imageBindings)
      {}
  
      const gl::ProgramState &getState() const { return mState; }
  
      virtual angle::Result syncState(const gl::Context *context);
  
      virtual angle::Result onLabelUpdate(const gl::Context *context);
  
    protected:
      const gl::ProgramState &mState;
  };
  
  inline angle::Result ProgramImpl::syncState(const gl::Context *context)
  {
      return angle::Result::Continue;
  }
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_PROGRAMIMPL_H_
  

Download