Test IMAGE1D_BUFFER in more scenario (#1806)

* cl_copy_images

* cl_get_info

* cl_fill_image

* cl_read_write_image

* kernel_image_methods

* IMAGE1D_BUFFER cannot be created with (USE_|ALLOC_|COPY_)_HOST_PTR

* do not allow mipmap with 1D buffer

* adjust M to be within maximum_sizes and max_pixels

* remove unused variables

* make sure M will never be 0

* fix region[0] after refactoring removing mipmap

* fix formatting

* format with clang-format-11

* fix image1d_buffer creation with gEnablePitch

* add missing case in switch

* use align_malloc when CL version is at least 2.0

* use CL_DEVICE_NUMERIC_VERSION and align_free

* fix free of pitch buffer

* fix formatting

* fix formatting

* fix data->is_aligned

test_conformance/images/clCopyImage/CMakeLists.txt

@@ -10,6 +10,7 @@ set(${MODULE_NAME}_SOURCES
     test_copy_2D_array.cpp
     test_copy_3D.cpp
     test_copy_3D_2D_array.cpp
+    test_copy_1D_buffer.cpp
     test_copy_generic.cpp
     test_loops.cpp
     ../common.cpp

test_conformance/images/clCopyImage/main.cpp

@@ -45,6 +45,21 @@ int test_3D(cl_device_id device, cl_context context, cl_command_queue queue, int
 {
     return test_image_set( device, context, queue, k3D );
 }
+int test_1Dbuffer(cl_device_id device, cl_context context,
+                  cl_command_queue queue, int num_elements)
+{
+    return test_image_set(device, context, queue, k1DBuffer);
+}
+int test_1DTo1Dbuffer(cl_device_id device, cl_context context,
+                      cl_command_queue queue, int num_elements)
+{
+    return test_image_set(device, context, queue, k1DTo1DBuffer);
+}
+int test_1DbufferTo1D(cl_device_id device, cl_context context,
+                      cl_command_queue queue, int num_elements)
+{
+    return test_image_set(device, context, queue, k1DBufferTo1D);
+}
 int test_1Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
 {
     return test_image_set( device, context, queue, k1DArray );
@@ -79,17 +94,11 @@ int test_3Dto2Darray(cl_device_id device, cl_context context, cl_command_queue q
 }
 
 test_definition test_list[] = {
-    ADD_TEST( 1D ),
-    ADD_TEST( 2D ),
-    ADD_TEST( 3D ),
-    ADD_TEST( 1Darray ),
-    ADD_TEST( 2Darray ),
-    ADD_TEST( 2Dto3D ),
-    ADD_TEST( 3Dto2D ),
-    ADD_TEST( 2Darrayto2D ),
-    ADD_TEST( 2Dto2Darray ),
-    ADD_TEST( 2Darrayto3D ),
-    ADD_TEST( 3Dto2Darray ),
+    ADD_TEST(1D),           ADD_TEST(2D),           ADD_TEST(3D),
+    ADD_TEST(1Darray),      ADD_TEST(2Darray),      ADD_TEST(2Dto3D),
+    ADD_TEST(3Dto2D),       ADD_TEST(2Darrayto2D),  ADD_TEST(2Dto2Darray),
+    ADD_TEST(2Darrayto3D),  ADD_TEST(3Dto2Darray),  ADD_TEST(1Dbuffer),
+    ADD_TEST(1DTo1Dbuffer), ADD_TEST(1DbufferTo1D),
 };
 
 const int test_num = ARRAY_SIZE( test_list );

test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp

@@ -0,0 +1,516 @@
+//
+// Copyright (c) 2023 The Khronos Group Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "../testBase.h"
+
+extern int test_copy_image_generic(cl_context context, cl_command_queue queue,
+                                   image_descriptor *srcImageInfo,
+                                   image_descriptor *dstImageInfo,
+                                   const size_t sourcePos[],
+                                   const size_t destPos[],
+                                   const size_t regionSize[], MTdata d);
+
+int test_copy_image_size_1D_buffer(cl_context context, cl_command_queue queue,
+                                   image_descriptor *srcImageInfo,
+                                   image_descriptor *dstImageInfo, MTdata d)
+{
+    size_t sourcePos[3], destPos[3], regionSize[3];
+    int ret = 0, retCode;
+    size_t width_lod = srcImageInfo->width;
+
+    // First, try just a full covering region
+    sourcePos[0] = sourcePos[1] = sourcePos[2] = 0;
+    destPos[0] = destPos[1] = destPos[2] = 0;
+    regionSize[0] = srcImageInfo->width;
+    regionSize[1] = 1;
+    regionSize[2] = 1;
+
+    retCode =
+        test_copy_image_generic(context, queue, srcImageInfo, dstImageInfo,
+                                sourcePos, destPos, regionSize, d);
+    if (retCode < 0)
+        return retCode;
+    else
+        ret += retCode;
+
+    // Now try a sampling of different random regions
+    for (int i = 0; i < 8; i++)
+    {
+        // Pick a random size
+        regionSize[0] = (width_lod > 8)
+            ? (size_t)random_in_range(8, (int)width_lod - 1, d)
+            : width_lod;
+
+        // Now pick positions within valid ranges
+        sourcePos[0] = (width_lod > regionSize[0]) ? (size_t)random_in_range(
+                           0, (int)(width_lod - regionSize[0] - 1), d)
+                                                   : 0;
+        destPos[0] = (width_lod > regionSize[0]) ? (size_t)random_in_range(
+                         0, (int)(width_lod - regionSize[0] - 1), d)
+                                                 : 0;
+
+
+        // Go for it!
+        retCode =
+            test_copy_image_generic(context, queue, srcImageInfo, srcImageInfo,
+                                    sourcePos, destPos, regionSize, d);
+        if (retCode < 0)
+            return retCode;
+        else
+            ret += retCode;
+    }
+
+    return ret;
+}
+
+int test_copy_image_set_1D_buffer(cl_device_id device, cl_context context,
+                                  cl_command_queue queue,
+                                  cl_image_format *format)
+{
+    size_t maxWidth;
+    cl_ulong maxAllocSize, memSize;
+    image_descriptor imageInfo = { 0 };
+    RandomSeed seed(gRandomSeed);
+    size_t pixelSize;
+
+    if (gTestMipmaps)
+    {
+        // 1D image buffers don't support mipmaps
+        // https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_Ext.html#cl_khr_mipmap_image
+        return 0;
+    }
+
+    imageInfo.format = format;
+    imageInfo.height = imageInfo.depth = imageInfo.arraySize =
+        imageInfo.slicePitch = 0;
+    imageInfo.type = CL_MEM_OBJECT_IMAGE1D_BUFFER;
+    pixelSize = get_pixel_size(imageInfo.format);
+
+    int error = clGetDeviceInfo(device, CL_DEVICE_IMAGE_MAX_BUFFER_SIZE,
+                                sizeof(maxWidth), &maxWidth, NULL);
+    error |= clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
+                             sizeof(maxAllocSize), &maxAllocSize, NULL);
+    error |= clGetDeviceInfo(device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(memSize),
+                             &memSize, NULL);
+    test_error(error, "Unable to get max image 1D buffer size from device");
+
+    if (memSize > (cl_ulong)SIZE_MAX)
+    {
+        memSize = (cl_ulong)SIZE_MAX;
+        maxAllocSize = (cl_ulong)SIZE_MAX;
+    }
+
+    if (gTestSmallImages)
+    {
+        for (imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++)
+        {
+            size_t rowPadding = gEnablePitch ? 48 : 0;
+            imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding;
+
+            if (gEnablePitch)
+            {
+                do
+                {
+                    rowPadding++;
+                    imageInfo.rowPitch =
+                        imageInfo.width * pixelSize + rowPadding;
+                } while ((imageInfo.rowPitch % pixelSize) != 0);
+            }
+
+            if (gDebugTrace) log_info("   at size %d\n", (int)imageInfo.width);
+
+            int ret = test_copy_image_size_1D_buffer(context, queue, &imageInfo,
+                                                     &imageInfo, seed);
+            if (ret) return -1;
+        }
+    }
+    else if (gTestMaxImages)
+    {
+        // Try a specific set of maximum sizes
+        size_t numbeOfSizes;
+        size_t sizes[100][3];
+
+        get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, 1, 1, 1,
+                      maxAllocSize, memSize, CL_MEM_OBJECT_IMAGE1D_BUFFER,
+                      imageInfo.format);
+
+        for (size_t idx = 0; idx < numbeOfSizes; idx++)
+        {
+            size_t rowPadding = gEnablePitch ? 48 : 0;
+            imageInfo.width = sizes[idx][0];
+            imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding;
+
+            if (gEnablePitch)
+            {
+                do
+                {
+                    rowPadding++;
+                    imageInfo.rowPitch =
+                        imageInfo.width * pixelSize + rowPadding;
+                } while ((imageInfo.rowPitch % pixelSize) != 0);
+            }
+
+            log_info("Testing %d\n", (int)sizes[idx][0]);
+            if (gDebugTrace)
+                log_info("   at max size %d\n", (int)sizes[idx][0]);
+            if (test_copy_image_size_1D_buffer(context, queue, &imageInfo,
+                                               &imageInfo, seed))
+                return -1;
+        }
+    }
+    else
+    {
+        for (int i = 0; i < NUM_IMAGE_ITERATIONS; i++)
+        {
+            cl_ulong size;
+            size_t rowPadding = gEnablePitch ? 48 : 0;
+            // Loop until we get a size that a) will fit in the max alloc size
+            // and b) that an allocation of that image, the result array, plus
+            // offset arrays, will fit in the global ram space
+            do
+            {
+                imageInfo.width =
+                    (size_t)random_log_in_range(16, (int)maxWidth / 32, seed);
+
+                imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding;
+
+                if (gEnablePitch)
+                {
+                    do
+                    {
+                        rowPadding++;
+                        imageInfo.rowPitch =
+                            imageInfo.width * pixelSize + rowPadding;
+                    } while ((imageInfo.rowPitch % pixelSize) != 0);
+                }
+
+                size = (size_t)imageInfo.rowPitch * 4;
+            } while (size > maxAllocSize || (size * 3) > memSize);
+
+            if (gDebugTrace)
+            {
+                log_info("   at size %d (row pitch %d) out of %d\n",
+                         (int)imageInfo.width, (int)imageInfo.rowPitch,
+                         (int)maxWidth);
+            }
+
+            int ret = test_copy_image_size_1D_buffer(context, queue, &imageInfo,
+                                                     &imageInfo, seed);
+            if (ret) return -1;
+        }
+    }
+
+    return 0;
+}
+
+int test_copy_image_set_1D_1D_buffer(cl_device_id device, cl_context context,
+                                     cl_command_queue queue,
+                                     cl_image_format *format)
+{
+    size_t maxWidth;
+    cl_ulong maxAllocSize, memSize;
+    image_descriptor imageInfo = { 0 };
+    RandomSeed seed(gRandomSeed);
+    size_t pixelSize;
+
+    if (gTestMipmaps)
+    {
+        // 1D image buffers don't support mipmaps
+        // https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_Ext.html#cl_khr_mipmap_image
+        return 0;
+    }
+
+    imageInfo.format = format;
+    imageInfo.height = imageInfo.depth = imageInfo.arraySize =
+        imageInfo.slicePitch = 0;
+    imageInfo.type = CL_MEM_OBJECT_IMAGE1D_BUFFER;
+    pixelSize = get_pixel_size(imageInfo.format);
+
+    int error = clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_WIDTH,
+                                sizeof(maxWidth), &maxWidth, NULL);
+    error |= clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
+                             sizeof(maxAllocSize), &maxAllocSize, NULL);
+    error |= clGetDeviceInfo(device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(memSize),
+                             &memSize, NULL);
+    test_error(error, "Unable to get max image 1D buffer size from device");
+
+    if (memSize > (cl_ulong)SIZE_MAX)
+    {
+        memSize = (cl_ulong)SIZE_MAX;
+        maxAllocSize = (cl_ulong)SIZE_MAX;
+    }
+
+    if (gTestSmallImages)
+    {
+        for (imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++)
+        {
+            size_t rowPadding = gEnablePitch ? 48 : 0;
+            imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding;
+
+            if (gEnablePitch)
+            {
+                do
+                {
+                    rowPadding++;
+                    imageInfo.rowPitch =
+                        imageInfo.width * pixelSize + rowPadding;
+                } while ((imageInfo.rowPitch % pixelSize) != 0);
+            }
+
+            if (gDebugTrace) log_info("   at size %d\n", (int)imageInfo.width);
+
+            image_descriptor srcImageInfo = imageInfo;
+            srcImageInfo.type = CL_MEM_OBJECT_IMAGE1D;
+
+            int ret = test_copy_image_size_1D_buffer(
+                context, queue, &srcImageInfo, &imageInfo, seed);
+            if (ret) return -1;
+        }
+    }
+    else if (gTestMaxImages)
+    {
+        // Try a specific set of maximum sizes
+        size_t numbeOfSizes;
+        size_t sizes[100][3];
+
+        get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, 1, 1, 1,
+                      maxAllocSize, memSize, CL_MEM_OBJECT_IMAGE1D_BUFFER,
+                      imageInfo.format);
+
+        for (size_t idx = 0; idx < numbeOfSizes; idx++)
+        {
+            size_t rowPadding = gEnablePitch ? 48 : 0;
+            imageInfo.width = sizes[idx][0];
+            imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding;
+
+            if (gEnablePitch)
+            {
+                do
+                {
+                    rowPadding++;
+                    imageInfo.rowPitch =
+                        imageInfo.width * pixelSize + rowPadding;
+                } while ((imageInfo.rowPitch % pixelSize) != 0);
+            }
+
+            log_info("Testing %d\n", (int)sizes[idx][0]);
+            if (gDebugTrace)
+                log_info("   at max size %d\n", (int)sizes[idx][0]);
+
+            image_descriptor srcImageInfo = imageInfo;
+            srcImageInfo.type = CL_MEM_OBJECT_IMAGE1D;
+
+            if (test_copy_image_size_1D_buffer(context, queue, &srcImageInfo,
+                                               &imageInfo, seed))
+                return -1;
+        }
+    }
+    else
+    {
+        for (int i = 0; i < NUM_IMAGE_ITERATIONS; i++)
+        {
+            cl_ulong size;
+            size_t rowPadding = gEnablePitch ? 48 : 0;
+            // Loop until we get a size that a) will fit in the max alloc size
+            // and b) that an allocation of that image, the result array, plus
+            // offset arrays, will fit in the global ram space
+            do
+            {
+                imageInfo.width =
+                    (size_t)random_log_in_range(16, (int)maxWidth / 32, seed);
+
+                imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding;
+
+                if (gEnablePitch)
+                {
+                    do
+                    {
+                        rowPadding++;
+                        imageInfo.rowPitch =
+                            imageInfo.width * pixelSize + rowPadding;
+                    } while ((imageInfo.rowPitch % pixelSize) != 0);
+                }
+
+                size = (size_t)imageInfo.rowPitch * 4;
+            } while (size > maxAllocSize || (size * 3) > memSize);
+
+            if (gDebugTrace)
+            {
+                log_info("   at size %d (row pitch %d) out of %d\n",
+                         (int)imageInfo.width, (int)imageInfo.rowPitch,
+                         (int)maxWidth);
+            }
+
+            image_descriptor srcImageInfo = imageInfo;
+            srcImageInfo.type = CL_MEM_OBJECT_IMAGE1D;
+
+            int ret = test_copy_image_size_1D_buffer(
+                context, queue, &srcImageInfo, &imageInfo, seed);
+            if (ret) return -1;
+        }
+    }
+
+    return 0;
+}
+
+int test_copy_image_set_1D_buffer_1D(cl_device_id device, cl_context context,
+                                     cl_command_queue queue,
+                                     cl_image_format *format)
+{
+    size_t maxWidth;
+    cl_ulong maxAllocSize, memSize;
+    image_descriptor imageInfo = { 0 };
+    RandomSeed seed(gRandomSeed);
+    size_t pixelSize;
+
+    if (gTestMipmaps)
+    {
+        // 1D image buffers don't support mipmaps
+        // https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_Ext.html#cl_khr_mipmap_image
+        return 0;
+    }
+
+    imageInfo.format = format;
+    imageInfo.height = imageInfo.depth = imageInfo.arraySize =
+        imageInfo.slicePitch = 0;
+    imageInfo.type = CL_MEM_OBJECT_IMAGE1D_BUFFER;
+    pixelSize = get_pixel_size(imageInfo.format);
+
+    int error = clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_WIDTH,
+                                sizeof(maxWidth), &maxWidth, NULL);
+    error |= clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
+                             sizeof(maxAllocSize), &maxAllocSize, NULL);
+    error |= clGetDeviceInfo(device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(memSize),
+                             &memSize, NULL);
+    test_error(error, "Unable to get max image 1D buffer size from device");
+
+    if (memSize > (cl_ulong)SIZE_MAX)
+    {
+        memSize = (cl_ulong)SIZE_MAX;
+        maxAllocSize = (cl_ulong)SIZE_MAX;
+    }
+
+    if (gTestSmallImages)
+    {
+        for (imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++)
+        {
+            size_t rowPadding = gEnablePitch ? 48 : 0;
+            imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding;
+
+            if (gEnablePitch)
+            {
+                do
+                {
+                    rowPadding++;
+                    imageInfo.rowPitch =
+                        imageInfo.width * pixelSize + rowPadding;
+                } while ((imageInfo.rowPitch % pixelSize) != 0);
+            }
+
+            if (gDebugTrace) log_info("   at size %d\n", (int)imageInfo.width);
+
+            image_descriptor dstImageInfo = imageInfo;
+            dstImageInfo.type = CL_MEM_OBJECT_IMAGE1D;
+
+            int ret = test_copy_image_size_1D_buffer(context, queue, &imageInfo,
+                                                     &dstImageInfo, seed);
+            if (ret) return -1;
+        }
+    }
+    else if (gTestMaxImages)
+    {
+        // Try a specific set of maximum sizes
+        size_t numbeOfSizes;
+        size_t sizes[100][3];
+
+        get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, 1, 1, 1,
+                      maxAllocSize, memSize, CL_MEM_OBJECT_IMAGE1D_BUFFER,
+                      imageInfo.format);
+
+        for (size_t idx = 0; idx < numbeOfSizes; idx++)
+        {
+            size_t rowPadding = gEnablePitch ? 48 : 0;
+            imageInfo.width = sizes[idx][0];
+            imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding;
+
+            if (gEnablePitch)
+            {
+                do
+                {
+                    rowPadding++;
+                    imageInfo.rowPitch =
+                        imageInfo.width * pixelSize + rowPadding;
+                } while ((imageInfo.rowPitch % pixelSize) != 0);
+            }
+
+            log_info("Testing %d\n", (int)sizes[idx][0]);
+            if (gDebugTrace)
+                log_info("   at max size %d\n", (int)sizes[idx][0]);
+
+            image_descriptor dstImageInfo = imageInfo;
+            dstImageInfo.type = CL_MEM_OBJECT_IMAGE1D;
+
+            if (test_copy_image_size_1D_buffer(context, queue, &imageInfo,
+                                               &dstImageInfo, seed))
+                return -1;
+        }
+    }
+    else
+    {
+        for (int i = 0; i < NUM_IMAGE_ITERATIONS; i++)
+        {
+            cl_ulong size;
+            size_t rowPadding = gEnablePitch ? 48 : 0;
+            // Loop until we get a size that a) will fit in the max alloc size
+            // and b) that an allocation of that image, the result array, plus
+            // offset arrays, will fit in the global ram space
+            do
+            {
+                imageInfo.width =
+                    (size_t)random_log_in_range(16, (int)maxWidth / 32, seed);
+
+                imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding;
+
+                if (gEnablePitch)
+                {
+                    do
+                    {
+                        rowPadding++;
+                        imageInfo.rowPitch =
+                            imageInfo.width * pixelSize + rowPadding;
+                    } while ((imageInfo.rowPitch % pixelSize) != 0);
+                }
+
+                size = (size_t)imageInfo.rowPitch * 4;
+            } while (size > maxAllocSize || (size * 3) > memSize);
+
+            if (gDebugTrace)
+            {
+                log_info("   at size %d (row pitch %d) out of %d\n",
+                         (int)imageInfo.width, (int)imageInfo.rowPitch,
+                         (int)maxWidth);
+            }
+
+            image_descriptor dstImageInfo = imageInfo;
+            dstImageInfo.type = CL_MEM_OBJECT_IMAGE1D;
+
+            int ret = test_copy_image_size_1D_buffer(context, queue, &imageInfo,
+                                                     &dstImageInfo, seed);
+            if (ret) return -1;
+        }
+    }
+
+    return 0;
+}

