CL: Add image enqueue commands

src/libANGLE/CLCommandQueue.h

@@ -118,6 +118,75 @@ class CommandQueue final : public _cl_command_queue, public Object
                            cl_event *event,
                            cl_int &errorCode);
 
+    cl_int enqueueReadImage(cl_mem image,
+                            cl_bool blockingRead,
+                            const size_t *origin,
+                            const size_t *region,
+                            size_t rowPitch,
+                            size_t slicePitch,
+                            void *ptr,
+                            cl_uint numEventsInWaitList,
+                            const cl_event *eventWaitList,
+                            cl_event *event);
+
+    cl_int enqueueWriteImage(cl_mem image,
+                             cl_bool blockingWrite,
+                             const size_t *origin,
+                             const size_t *region,
+                             size_t inputRowPitch,
+                             size_t inputSlicePitch,
+                             const void *ptr,
+                             cl_uint numEventsInWaitList,
+                             const cl_event *eventWaitList,
+                             cl_event *event);
+
+    cl_int enqueueCopyImage(cl_mem srcImage,
+                            cl_mem dstImage,
+                            const size_t *srcOrigin,
+                            const size_t *dstOrigin,
+                            const size_t *region,
+                            cl_uint numEventsInWaitList,
+                            const cl_event *eventWaitList,
+                            cl_event *event);
+
+    cl_int enqueueFillImage(cl_mem image,
+                            const void *fillColor,
+                            const size_t *origin,
+                            const size_t *region,
+                            cl_uint numEventsInWaitList,
+                            const cl_event *eventWaitList,
+                            cl_event *event);
+
+    cl_int enqueueCopyImageToBuffer(cl_mem srcImage,
+                                    cl_mem dstBuffer,
+                                    const size_t *srcOrigin,
+                                    const size_t *region,
+                                    size_t dstOffset,
+                                    cl_uint numEventsInWaitList,
+                                    const cl_event *eventWaitList,
+                                    cl_event *event);
+
+    cl_int enqueueCopyBufferToImage(cl_mem srcBuffer,
+                                    cl_mem dstImage,
+                                    size_t srcOffset,
+                                    const size_t *dstOrigin,
+                                    const size_t *region,
+                                    cl_uint numEventsInWaitList,
+                                    const cl_event *eventWaitList,
+                                    cl_event *event);
+
+    void *enqueueMapImage(cl_mem image,
+                          cl_bool blockingMap,
+                          MapFlags mapFlags,
+                          const size_t *origin,
+                          const size_t *region,
+                          size_t *imageRowPitch,
+                          size_t *imageSlicePitch,
+                          cl_uint numEventsInWaitList,
+                          const cl_event *eventWaitList,
+                          cl_event *event,
+                          cl_int &errorCode);
+
   public:
     using PropArray = std::vector<cl_queue_properties>;
 

src/libANGLE/CLDevice.cpp

@@ -383,6 +383,62 @@ bool Device::supportsBuiltInKernel(const std::string &name) const
     return false;
 }
 
