kc3-lang/angle/src/libANGLE/renderer/vulkan/CLKernelVk.h

• Show log

  Commit

• Hash : f9709279
  Author :
  Date : 2024-09-20T16:02:56
  

  CL/Vulkan: Add support for printf builtin processing
  
  The support for printf builtin in clspv enabled through the SPIR-V
  non-semantic clspv reflection instructions - PrintfInfo and
  PrintfBufferStorageBuffer [1]. The printf buffer is setup with a
  separate descriptor layout and the pipeline layout is updated
  accordingly.
  
  Also, printf is enabled as default option now for clspv.
  
  [1]: https://github.com/KhronosGroup/SPIRV-Registry/blob/master/nonsemantic/NonSemantic.ClspvReflection.html
  Bug: angleproject:369724757
  Change-Id: I20b245eb0fea69941bd1aeb42534f8b729ec17e8
  Signed-off-by: Gowtham Tammana <g.tammana@samsung.com>
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5893958
  Reviewed-by: Charlie Lao <cclao@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/CLKernelVk.h

• //
  // Copyright 2021 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.
  //
  // CLKernelVk.h: Defines the class interface for CLKernelVk, implementing CLKernelImpl.
  
  #ifndef LIBANGLE_RENDERER_VULKAN_CLKERNELVK_H_
  #define LIBANGLE_RENDERER_VULKAN_CLKERNELVK_H_
  
  #include "libANGLE/renderer/vulkan/cl_types.h"
  #include "libANGLE/renderer/vulkan/vk_cache_utils.h"
  #include "libANGLE/renderer/vulkan/vk_helpers.h"
  #include "libANGLE/renderer/vulkan/vk_utils.h"
  
  #include "libANGLE/renderer/CLKernelImpl.h"
  #include "vulkan/vulkan_core.h"
  
  namespace rx
  {
  
  struct CLKernelArgument
  {
      CLKernelImpl::ArgInfo info{};
      uint32_t type     = 0;
      uint32_t ordinal  = 0;
      size_t handleSize = 0;
      void *handle      = nullptr;
      bool used         = false;
  
      // Shared operand words/regions for "OpExtInst" type spv instructions
      // (starts from spv word index/offset 7 and onward)
      // https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpExtInst
      // https://github.com/google/clspv/blob/main/docs/OpenCLCOnVulkan.md#kernels
      union
      {
          uint32_t op3;
          uint32_t descriptorSet;
          uint32_t pushConstOffset;
          uint32_t workgroupSpecId;
      };
      union
      {
          uint32_t op4;
          uint32_t descriptorBinding;
          uint32_t pushConstantSize;
          uint32_t workgroupSize;
      };
      union
      {
          uint32_t op5;
          uint32_t podStorageBufferOffset;
          uint32_t podUniformOffset;
          uint32_t pointerUniformOffset;
      };
      union
      {
          uint32_t op6;
          uint32_t podStorageBufferSize;
          uint32_t podUniformSize;
          uint32_t pointerUniformSize;
      };
  };
  using CLKernelArguments = std::vector<CLKernelArgument>;
  using CLKernelArgsMap   = angle::HashMap<std::string, CLKernelArguments>;
  
  class CLKernelVk : public CLKernelImpl
  {
    public:
      using Ptr = std::unique_ptr<CLKernelVk>;
  
      struct KernelSpecConstant
      {
          uint32_t ID;
          uint32_t data;
      };
      // Setting a reasonable initial value
      // https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_API.html#CL_DEVICE_MAX_PARAMETER_SIZE
      using KernelSpecConstants = angle::FastVector<KernelSpecConstant, 128>;
  
      CLKernelVk(const cl::Kernel &kernel,
                 std::string &name,
                 std::string &attributes,
                 CLKernelArguments &args);
      ~CLKernelVk() override;
  
      angle::Result init();
  
      angle::Result setArg(cl_uint argIndex, size_t argSize, const void *argValue) override;
  
      angle::Result createInfo(CLKernelImpl::Info *infoOut) const override;
  
      CLProgramVk *getProgram() { return mProgram; }
      const std::string &getKernelName() { return mName; }
      const CLKernelArguments &getArgs() { return mArgs; }
      vk::AtomicBindingPointer<vk::PipelineLayout> &getPipelineLayout() { return mPipelineLayout; }
      vk::DescriptorSetLayoutPointerArray &getDescriptorSetLayouts() { return mDescriptorSetLayouts; }
      cl::Kernel &getFrontendObject() { return const_cast<cl::Kernel &>(mKernel); }
  
      angle::Result getOrCreateComputePipeline(vk::PipelineCacheAccess *pipelineCache,
                                               const cl::NDRange &ndrange,
                                               const cl::Device &device,
                                               vk::PipelineHelper **pipelineOut,
                                               cl::WorkgroupCount *workgroupCountOut);
  
      const vk::DescriptorSetLayoutDesc &getDescriptorSetLayoutDesc(DescriptorSetIndex index) const
      {
          return mDescriptorSetLayoutDescs[index];
      }
      const vk::DescriptorSetLayoutDesc &getKernelArgDescriptorSetDesc() const
      {
          return getDescriptorSetLayoutDesc(DescriptorSetIndex::KernelArguments);
      }
      const vk::DescriptorSetLayoutDesc &getLiteralSamplerDescriptorSetDesc() const
      {
          return getDescriptorSetLayoutDesc(DescriptorSetIndex::LiteralSampler);
      }
      const vk::DescriptorSetLayoutDesc &getPrintfDescriptorSetDesc() const
      {
          return getDescriptorSetLayoutDesc(DescriptorSetIndex::Printf);
      }
  
      const vk::PipelineLayoutDesc &getPipelineLayoutDesc() { return mPipelineLayoutDesc; }
  
      VkDescriptorSet &getDescriptorSet(DescriptorSetIndex index) { return mDescriptorSets[index]; }
  
      bool usesPrintf() const;
  
    private:
      static constexpr std::array<size_t, 3> kEmptyWorkgroupSize = {0, 0, 0};
  
      CLProgramVk *mProgram;
      CLContextVk *mContext;
      std::string mName;
      std::string mAttributes;
      CLKernelArguments mArgs;
      vk::ShaderProgramHelper mShaderProgramHelper;
      vk::ComputePipelineCache mComputePipelineCache;
      KernelSpecConstants mSpecConstants;
      vk::AtomicBindingPointer<vk::PipelineLayout> mPipelineLayout;
      vk::DescriptorSetLayoutPointerArray mDescriptorSetLayouts{};
  
      vk::DescriptorSetArray<VkDescriptorSet> mDescriptorSets;
  
      vk::DescriptorSetArray<vk::DescriptorSetLayoutDesc> mDescriptorSetLayoutDescs;
      vk::PipelineLayoutDesc mPipelineLayoutDesc;
  };
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_CLKERNELVK_H_
  

Download