test_conformance/images/clCopyImage/test_copy_generic.cpp

@@ -14,12 +14,18 @@
 // limitations under the License.
 //
 #include "../testBase.h"
+#include <CL/cl.h>
 
 static void CL_CALLBACK free_pitch_buffer( cl_mem image, void *buf )
 {
     free( buf );
 }
 
+static void CL_CALLBACK release_cl_buffer(cl_mem image, void *buf)
+{
+    clReleaseMemObject((cl_mem)buf);
+}
+
 cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr<char>& data, image_descriptor *imageInfo, int *error )
 {
     cl_mem img;
@@ -69,6 +75,71 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr
             if ( gEnablePitch )
                 host_ptr = malloc( imageInfo->arraySize * imageInfo->slicePitch );
             break;
+        case CL_MEM_OBJECT_IMAGE1D_BUFFER:
+            if (gDebugTrace)
+                log_info(" - Creating 1D buffer image %d ...\n",
+                         (int)imageInfo->width);
+            {
+                cl_int err;
+                cl_mem_flags buffer_flags = CL_MEM_READ_WRITE;
+                if (gEnablePitch)
+                {
+                    cl_device_id device;
+                    err =
+                        clGetCommandQueueInfo(queue, CL_QUEUE_DEVICE,
+                                              sizeof(device), &device, nullptr);
+                    if (err != CL_SUCCESS)
+                    {
+                        log_error(
+                            "Error: Could not get CL_QUEUE_DEVICE from queue");
+                        return NULL;
+                    }
+                    char major_version;
+                    err = clGetDeviceInfo(device, CL_DEVICE_VERSION,
+                                          sizeof(major_version), &major_version,
+                                          nullptr);
+                    if (err != CL_SUCCESS)
+                    {
+                        log_error("Error: Could not get CL_DEVICE_VERSION from "
+                                  "device");
+                        return NULL;
+                    }
+                    if (major_version == '1')
+                    {
+                        host_ptr = malloc(imageInfo->rowPitch);
+                    }
+                    else
+                    {
+                        cl_uint base_address_alignment = 0;
+                        err = clGetDeviceInfo(
+                            device, CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT,
+                            sizeof(base_address_alignment),
+                            &base_address_alignment, nullptr);
+                        if (err != CL_SUCCESS)
+                        {
+                            log_error("ERROR: Could not get "
+                                      "CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT "
+                                      "from device");
+                            return NULL;
+                        }
+                        host_ptr = align_malloc(imageInfo->rowPitch,
+                                                base_address_alignment);
+                    }
+                    buffer_flags |= CL_MEM_USE_HOST_PTR;
+                }
+
+                cl_mem buffer = clCreateBuffer(context, buffer_flags,
+                                               imageInfo->rowPitch, NULL, &err);
+                if (err != CL_SUCCESS)
+                {
+                    log_error("ERROR: Could not create buffer for 1D buffer "
+                              "image. %ld bytes\n",
+                              imageInfo->width);
+                    return NULL;
+                }
+                imageDesc.buffer = buffer;
+            }
+            break;
     }
 
     if ( gDebugTrace && gTestMipmaps )