+bool Device::supportsNativeImageDimensions(const cl_image_desc &desc) const
+{
+    switch (desc.image_type)
+    {
+        case CL_MEM_OBJECT_IMAGE1D:
+            return desc.image_width <= mInfo.mImage2D_MaxWidth;
+        case CL_MEM_OBJECT_IMAGE2D:
+            return desc.image_width <= mInfo.mImage2D_MaxWidth &&
+                   desc.image_height <= mInfo.mImage2D_MaxHeight;
+        case CL_MEM_OBJECT_IMAGE3D:
+            return desc.image_width <= mInfo.mImage3D_MaxWidth &&
+                   desc.image_height <= mInfo.mImage3D_MaxHeight &&
+                   desc.image_depth <= mInfo.mImage3D_MaxDepth;
+        case CL_MEM_OBJECT_IMAGE1D_ARRAY:
+            return desc.image_width <= mInfo.mImage2D_MaxWidth &&
+                   desc.image_array_size <= mInfo.mImageMaxArraySize;
+        case CL_MEM_OBJECT_IMAGE2D_ARRAY:
+            return desc.image_width <= mInfo.mImage2D_MaxWidth &&
+                   desc.image_height <= mInfo.mImage2D_MaxHeight &&
+                   desc.image_array_size <= mInfo.mImageMaxArraySize;
+        case CL_MEM_OBJECT_IMAGE1D_BUFFER:
+            return desc.image_width <= mInfo.mImageMaxBufferSize;
+        default:
+            ASSERT(false);
+            break;
+    }
+    return false;
+}
+
+bool Device::supportsImageDimensions(const ImageDescriptor &desc) const
+{
+    switch (desc.type)
+    {
+        case CL_MEM_OBJECT_IMAGE1D:
+            return desc.width <= mInfo.mImage2D_MaxWidth;
+        case CL_MEM_OBJECT_IMAGE2D:
+            return desc.width <= mInfo.mImage2D_MaxWidth && desc.height <= mInfo.mImage2D_MaxHeight;
+        case CL_MEM_OBJECT_IMAGE3D:
+            return desc.width <= mInfo.mImage3D_MaxWidth &&
+                   desc.height <= mInfo.mImage3D_MaxHeight && desc.depth <= mInfo.mImage3D_MaxDepth;
+        case CL_MEM_OBJECT_IMAGE1D_ARRAY:
+            return desc.width <= mInfo.mImage2D_MaxWidth &&
+                   desc.arraySize <= mInfo.mImageMaxArraySize;
+        case CL_MEM_OBJECT_IMAGE2D_ARRAY:
+            return desc.width <= mInfo.mImage2D_MaxWidth &&
+                   desc.height <= mInfo.mImage2D_MaxHeight &&
+                   desc.arraySize <= mInfo.mImageMaxArraySize;
+        case CL_MEM_OBJECT_IMAGE1D_BUFFER:
+            return desc.width <= mInfo.mImageMaxBufferSize;
+        default:
+            ASSERT(false);
+            break;
+    }
+    return false;
+}
+
 Device::Device(Platform &platform,
                Device *parent,
                DeviceType type,

src/libANGLE/CLDevice.h

@@ -43,6 +43,8 @@ class Device final : public _cl_device_id, public Object
     T &getImpl() const;
 
     bool supportsBuiltInKernel(const std::string &name) const;
+    bool supportsNativeImageDimensions(const cl_image_desc &desc) const;
+    bool supportsImageDimensions(const ImageDescriptor &desc) const;
 
     static bool IsValidType(DeviceType type);
 

src/libANGLE/CLImage.cpp

@@ -116,6 +116,30 @@ bool Image::IsValid(const _cl_mem *image)
 
 Image::~Image() = default;
 
+bool Image::isRegionValid(const size_t origin[3], const size_t region[3]) const
+{
+    switch (getType())
+    {
+        case CL_MEM_OBJECT_IMAGE1D:
+        case CL_MEM_OBJECT_IMAGE1D_BUFFER:
+            return origin[0] + region[0] <= mDesc.width;
+        case CL_MEM_OBJECT_IMAGE2D:
+            return origin[0] + region[0] <= mDesc.width && origin[1] + region[1] <= mDesc.height;
+        case CL_MEM_OBJECT_IMAGE3D:
+            return origin[0] + region[0] <= mDesc.width && origin[1] + region[1] <= mDesc.height &&
+                   origin[2] + region[2] <= mDesc.depth;
+        case CL_MEM_OBJECT_IMAGE1D_ARRAY:
+            return origin[0] + region[0] <= mDesc.width && origin[1] + region[1] <= mDesc.arraySize;
+        case CL_MEM_OBJECT_IMAGE2D_ARRAY:
+            return origin[0] + region[0] <= mDesc.width && origin[1] + region[1] <= mDesc.height &&
+                   origin[2] + region[2] <= mDesc.arraySize;
+        default:
+            ASSERT(false);
+            break;
+    }
+    return false;
+}
+
 Image::Image(Context &context,
              PropArray &&properties,
              MemFlags flags,

src/libANGLE/CLImage.h

@@ -10,6 +10,8 @@
 
 #include "libANGLE/CLMemory.h"
 
+#include "libANGLE/cl_utils.h"
+
 namespace cl
 {
 
@@ -30,6 +32,12 @@ class Image final : public Memory
     const cl_image_format &getFormat() const;
     const ImageDescriptor &getDescriptor() const;
 
+    bool isRegionValid(const size_t origin[3], const size_t region[3]) const;
+
+    size_t getElementSize() const;
+    size_t getRowSize() const;
+    size_t getSliceSize() const;
+
   private:
     Image(Context &context,
           PropArray &&properties,
@@ -61,6 +69,21 @@ inline const ImageDescriptor &Image::getDescriptor() const
     return mDesc;
 }
 
+inline size_t Image::getElementSize() const
+{
+    return GetElementSize(mFormat);
+}
+
+inline size_t Image::getRowSize() const
+{
+    return GetElementSize(mFormat) * mDesc.width;
+}
+
+inline size_t Image::getSliceSize() const
+{
+    return GetElementSize(mFormat) * mDesc.width * mDesc.height;
+}
+
 }  // namespace cl
 
 #endif  // LIBANGLE_CLIMAGE_H_

src/libANGLE/CLMemory.h

@@ -35,6 +35,7 @@ class Memory : public _cl_mem, public Object
     void *getHostPtr() const;
     const MemoryPtr &getParent() const;
     size_t getOffset() const;
+    size_t getSize() const;
 
     template <typename T = rx::CLMemoryImpl>
     T &getImpl() const;
@@ -112,6 +113,11 @@ inline size_t Memory::getOffset() const
     return mOffset;
 }
 
+inline size_t Memory::getSize() const
+{
+    return mSize;
+}
+
 template <typename T>
 inline T &Memory::getImpl() const
 {

src/libANGLE/cl_utils.h

@@ -17,6 +17,15 @@ size_t GetChannelCount(cl_channel_order channelOrder);
 
 size_t GetElementSize(const cl_image_format &image_format);
 
+inline bool OverlapRegions(size_t offset1, size_t offset2, size_t size)
+{
+    // From https://www.khronos.org/registry/OpenCL/specs/3.0-unified/html/OpenCL_API.html
+    // The regions overlap if src_offset <= dst_offset <= src_offset + size - 1
+    // or if dst_offset <= src_offset <= dst_offset + size - 1.
+    return (offset1 <= offset2 && offset2 <= offset1 + size - 1u) ||
+           (offset2 <= offset1 && offset1 <= offset2 + size - 1u);
+}
+
 }  // namespace cl
 
 #endif  // LIBANGLE_CL_UTILS_H_

src/libANGLE/renderer/CLCommandQueueImpl.h

@@ -102,6 +102,68 @@ class CLCommandQueueImpl : angle::NonCopyable
                                    CLEventImpl::CreateFunc *eventCreateFunc,
                                    cl_int &errorCode) = 0;
 
