kc3-lang/angle/src/libANGLE/renderer/vulkan/CLCommandQueueVk.cpp

• Show log

  Commit

• Hash : 35c7e186
  Author :
  Date : 2024-04-03T14:31:59
  

  CL: Introduce NDRange object/ops abstraction
  
  Create new FrontEnd type "NDRange" to encapsulate
  OpenCL's NDRange items. Update backend implementations
  to make use of this new object.
  
  Bug: angleproject:8650
  Change-Id: I3c1549c50c85153b3ea77267e104eec04ba1bd93
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5421572
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Austin Annestrand <a.annestrand@samsung.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/CLCommandQueueVk.cpp

• //
  // 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.
  //
  // CLCommandQueueVk.cpp: Implements the class methods for CLCommandQueueVk.
  
  #include "libANGLE/renderer/vulkan/CLCommandQueueVk.h"
  #include "libANGLE/renderer/vulkan/CLContextVk.h"
  #include "libANGLE/renderer/vulkan/CLDeviceVk.h"
  #include "libANGLE/renderer/vulkan/vk_renderer.h"
  
  #include "libANGLE/CLCommandQueue.h"
  #include "libANGLE/CLContext.h"
  #include "libANGLE/cl_utils.h"
  
  namespace rx
  {
  
  CLCommandQueueVk::CLCommandQueueVk(const cl::CommandQueue &commandQueue)
      : CLCommandQueueImpl(commandQueue),
        mContext(&commandQueue.getContext().getImpl<CLContextVk>()),
        mDevice(&commandQueue.getDevice().getImpl<CLDeviceVk>()),
        mComputePassCommands(nullptr)
  {}
  
  CLCommandQueueVk::~CLCommandQueueVk()
  {
      VkDevice vkDevice = mContext->getDevice();
  
      // Recycle the current command buffers
      mContext->getRenderer()->recycleOutsideRenderPassCommandBufferHelper(&mComputePassCommands);
      mCommandPool.outsideRenderPassPool.destroy(vkDevice);
  }
  
  angle::Result CLCommandQueueVk::init()
  {
      ANGLE_CL_IMPL_TRY_ERROR(
          vk::OutsideRenderPassCommandBuffer::InitializeCommandPool(
              mContext, &mCommandPool.outsideRenderPassPool,
              mContext->getRenderer()->getDeviceQueueIndex(), getProtectionType()),
          CL_OUT_OF_RESOURCES);
  
      ANGLE_CL_IMPL_TRY_ERROR(mContext->getRenderer()->getOutsideRenderPassCommandBufferHelper(
                                  mContext, &mCommandPool.outsideRenderPassPool,
                                  &mOutsideRenderPassCommandsAllocator, &mComputePassCommands),
                              CL_OUT_OF_RESOURCES);
  
      return angle::Result::Continue;
  }
  
  angle::Result CLCommandQueueVk::setProperty(cl::CommandQueueProperties properties, cl_bool enable)
  {
      // NOTE: "clSetCommandQueueProperty" has been deprecated as of OpenCL 1.1
      // http://man.opencl.org/deprecated.html
      return angle::Result::Continue;
  }
  
  angle::Result CLCommandQueueVk::enqueueReadBuffer(const cl::Buffer &buffer,
                                                    bool blocking,
                                                    size_t offset,
                                                    size_t size,
                                                    void *ptr,
                                                    const cl::EventPtrs &waitEvents,
                                                    CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueWriteBuffer(const cl::Buffer &buffer,
                                                     bool blocking,
                                                     size_t offset,
                                                     size_t size,
                                                     const void *ptr,
                                                     const cl::EventPtrs &waitEvents,
                                                     CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueReadBufferRect(const cl::Buffer &buffer,
                                                        bool blocking,
                                                        const cl::MemOffsets &bufferOrigin,
                                                        const cl::MemOffsets &hostOrigin,
                                                        const cl::Coordinate &region,
                                                        size_t bufferRowPitch,
                                                        size_t bufferSlicePitch,
                                                        size_t hostRowPitch,
                                                        size_t hostSlicePitch,
                                                        void *ptr,
                                                        const cl::EventPtrs &waitEvents,
                                                        CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueWriteBufferRect(const cl::Buffer &buffer,
                                                         bool blocking,
                                                         const cl::MemOffsets &bufferOrigin,
                                                         const cl::MemOffsets &hostOrigin,
                                                         const cl::Coordinate &region,
                                                         size_t bufferRowPitch,
                                                         size_t bufferSlicePitch,
                                                         size_t hostRowPitch,
                                                         size_t hostSlicePitch,
                                                         const void *ptr,
                                                         const cl::EventPtrs &waitEvents,
                                                         CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueCopyBuffer(const cl::Buffer &srcBuffer,
                                                    const cl::Buffer &dstBuffer,
                                                    size_t srcOffset,
                                                    size_t dstOffset,
                                                    size_t size,
                                                    const cl::EventPtrs &waitEvents,
                                                    CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueCopyBufferRect(const cl::Buffer &srcBuffer,
                                                        const cl::Buffer &dstBuffer,
                                                        const cl::MemOffsets &srcOrigin,
                                                        const cl::MemOffsets &dstOrigin,
                                                        const cl::Coordinate &region,
                                                        size_t srcRowPitch,
                                                        size_t srcSlicePitch,
                                                        size_t dstRowPitch,
                                                        size_t dstSlicePitch,
                                                        const cl::EventPtrs &waitEvents,
                                                        CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueFillBuffer(const cl::Buffer &buffer,
                                                    const void *pattern,
                                                    size_t patternSize,
                                                    size_t offset,
                                                    size_t size,
                                                    const cl::EventPtrs &waitEvents,
                                                    CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueMapBuffer(const cl::Buffer &buffer,
                                                   bool blocking,
                                                   cl::MapFlags mapFlags,
                                                   size_t offset,
                                                   size_t size,
                                                   const cl::EventPtrs &waitEvents,
                                                   CLEventImpl::CreateFunc *eventCreateFunc,
                                                   void *&mapPtr)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueReadImage(const cl::Image &image,
                                                   bool blocking,
                                                   const cl::MemOffsets &origin,
                                                   const cl::Coordinate &region,
                                                   size_t rowPitch,
                                                   size_t slicePitch,
                                                   void *ptr,
                                                   const cl::EventPtrs &waitEvents,
                                                   CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueWriteImage(const cl::Image &image,
                                                    bool blocking,
                                                    const cl::MemOffsets &origin,
                                                    const cl::Coordinate &region,
                                                    size_t inputRowPitch,
                                                    size_t inputSlicePitch,
                                                    const void *ptr,
                                                    const cl::EventPtrs &waitEvents,
                                                    CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueCopyImage(const cl::Image &srcImage,
                                                   const cl::Image &dstImage,
                                                   const cl::MemOffsets &srcOrigin,
                                                   const cl::MemOffsets &dstOrigin,
                                                   const cl::Coordinate &region,
                                                   const cl::EventPtrs &waitEvents,
                                                   CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueFillImage(const cl::Image &image,
                                                   const void *fillColor,
                                                   const cl::MemOffsets &origin,
                                                   const cl::Coordinate &region,
                                                   const cl::EventPtrs &waitEvents,
                                                   CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueCopyImageToBuffer(const cl::Image &srcImage,
                                                           const cl::Buffer &dstBuffer,
                                                           const cl::MemOffsets &srcOrigin,
                                                           const cl::Coordinate &region,
                                                           size_t dstOffset,
                                                           const cl::EventPtrs &waitEvents,
                                                           CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueCopyBufferToImage(const cl::Buffer &srcBuffer,
                                                           const cl::Image &dstImage,
                                                           size_t srcOffset,
                                                           const cl::MemOffsets &dstOrigin,
                                                           const cl::Coordinate &region,
                                                           const cl::EventPtrs &waitEvents,
                                                           CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueMapImage(const cl::Image &image,
                                                  bool blocking,
                                                  cl::MapFlags mapFlags,
                                                  const cl::MemOffsets &origin,
                                                  const cl::Coordinate &region,
                                                  size_t *imageRowPitch,
                                                  size_t *imageSlicePitch,
                                                  const cl::EventPtrs &waitEvents,
                                                  CLEventImpl::CreateFunc *eventCreateFunc,
                                                  void *&mapPtr)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueUnmapMemObject(const cl::Memory &memory,
                                                        void *mappedPtr,
                                                        const cl::EventPtrs &waitEvents,
                                                        CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueMigrateMemObjects(const cl::MemoryPtrs &memObjects,
                                                           cl::MemMigrationFlags flags,
                                                           const cl::EventPtrs &waitEvents,
                                                           CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueNDRangeKernel(const cl::Kernel &kernel,
                                                       const cl::NDRange &ndrange,
                                                       const cl::EventPtrs &waitEvents,
                                                       CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueTask(const cl::Kernel &kernel,
                                              const cl::EventPtrs &waitEvents,
                                              CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueNativeKernel(cl::UserFunc userFunc,
                                                      void *args,
                                                      size_t cbArgs,
                                                      const cl::BufferPtrs &buffers,
                                                      const std::vector<size_t> bufferPtrOffsets,
                                                      const cl::EventPtrs &waitEvents,
                                                      CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueMarkerWithWaitList(const cl::EventPtrs &waitEvents,
                                                            CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueMarker(CLEventImpl::CreateFunc &eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueWaitForEvents(const cl::EventPtrs &events)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueBarrierWithWaitList(const cl::EventPtrs &waitEvents,
                                                             CLEventImpl::CreateFunc *eventCreateFunc)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::enqueueBarrier()
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::flush()
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  angle::Result CLCommandQueueVk::finish()
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  }  // namespace rx
  

Download