| // |
| // 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::MemOffsets &bufferOrigin, |
| const cl::MemOffsets &hostOrigin, |
| const cl::Coordinate ®ion, |
| 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::MemOffsets &bufferOrigin, |
| const cl::MemOffsets &hostOrigin, |
| const cl::Coordinate ®ion, |
| 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::MemOffsets &srcOrigin, |
| const cl::MemOffsets &dstOrigin, |
| const cl::Coordinate ®ion, |
| 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::MemOffsets &origin, |
| const cl::Coordinate ®ion, |
| 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::MemOffsets &origin, |
| const cl::Coordinate ®ion, |
| 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::MemOffsets &srcOrigin, |
| const cl::MemOffsets &dstOrigin, |
| const cl::Coordinate ®ion, |
| cl_uint numEventsInWaitList, |
| const cl_event *eventWaitList, |
| cl_event *event); |
| |
| angle::Result enqueueFillImage(cl_mem image, |
| const void *fillColor, |
| const cl::MemOffsets &origin, |
| const cl::Coordinate ®ion, |
| cl_uint numEventsInWaitList, |
| const cl_event *eventWaitList, |
| cl_event *event); |
| |
| angle::Result enqueueCopyImageToBuffer(cl_mem srcImage, |
| cl_mem dstBuffer, |
| const cl::MemOffsets &srcOrigin, |
| const cl::Coordinate ®ion, |
| 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::MemOffsets &dstOrigin, |
| const cl::Coordinate ®ion, |
| cl_uint numEventsInWaitList, |
| const cl_event *eventWaitList, |
| cl_event *event); |
| |
| angle::Result enqueueMapImage(cl_mem image, |
| cl_bool blockingMap, |
| MapFlags mapFlags, |
| const cl::MemOffsets &origin, |
| const cl::Coordinate ®ion, |
| 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(); |
| |
| public: |
| using PropArray = std::vector<cl_queue_properties>; |
| |
| 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; |
| |
| template <typename T = rx::CLCommandQueueImpl> |
| T &getImpl() const; |
| |
| cl_int onRelease(); |
| |
| private: |
| CommandQueue(Context &context, |
| Device &device, |
| PropArray &&propArray, |
| 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; |
| 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; |
| } |
| |
| 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_ |