+    virtual cl_int enqueueReadImage(const cl::Image &image,
+                                    bool blocking,
+                                    const size_t origin[3],
+                                    const size_t region[3],
+                                    size_t rowPitch,
+                                    size_t slicePitch,
+                                    void *ptr,
+                                    const cl::EventPtrs &waitEvents,
+                                    CLEventImpl::CreateFunc *eventCreateFunc) = 0;
+
+    virtual cl_int enqueueWriteImage(const cl::Image &image,
+                                     bool blocking,
+                                     const size_t origin[3],
+                                     const size_t region[3],
+                                     size_t inputRowPitch,
+                                     size_t inputSlicePitch,
+                                     const void *ptr,
+                                     const cl::EventPtrs &waitEvents,
+                                     CLEventImpl::CreateFunc *eventCreateFunc) = 0;
+
+    virtual cl_int enqueueCopyImage(const cl::Image &srcImage,
+                                    const cl::Image &dstImage,
+                                    const size_t srcOrigin[3],
+                                    const size_t dstOrigin[3],
+                                    const size_t region[3],
+                                    const cl::EventPtrs &waitEvents,
+                                    CLEventImpl::CreateFunc *eventCreateFunc) = 0;
+
+    virtual cl_int enqueueFillImage(const cl::Image &image,
+                                    const void *fillColor,
+                                    const size_t origin[3],
+                                    const size_t region[3],
+                                    const cl::EventPtrs &waitEvents,
+                                    CLEventImpl::CreateFunc *eventCreateFunc) = 0;
+
+    virtual cl_int enqueueCopyImageToBuffer(const cl::Image &srcImage,
+                                            const cl::Buffer &dstBuffer,
+                                            const size_t srcOrigin[3],
+                                            const size_t region[3],
+                                            size_t dstOffset,
+                                            const cl::EventPtrs &waitEvents,
+                                            CLEventImpl::CreateFunc *eventCreateFunc) = 0;
+
+    virtual cl_int enqueueCopyBufferToImage(const cl::Buffer &srcBuffer,
+                                            const cl::Image &dstImage,
+                                            size_t srcOffset,
+                                            const size_t dstOrigin[3],
+                                            const size_t region[3],
+                                            const cl::EventPtrs &waitEvents,
+                                            CLEventImpl::CreateFunc *eventCreateFunc) = 0;
+
+    virtual void *enqueueMapImage(const cl::Image &image,
+                                  bool blocking,
+                                  cl::MapFlags mapFlags,
+                                  const size_t origin[3],
+                                  const size_t region[3],
+                                  size_t *imageRowPitch,
+                                  size_t *imageSlicePitch,
+                                  const cl::EventPtrs &waitEvents,
+                                  CLEventImpl::CreateFunc *eventCreateFunc,
+                                  cl_int &errorCode) = 0;
+
   protected:
     const cl::CommandQueue &mCommandQueue;
 };