@@ -81,7 +152,10 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr
             log_error( "ERROR: Unable to create backing store for pitched 3D image. %ld bytes\n",  imageInfo->depth * imageInfo->slicePitch );
             return NULL;
         }
-        mem_flags = CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR;
+        if (imageInfo->type != CL_MEM_OBJECT_IMAGE1D_BUFFER)
+        {
+            mem_flags = CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR;
+        }
     }
 
     img = clCreateImage(context, mem_flags, imageInfo->format, &imageDesc, host_ptr, error);
@@ -103,6 +177,21 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr
             free(host_ptr);
     }
 
+    if (imageDesc.buffer != NULL)
+    {
+        int callbackError = clSetMemObjectDestructorCallback(
+            img, release_cl_buffer, imageDesc.buffer);
+        if (callbackError != CL_SUCCESS)
+        {
+            log_error("Error: Unable to attach destructor callback to 1d "
+                      "buffer image. Err: %d\n",
+                      callbackError);
+            clReleaseMemObject(imageDesc.buffer);
+            clReleaseMemObject(img);
+            return NULL;
+        }
+    }
+
     if ( *error != CL_SUCCESS )
     {
         long long unsigned imageSize = get_image_size_mb(imageInfo);
@@ -141,6 +230,12 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr
                           (int)imageInfo->arraySize, imageSize,
                           IGetErrorString(*error));
                 break;
