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

• Show log

  Commit

• Hash : 096924c1
  Author :
  Date : 2025-06-13T17:26:20
  

  CL: Consolidate cl::{Offset,Extents} types
  
  The following definitions were equivalent, so consolidating their
  definitions.
  
    - cl::MemOffsets ~ cl::Offset
    - cl::Coordinate ~ cl::Extents
  
  Bug: angleproject:444481344
  Change-Id: I6c1bd68bc3260b8da0ab4b4796668caf474e56a1
  Signed-off-by: Gowtham Tammana <g.tammana@samsung.com>
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6939056
  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/CLCommandQueue.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.
  //
  // CLCommandQueue.h: Defines the cl::CommandQueue class, which can be used to queue a set of OpenCL
  // operations.
  
  #ifndef LIBANGLE_CLCOMMANDQUEUE_H_
  #define LIBANGLE_CLCOMMANDQUEUE_H_
  
  #include "libANGLE/CLObject.h"
  #include "libANGLE/cl_utils.h"
  #include "libANGLE/renderer/CLCommandQueueImpl.h"
  
  #include "common/SynchronizedValue.h"
  
  #include <limits>
  
  namespace cl
  {
  
  class CommandQueue final : public _cl_command_queue, public Object
  {
    public:
      // Front end entry functions, only called from OpenCL entry points
  
      angle::Result getInfo(CommandQueueInfo name,
                            size_t valueSize,
                            void *value,
                            size_t *valueSizeRet) const;
  
      angle::Result setProperty(CommandQueueProperties properties,
                                cl_bool enable,
                                cl_command_queue_properties *oldProperties);
  
      angle::Result enqueueReadBuffer(cl_mem buffer,
                                      cl_bool blockingRead,
                                      size_t offset,
                                      size_t size,
                                      void *ptr,
                                      cl_uint numEventsInWaitList,
                                      const cl_event *eventWaitList,
                                      cl_event *event);
  
      angle::Result enqueueWriteBuffer(cl_mem buffer,
                                       cl_bool blockingWrite,
                                       size_t offset,
                                       size_t size,
                                       const void *ptr,
                                       cl_uint numEventsInWaitList,
                                       const cl_event *eventWaitList,
                                       cl_event *event);
  
      angle::Result enqueueReadBufferRect(cl_mem buffer,
                                          cl_bool blockingRead,
                                          const cl::Offset &bufferOrigin,
                                          const cl::Offset &hostOrigin,
                                          const cl::Extents &region,
                                          size_t bufferRowPitch,
                                          size_t bufferSlicePitch,
                                          size_t hostRowPitch,
                                          size_t hostSlicePitch,
                                          void *ptr,
                                          cl_uint numEventsInWaitList,
                                          const cl_event *eventWaitList,
                                          cl_event *event);
  
      angle::Result enqueueWriteBufferRect(cl_mem buffer,
                                           cl_bool blockingWrite,
                                           const cl::Offset &bufferOrigin,
                                           const cl::Offset &hostOrigin,
                                           const cl::Extents &region,
                                           size_t bufferRowPitch,
                                           size_t bufferSlicePitch,
                                           size_t hostRowPitch,
                                           size_t hostSlicePitch,
                                           const void *ptr,
                                           cl_uint numEventsInWaitList,
                                           const cl_event *eventWaitList,
                                           cl_event *event);
  
      angle::Result enqueueCopyBuffer(cl_mem srcBuffer,
                                      cl_mem dstBuffer,
                                      size_t srcOffset,
                                      size_t dstOffset,
                                      size_t size,
                                      cl_uint numEventsInWaitList,
                                      const cl_event *eventWaitList,
                                      cl_event *event);
  
      angle::Result enqueueCopyBufferRect(cl_mem srcBuffer,
                                          cl_mem dstBuffer,
                                          const cl::Offset &srcOrigin,
                                          const cl::Offset &dstOrigin,
                                          const cl::Extents &region,
                                          size_t srcRowPitch,
                                          size_t srcSlicePitch,
                                          size_t dstRowPitch,
                                          size_t dstSlicePitch,
                                          cl_uint numEventsInWaitList,
                                          const cl_event *eventWaitList,
                                          cl_event *event);
  
      angle::Result enqueueFillBuffer(cl_mem buffer,
                                      const void *pattern,
                                      size_t patternSize,
                                      size_t offset,
                                      size_t size,
                                      cl_uint numEventsInWaitList,
                                      const cl_event *eventWaitList,
                                      cl_event *event);
  
      angle::Result enqueueMapBuffer(cl_mem buffer,
                                     cl_bool blockingMap,
                                     MapFlags mapFlags,
                                     size_t offset,
                                     size_t size,
                                     cl_uint numEventsInWaitList,
                                     const cl_event *eventWaitList,
                                     cl_event *event,
                                     void *&mapPtr);
  
      angle::Result enqueueReadImage(cl_mem image,
                                     cl_bool blockingRead,
                                     const cl::Offset &origin,
                                     const cl::Extents &region,
                                     size_t rowPitch,
                                     size_t slicePitch,
                                     void *ptr,
                                     cl_uint numEventsInWaitList,
                                     const cl_event *eventWaitList,
                                     cl_event *event);
  
      angle::Result enqueueWriteImage(cl_mem image,
                                      cl_bool blockingWrite,
                                      const cl::Offset &origin,
                                      const cl::Extents &region,
                                      size_t inputRowPitch,
                                      size_t inputSlicePitch,
                                      const void *ptr,
                                      cl_uint numEventsInWaitList,
                                      const cl_event *eventWaitList,
                                      cl_event *event);
  
      angle::Result enqueueCopyImage(cl_mem srcImage,
                                     cl_mem dstImage,
                                     const cl::Offset &srcOrigin,
                                     const cl::Offset &dstOrigin,
                                     const cl::Extents &region,
                                     cl_uint numEventsInWaitList,
                                     const cl_event *eventWaitList,
                                     cl_event *event);
  
      angle::Result enqueueFillImage(cl_mem image,
                                     const void *fillColor,
                                     const cl::Offset &origin,
                                     const cl::Extents &region,
                                     cl_uint numEventsInWaitList,
                                     const cl_event *eventWaitList,
                                     cl_event *event);
  
      angle::Result enqueueCopyImageToBuffer(cl_mem srcImage,
                                             cl_mem dstBuffer,
                                             const cl::Offset &srcOrigin,
                                             const cl::Extents &region,
                                             size_t dstOffset,
                                             cl_uint numEventsInWaitList,
                                             const cl_event *eventWaitList,
                                             cl_event *event);
  
      angle::Result enqueueCopyBufferToImage(cl_mem srcBuffer,
                                             cl_mem dstImage,
                                             size_t srcOffset,
                                             const cl::Offset &dstOrigin,
                                             const cl::Extents &region,
                                             cl_uint numEventsInWaitList,
                                             const cl_event *eventWaitList,
                                             cl_event *event);
  
      angle::Result enqueueMapImage(cl_mem image,
                                    cl_bool blockingMap,
                                    MapFlags mapFlags,
                                    const cl::Offset &origin,
                                    const cl::Extents &region,
                                    size_t *imageRowPitch,
                                    size_t *imageSlicePitch,
                                    cl_uint numEventsInWaitList,
                                    const cl_event *eventWaitList,
                                    cl_event *event,
                                    void *&mapPtr);
  
      angle::Result enqueueUnmapMemObject(cl_mem memobj,
                                          void *mappedPtr,
                                          cl_uint numEventsInWaitList,
                                          const cl_event *eventWaitList,
                                          cl_event *event);
  
      angle::Result enqueueMigrateMemObjects(cl_uint numMemObjects,
                                             const cl_mem *memObjects,
                                             MemMigrationFlags flags,
                                             cl_uint numEventsInWaitList,
                                             const cl_event *eventWaitList,
                                             cl_event *event);
  
      angle::Result enqueueNDRangeKernel(cl_kernel kernel,
                                         const NDRange &ndrange,
                                         cl_uint numEventsInWaitList,
                                         const cl_event *eventWaitList,
                                         cl_event *event);
  
      angle::Result enqueueTask(cl_kernel kernel,
                                cl_uint numEventsInWaitList,
                                const cl_event *eventWaitList,
                                cl_event *event);
  
      angle::Result enqueueNativeKernel(UserFunc userFunc,
                                        void *args,
                                        size_t cbArgs,
                                        cl_uint numMemObjects,
                                        const cl_mem *memList,
                                        const void **argsMemLoc,
                                        cl_uint numEventsInWaitList,
                                        const cl_event *eventWaitList,
                                        cl_event *event);
  
      angle::Result enqueueMarkerWithWaitList(cl_uint numEventsInWaitList,
                                              const cl_event *eventWaitList,
                                              cl_event *event);
  
      angle::Result enqueueMarker(cl_event *event);
  
      angle::Result enqueueWaitForEvents(cl_uint numEvents, const cl_event *eventList);
  
      angle::Result enqueueBarrierWithWaitList(cl_uint numEventsInWaitList,
                                               const cl_event *eventWaitList,
                                               cl_event *event);
  
      angle::Result enqueueBarrier();
  
      angle::Result flush();
      angle::Result finish();
  
      angle::Result enqueueAcquireExternalMemObjectsKHR(cl_uint numMemObjects,
                                                        const cl_mem *memObjects,
                                                        cl_uint numEventsInWaitList,
                                                        const cl_event *eventWaitList,
                                                        cl_event *event);
  
      angle::Result enqueueReleaseExternalMemObjectsKHR(cl_uint numMemObjects,
                                                        const cl_mem *memObjects,
                                                        cl_uint numEventsInWaitList,
                                                        const cl_event *eventWaitList,
                                                        cl_event *event);
  
    public:
      using PropArray = std::vector<cl_queue_properties>;
      using Priority  = cl_queue_priority_khr;
  
      static constexpr cl_uint kNoSize = std::numeric_limits<cl_uint>::max();
  
      ~CommandQueue() override;
  
      Context &getContext();
      const Context &getContext() const;
      const Device &getDevice() const;
  
      // Get index of device in the context.
      size_t getDeviceIndex() const;
  
      CommandQueueProperties getProperties() const;
      bool isOnHost() const;
      bool isOnDevice() const;
  
      bool hasSize() const;
      cl_uint getSize() const;
  
      Priority getPriority() const;
  
      template <typename T = rx::CLCommandQueueImpl>
      T &getImpl() const;
  
      cl_int onRelease();
  
    private:
      CommandQueue(Context &context,
                   Device &device,
                   PropArray &&propArray,
                   Priority priority,
                   CommandQueueProperties properties,
                   cl_uint size);
  
      CommandQueue(Context &context, Device &device, CommandQueueProperties properties);
  
      const ContextPtr mContext;
      const DevicePtr mDevice;
      const PropArray mPropArray;
      angle::SynchronizedValue<CommandQueueProperties> mProperties;
      const cl_uint mSize = kNoSize;
      const Priority mPriority;
      rx::CLCommandQueueImpl::Ptr mImpl;
  
      friend class Object;
  };
  
  inline Context &CommandQueue::getContext()
  {
      return *mContext;
  }
  
  inline const Context &CommandQueue::getContext() const
  {
      return *mContext;
  }
  
  inline const Device &CommandQueue::getDevice() const
  {
      return *mDevice;
  }
  
  inline CommandQueueProperties CommandQueue::getProperties() const
  {
      return *mProperties;
  }
  
  inline bool CommandQueue::isOnHost() const
  {
      return mProperties->excludes(CL_QUEUE_ON_DEVICE);
  }
  
  inline bool CommandQueue::isOnDevice() const
  {
      return mProperties->intersects(CL_QUEUE_ON_DEVICE);
  }
  
  inline bool CommandQueue::hasSize() const
  {
      return mSize != kNoSize;
  }
  
  inline cl_uint CommandQueue::getSize() const
  {
      return mSize;
  }
  
  inline CommandQueue::Priority CommandQueue::getPriority() const
  {
      return mPriority;
  }
  
  template <typename T>
  inline T &CommandQueue::getImpl() const
  {
      return static_cast<T &>(*mImpl);
  }
  
  inline cl_int CommandQueue::onRelease()
  {
      // Perform implicit submission on queue release
      // https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_API.html#clReleaseCommandQueue
      if (IsError(finish()))
      {
          WARN() << "Failed to perform implicit submission on queue release!";
          return CL_OUT_OF_RESOURCES;
      }
      return CL_SUCCESS;
  }
  
  }  // namespace cl
  
  #endif  // LIBANGLE_CLCOMMANDQUEUE_H_
  

Download