src/libANGLE/renderer/cl/CLCommandQueueCL.h

@@ -101,6 +101,68 @@ class CLCommandQueueCL : public CLCommandQueueImpl
                            CLEventImpl::CreateFunc *eventCreateFunc,
                            cl_int &errorCode) override;
 
+    cl_int enqueueReadImage(const cl::Image &image,
+                            bool blocking,
+                            const size_t origin[3],
+                            const size_t region[3],
+                            size_t rowPitch,
+                            size_t slicePitch,
+                            void *ptr,
+                            const cl::EventPtrs &waitEvents,
+                            CLEventImpl::CreateFunc *eventCreateFunc) override;
+
+    cl_int enqueueWriteImage(const cl::Image &image,
+                             bool blocking,
+                             const size_t origin[3],
+                             const size_t region[3],
+                             size_t inputRowPitch,
+                             size_t inputSlicePitch,
+                             const void *ptr,
+                             const cl::EventPtrs &waitEvents,
+                             CLEventImpl::CreateFunc *eventCreateFunc) override;
+
+    cl_int enqueueCopyImage(const cl::Image &srcImage,
+                            const cl::Image &dstImage,
+                            const size_t srcOrigin[3],
+                            const size_t dstOrigin[3],
+                            const size_t region[3],
+                            const cl::EventPtrs &waitEvents,
+                            CLEventImpl::CreateFunc *eventCreateFunc) override;
+
+    cl_int enqueueFillImage(const cl::Image &image,
+                            const void *fillColor,
+                            const size_t origin[3],
+                            const size_t region[3],
+                            const cl::EventPtrs &waitEvents,
+                            CLEventImpl::CreateFunc *eventCreateFunc) override;
+
+    cl_int enqueueCopyImageToBuffer(const cl::Image &srcImage,
+                                    const cl::Buffer &dstBuffer,
+                                    const size_t srcOrigin[3],
+                                    const size_t region[3],
+                                    size_t dstOffset,
+                                    const cl::EventPtrs &waitEvents,
+                                    CLEventImpl::CreateFunc *eventCreateFunc) override;
+
+    cl_int enqueueCopyBufferToImage(const cl::Buffer &srcBuffer,
+                                    const cl::Image &dstImage,
+                                    size_t srcOffset,
+                                    const size_t dstOrigin[3],
+                                    const size_t region[3],
+                                    const cl::EventPtrs &waitEvents,
+                                    CLEventImpl::CreateFunc *eventCreateFunc) override;
+
+    void *enqueueMapImage(const cl::Image &image,
+                          bool blocking,
+                          cl::MapFlags mapFlags,
+                          const size_t origin[3],
+                          const size_t region[3],
+                          size_t *imageRowPitch,
+                          size_t *imageSlicePitch,
+                          const cl::EventPtrs &waitEvents,
+                          CLEventImpl::CreateFunc *eventCreateFunc,
+                          cl_int &errorCode) override;
+
   private:
     const cl_command_queue mNative;
 };

src/libANGLE/renderer/cl/CLDeviceCL.cpp