+            case CL_MEM_OBJECT_IMAGE1D_BUFFER:
+                log_error(
+                    "ERROR: Unable to create 1D buffer image of size %d (%llu "
+                    "MB):(%s)",
+                    (int)imageInfo->width, imageSize, IGetErrorString(*error));
+                break;
         }
         log_error("ERROR: and %llu mip levels\n", (unsigned long long) imageInfo->num_mip_levels);
         return NULL;
@@ -161,6 +256,7 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr
             height = imageInfo->arraySize;
             depth = 1;
             break;
+        case CL_MEM_OBJECT_IMAGE1D_BUFFER:
         case CL_MEM_OBJECT_IMAGE1D:
             height = depth = 1;
             break;
@@ -196,6 +292,7 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr
                 case CL_MEM_OBJECT_IMAGE1D_ARRAY:
                     origin[ 2 ] =  lod;
                     break;
+                case CL_MEM_OBJECT_IMAGE1D_BUFFER:
                 case CL_MEM_OBJECT_IMAGE1D:
                     origin[ 1 ] = lod;
                     break;
@@ -210,6 +307,7 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr
                 case CL_MEM_OBJECT_IMAGE2D:
                     height = ( imageInfo->height >> lod ) ? (imageInfo->height >> lod) : 1;
                 case CL_MEM_OBJECT_IMAGE1D_ARRAY:
