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

• Show log

  Commit

• Hash : f8c06f10
  Author :
  Date : 2023-11-30T17:45:35
  

  OpenCL: Add types to cl_mem origin and region
  
  Now using cl::MemOffset and cl::Coordinate.
  
  Bug: angleproject:8439
  Change-Id: Id775fe78467d3b56d2a7cc87f793221ab5e04bc5
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5078244
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  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/cl_utils.h"
  
  namespace rx
  {
  
  CLCommandQueueVk::CLCommandQueueVk(const cl::CommandQueue &commandQueue)
      : CLCommandQueueImpl(commandQueue)
  {}
  
  CLCommandQueueVk::~CLCommandQueueVk() = default;
  
  angle::Result CLCommandQueueVk::setProperty(cl::CommandQueueProperties properties, cl_bool enable)
  {
      UNIMPLEMENTED();
      ANGLE_CL_RETURN_ERROR(CL_OUT_OF_RESOURCES);
  }
  
  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,
                                                       cl_uint workDim,
                                                       const size_t *globalWorkOffset,
                                                       const size_t *globalWorkSize,
                                                       const size_t *localWorkSize,
                                                       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