@@ -212,7 +212,7 @@ cl_int CLDeviceCL::createSubDevices(const cl_device_partition_property *properti
     {
         for (cl_device_id nativeSubDevice : nativeSubDevices)
         {
-            createFuncs.emplace_back([=](const cl::Device &device) {
+            createFuncs.emplace_back([nativeSubDevice](const cl::Device &device) {
                 return Ptr(new CLDeviceCL(device, nativeSubDevice));
             });
         }

src/libANGLE/renderer/cl/CLPlatformCL.cpp

@@ -348,7 +348,7 @@ CLDeviceImpl::CreateDatas CLPlatformCL::createDevices() const
                 }
 
                 cl_device_id nativeDevice = nativeDevices[index];
-                createDatas.emplace_back(types[index], [=](const cl::Device &device) {
+                createDatas.emplace_back(types[index], [nativeDevice](const cl::Device &device) {
                     return CLDeviceCL::Ptr(new CLDeviceCL(device, nativeDevice));
                 });
             }
@@ -418,7 +418,7 @@ void CLPlatformCL::Initialize(CreateFuncs &createFuncs, bool isIcd)
     for (KHRicdVendor *vendorIt = khrIcdVendors; vendorIt != nullptr; vendorIt = vendorIt->next)
     {
         cl_platform_id nativePlatform = vendorIt->platform;
-        createFuncs.emplace_back([=](const cl::Platform &platform) {
+        createFuncs.emplace_back([nativePlatform](const cl::Platform &platform) {
             return Ptr(new CLPlatformCL(platform, nativePlatform));
         });
     }

src/libANGLE/renderer/cl/CLProgramCL.cpp

@@ -70,7 +70,7 @@ cl_int CLProgramCL::createKernels(cl_uint numKernels,
     {
         for (cl_kernel nativeKernel : nativeKernels)
         {
-            createFuncs.emplace_back([=](const cl::Kernel &kernel) {
+            createFuncs.emplace_back([nativeKernel](const cl::Kernel &kernel) {
                 return CLKernelImpl::Ptr(new CLKernelCL(kernel, nativeKernel));
             });
         }

src/libGLESv2/cl_stubs.cpp

@@ -835,8 +835,9 @@ cl_int EnqueueReadImage(cl_command_queue command_queue,
                         const cl_event *event_wait_list,
                         cl_event *event)
 {
-    WARN_NOT_SUPPORTED(EnqueueReadImage);
-    return 0;
+    return command_queue->cast<CommandQueue>().enqueueReadImage(
+        image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list,
+        event_wait_list, event);
 }
 
 cl_int EnqueueWriteImage(cl_command_queue command_queue,
@@ -851,8 +852,9 @@ cl_int EnqueueWriteImage(cl_command_queue command_queue,
                          const cl_event *event_wait_list,
                          cl_event *event)
 {
-    WARN_NOT_SUPPORTED(EnqueueWriteImage);
-    return 0;
+    return command_queue->cast<CommandQueue>().enqueueWriteImage(
+        image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr,
+        num_events_in_wait_list, event_wait_list, event);
 }
 
 cl_int EnqueueFillImage(cl_command_queue command_queue,
@@ -864,8 +866,8 @@ cl_int EnqueueFillImage(cl_command_queue command_queue,
                         const cl_event *event_wait_list,
                         cl_event *event)
 {
-    WARN_NOT_SUPPORTED(EnqueueFillImage);
-    return 0;
+    return command_queue->cast<CommandQueue>().enqueueFillImage(
+        image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, event);
 }
 
 cl_int EnqueueCopyImage(cl_command_queue command_queue,
@@ -878,8 +880,9 @@ cl_int EnqueueCopyImage(cl_command_queue command_queue,
                         const cl_event *event_wait_list,
                         cl_event *event)
 {
-    WARN_NOT_SUPPORTED(EnqueueCopyImage);
-    return 0;
+    return command_queue->cast<CommandQueue>().enqueueCopyImage(
+        src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list,
+        event_wait_list, event);
 }
 
 cl_int EnqueueCopyImageToBuffer(cl_command_queue command_queue,
@@ -892,8 +895,9 @@ cl_int EnqueueCopyImageToBuffer(cl_command_queue command_queue,
                                 const cl_event *event_wait_list,
                                 cl_event *event)
 {
-    WARN_NOT_SUPPORTED(EnqueueCopyImageToBuffer);
-    return 0;
+    return command_queue->cast<CommandQueue>().enqueueCopyImageToBuffer(
+        src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list,
+        event_wait_list, event);
 }
 
 cl_int EnqueueCopyBufferToImage(cl_command_queue command_queue,
@@ -906,8 +910,9 @@ cl_int EnqueueCopyBufferToImage(cl_command_queue command_queue,
                                 const cl_event *event_wait_list,
                                 cl_event *event)
 {
-    WARN_NOT_SUPPORTED(EnqueueCopyBufferToImage);
-    return 0;
+    return command_queue->cast<CommandQueue>().enqueueCopyBufferToImage(
+        src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list,
+        event_wait_list, event);
 }
 
 void *EnqueueMapBuffer(cl_command_queue command_queue,
@@ -939,8 +944,9 @@ void *EnqueueMapImage(cl_command_queue command_queue,
                       cl_event *event,
                       cl_int &errorCode)
 {
-    WARN_NOT_SUPPORTED(EnqueueMapImage);
-    return 0;
+    return command_queue->cast<CommandQueue>().enqueueMapImage(
+        image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch,
+        num_events_in_wait_list, event_wait_list, event, errorCode);
 }
 
 cl_int EnqueueUnmapMemObject(cl_command_queue command_queue,