+                case CL_MEM_OBJECT_IMAGE1D_BUFFER:
                 case CL_MEM_OBJECT_IMAGE1D:
                     width = ( imageInfo->width >> lod ) ? (imageInfo->width >> lod) : 1;
             }
@@ -260,6 +358,7 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr
                     break;
                 case CL_MEM_OBJECT_IMAGE1D_ARRAY:
                 case CL_MEM_OBJECT_IMAGE1D:
+                case CL_MEM_OBJECT_IMAGE1D_BUFFER:
                     dstPitch2D = mappedSlice;
                     break;
             }
@@ -391,8 +490,7 @@ int test_copy_image_generic( cl_context context, cl_command_queue queue, image_d
         switch(dstImageInfo->type)
         {
             case CL_MEM_OBJECT_IMAGE1D:
-                dst_lod = destPos[1];
-                break;
+            case CL_MEM_OBJECT_IMAGE1D_BUFFER: dst_lod = destPos[1]; break;
             case CL_MEM_OBJECT_IMAGE1D_ARRAY:
             case CL_MEM_OBJECT_IMAGE2D:
                 dst_lod = destPos[2];
@@ -407,6 +505,7 @@ int test_copy_image_generic( cl_context context, cl_command_queue queue, image_d
     }
     switch (dstImageInfo->type)
     {
+        case CL_MEM_OBJECT_IMAGE1D_BUFFER:
         case CL_MEM_OBJECT_IMAGE1D:
             if( gTestMipmaps )
                 origin[ 1 ] = dst_lod;
@@ -542,6 +641,7 @@ int test_copy_image_generic( cl_context context, cl_command_queue queue, image_d
             secondDim = dstImageInfo->height;
             break;
         }
+        case CL_MEM_OBJECT_IMAGE1D_BUFFER:
         case CL_MEM_OBJECT_IMAGE1D: {
             break;
         }

test_conformance/images/clCopyImage/test_loops.cpp

@@ -24,6 +24,18 @@ extern int test_copy_image_set_2D_array( cl_device_id device, cl_context context
 extern int test_copy_image_set_2D_3D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, bool reverse );
 extern int test_copy_image_set_2D_2D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, bool reverse );
 extern int test_copy_image_set_3D_2D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, bool reverse );
+extern int test_copy_image_set_1D_buffer(cl_device_id device,
+                                         cl_context context,
+                                         cl_command_queue queue,
+                                         cl_image_format *format);
+extern int test_copy_image_set_1D_1D_buffer(cl_device_id device,
+                                            cl_context context,
+                                            cl_command_queue queue,
+                                            cl_image_format *format);
+extern int test_copy_image_set_1D_buffer_1D(cl_device_id device,
+                                            cl_context context,
+                                            cl_command_queue queue,
+                                            cl_image_format *format);
 
 int test_image_type( cl_device_id device, cl_context context, cl_command_queue queue, MethodsToTest testMethod, cl_mem_flags flags )
 {
@@ -87,6 +99,18 @@ int test_image_type( cl_device_id device, cl_context context, cl_command_queue q
             name = "3D -> 2D array";
             imageType = CL_MEM_OBJECT_IMAGE3D;
             break;
+        case k1DBuffer:
+            name = "1D buffer -> 1D buffer";
+            imageType = CL_MEM_OBJECT_IMAGE1D_BUFFER;
+            break;
+        case k1DTo1DBuffer:
+            name = "1D -> 1D buffer";
+            imageType = CL_MEM_OBJECT_IMAGE1D_BUFFER;
+            break;
+        case k1DBufferTo1D:
+            name = "1D buffer -> 1D";
+            imageType = CL_MEM_OBJECT_IMAGE1D_BUFFER;
+            break;
     }
 
     if(gTestMipmaps)
@@ -138,6 +162,16 @@ int test_image_type( cl_device_id device, cl_context context, cl_command_queue q
             test_return = test_copy_image_set_3D_2D_array( device, context, queue, &formatList[ i ], true);
         else if( testMethod == k3DTo2DArray)
             test_return = test_copy_image_set_3D_2D_array( device, context, queue, &formatList[ i ], false);
+        else if (testMethod == k1DBuffer)
+            test_return = test_copy_image_set_1D_buffer(device, context, queue,
+                                                        &formatList[i]);
+        else if (testMethod == k1DBufferTo1D)
+            test_return = test_copy_image_set_1D_buffer_1D(
+                device, context, queue, &formatList[i]);
+        else if (testMethod == k1DTo1DBuffer)
+            test_return = test_copy_image_set_1D_1D_buffer(
+                device, context, queue, &formatList[i]);
+
 
         if (test_return) {
             gFailCount++;