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/clFillImage/CMakeLists.txt

@@ -4,6 +4,7 @@ set(MODULE_NAME CL_FILL_IMAGES)
 set(${MODULE_NAME}_SOURCES
     main.cpp
     test_fill_1D.cpp
+    test_fill_1D_buffer.cpp
     test_fill_1D_array.cpp
     test_fill_2D.cpp
     test_fill_2D_array.cpp

test_conformance/images/clFillImage/main.cpp

@@ -52,13 +52,15 @@ int test_2Darray(cl_device_id device, cl_context context, cl_command_queue queue
 {
     return test_image_set(device, context, queue, k2DArray);
 }
+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);
+}
 
 test_definition test_list[] = {
-    ADD_TEST( 1D ),
-    ADD_TEST( 2D ),
-    ADD_TEST( 3D ),
-    ADD_TEST( 1Darray ),
-    ADD_TEST( 2Darray ),
+    ADD_TEST(1D),      ADD_TEST(2D),      ADD_TEST(3D),
+    ADD_TEST(1Darray), ADD_TEST(2Darray), ADD_TEST(1Dbuffer),
 };
 
 const int test_num = ARRAY_SIZE( test_list );

test_conformance/images/clFillImage/test_fill_1D_buffer.cpp

@@ -0,0 +1,203 @@
+//
+// 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"
+
+// Defined in test_fill_2D_3D.cpp
+extern int test_fill_image_generic(cl_context context, cl_command_queue queue,
+                                   image_descriptor *imageInfo,
+                                   const size_t origin[], const size_t region[],
+                                   ExplicitType outputType, MTdata d);
+
+
+int test_fill_image_size_1D_buffer(cl_context context, cl_command_queue queue,
+                                   image_descriptor *imageInfo,
+                                   ExplicitType outputType, MTdata d)
+{
+    size_t origin[3], region[3];
+    int ret = 0, retCode;
+
+    // First, try just a full covering region fill
+    origin[0] = origin[1] = origin[2] = 0;
+    region[0] = imageInfo->width;
+    region[1] = 1;
+    region[2] = 1;
+
+    retCode = test_fill_image_generic(context, queue, imageInfo, origin, region,
+                                      outputType, 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
+        region[0] = (imageInfo->width > 8)
+            ? (size_t)random_in_range(8, (int)imageInfo->width - 1, d)
+            : imageInfo->width;
+
+        // Now pick positions within valid ranges
+        origin[0] = (imageInfo->width > region[0]) ? (size_t)random_in_range(
+                        0, (int)(imageInfo->width - region[0] - 1), d)
+                                                   : 0;
+
+        // Go for it!
+        retCode = test_fill_image_generic(context, queue, imageInfo, origin,
+                                          region, outputType, d);
+        if (retCode < 0)
+            return retCode;
+        else
+            ret += retCode;
+    }
+
+    return ret;
+}
+
+
+int test_fill_image_set_1D_buffer(cl_device_id device, cl_context context,
+                                  cl_command_queue queue,
+                                  cl_image_format *format,
+                                  ExplicitType outputType)
+{
+    size_t maxWidth;
+    cl_ulong maxAllocSize, memSize;
+    image_descriptor imageInfo = { 0 };
+    RandomSeed seed(gRandomSeed);
+    const size_t rowPadding_default = 48;
+    size_t rowPadding = gEnablePitch ? rowPadding_default : 0;
+    size_t pixelSize;
+
+    memset(&imageInfo, 0x0, sizeof(image_descriptor));
+    imageInfo.type = CL_MEM_OBJECT_IMAGE1D_BUFFER;
+    imageInfo.format = format;
+    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 2D 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++)
+        {
+            imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding;
+
+            if (gEnablePitch)
+            {
+                rowPadding = rowPadding_default;
+                do
+                {
+                    rowPadding++;
+                    imageInfo.rowPitch =
+                        imageInfo.width * pixelSize + rowPadding;
+                } while ((imageInfo.rowPitch % pixelSize) != 0);
+            }
+
+            if (gDebugTrace)
+                log_info("   at size %d,%d\n", (int)imageInfo.width,
+                         (int)imageInfo.height);
+
+            int ret = test_fill_image_size_1D_buffer(context, queue, &imageInfo,
+                                                     outputType, 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++)
+        {
+            imageInfo.width = sizes[idx][0];
+            imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding;
+
+            if (gEnablePitch)
+            {
+                rowPadding = rowPadding_default;
+                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_fill_image_size_1D_buffer(context, queue, &imageInfo,
+                                               outputType, seed))
+                return -1;
+        }
+    }
+    else
+    {
+        for (int i = 0; i < NUM_IMAGE_ITERATIONS; i++)
+        {
+            cl_ulong size;
+            // 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)
+                {
+                    rowPadding = rowPadding_default;
+                    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_fill_image_size_1D_buffer(context, queue, &imageInfo,
+                                                     outputType, seed);
+            if (ret) return -1;
+        }
+    }
+
+    return 0;
+}

test_conformance/images/clFillImage/test_fill_generic.cpp

@@ -17,9 +17,27 @@
 
 extern void read_image_pixel_float( void *imageData, image_descriptor *imageInfo, int x, int y, int z, float *outData );
 
-static void CL_CALLBACK free_pitch_buffer( cl_mem image, void *buf )
+struct pitch_buffer_data
 {
-    free( buf );
+    void *buf;
+    bool is_aligned;
+};
+static void CL_CALLBACK free_pitch_buffer(cl_mem image, void *data)
+{
+    struct pitch_buffer_data *d = (struct pitch_buffer_data *)data;
+    if (d->is_aligned)
+    {
+        align_free(d->buf);
+    }
+    else
+    {
+        free(d->buf);
+    }
+    free(d);
+}
+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 )
@@ -38,6 +56,26 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr
     imageDesc.image_row_pitch = gEnablePitch ? imageInfo->rowPitch : 0;
     imageDesc.image_slice_pitch = gEnablePitch ? imageInfo->slicePitch : 0;
 
+    cl_version version;
+    cl_device_id device;
+    {
+        cl_int 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;
+        }
+        err = clGetDeviceInfo(device, CL_DEVICE_NUMERIC_VERSION,
+                              sizeof(version), &version, nullptr);
+        if (err != CL_SUCCESS)
+        {
+            log_error("Error: Could not get CL_DEVICE_NUMERIC_VERSION from "
+                      "device");
+            return NULL;
+        }
+    }
+
     switch (imageInfo->type)
     {
         case CL_MEM_OBJECT_IMAGE1D:
@@ -70,6 +108,50 @@ 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)
+                {
+                    if (CL_VERSION_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, host_ptr, &err);
+                if (err != CL_SUCCESS)
+                {
+                    log_error("ERROR: Could not create buffer for 1D buffer "
+                              "image. %ld bytes\n",
+                              imageInfo->rowPitch);
+                    return NULL;
+                }
+                imageDesc.buffer = buffer;
+            }
+            break;
     }
 
     if (gEnablePitch)
@@ -79,26 +161,63 @@ 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);
+    if (imageInfo->type != CL_MEM_OBJECT_IMAGE1D_BUFFER)
+    {
+        img = clCreateImage(context, mem_flags, imageInfo->format, &imageDesc,
+                            host_ptr, error);
+    }
+    else
+    {
+        img = clCreateImage(context, mem_flags, imageInfo->format, &imageDesc,
+                            nullptr, error);
+    }
 
     if (gEnablePitch)
     {
-        if ( *error == CL_SUCCESS )
+        struct pitch_buffer_data *data = (struct pitch_buffer_data *)malloc(
+            sizeof(struct pitch_buffer_data));
+        data->buf = host_ptr;
+        data->is_aligned = (CL_VERSION_MAJOR(version) != 1)
+            && (imageInfo->type == CL_MEM_OBJECT_IMAGE1D_BUFFER);
+        if (*error == CL_SUCCESS)
         {
-            int callbackError = clSetMemObjectDestructorCallback( img, free_pitch_buffer, host_ptr );
-            if ( CL_SUCCESS != callbackError )
+            int callbackError =
+                clSetMemObjectDestructorCallback(img, free_pitch_buffer, data);
+            if (CL_SUCCESS != callbackError)
             {
-                free( host_ptr );
-                log_error( "ERROR: Unable to attach destructor callback to pitched 3D image. Err: %d\n", callbackError );
-                clReleaseMemObject( img );
+                free_pitch_buffer(img, data);
+                log_error("ERROR: Unable to attach destructor callback to "
+                          "pitched 3D image. Err: %d\n",
+                          callbackError);
+                clReleaseMemObject(img);
                 return NULL;
             }
         }
         else
-            free(host_ptr);
+        {
+            free_pitch_buffer(img, data);
+        }
+    }
+
+    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 )
@@ -122,6 +241,12 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr
             case CL_MEM_OBJECT_IMAGE2D_ARRAY:
                 log_error( "ERROR: Unable to create 2D image array of size %d x %d x %d (%llu MB): %s\n", (int)imageInfo->width, (int)imageInfo->height, (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;
         }
         return NULL;
     }
@@ -139,6 +264,7 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr
             depth = 1;
             imageSize = imageInfo->rowPitch * imageInfo->arraySize;
             break;
+        case CL_MEM_OBJECT_IMAGE1D_BUFFER:
         case CL_MEM_OBJECT_IMAGE1D:
             height = depth = 1;
             imageSize = imageInfo->rowPitch;
@@ -194,8 +320,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:
-                dstPitch2D = mappedSlice;
-                break;
+            case CL_MEM_OBJECT_IMAGE1D_BUFFER: dstPitch2D = mappedSlice; break;
         }
 
         for ( size_t z = 0; z < depth; z++ )
@@ -286,6 +411,9 @@ int test_fill_image_generic( cl_context context, cl_command_queue queue, image_d
         case CL_MEM_OBJECT_IMAGE2D_ARRAY:
             dataBytes = imageInfo->arraySize * imageInfo->slicePitch;
             break;
+        case CL_MEM_OBJECT_IMAGE1D_BUFFER:
+            dataBytes = imageInfo->rowPitch;
+            break;
     }
 
     if (dataBytes > imgData.getSize())
@@ -398,6 +526,7 @@ int test_fill_image_generic( cl_context context, cl_command_queue queue, image_d
     size_t imageRegion[ 3 ] = { imageInfo->width, 1, 1 };
     switch (imageInfo->type)
     {
+        case CL_MEM_OBJECT_IMAGE1D_BUFFER:
         case CL_MEM_OBJECT_IMAGE1D:
             break;
         case CL_MEM_OBJECT_IMAGE2D:
@@ -437,28 +566,30 @@ int test_fill_image_generic( cl_context context, cl_command_queue queue, image_d
     size_t secondDim = 1;
 
     switch (imageInfo->type) {
-      case CL_MEM_OBJECT_IMAGE1D:
-        secondDim = 1;
-        thirdDim = 1;
-        break;
-      case CL_MEM_OBJECT_IMAGE2D:
-        secondDim = imageInfo->height;
-        thirdDim = 1;
-        break;
-      case CL_MEM_OBJECT_IMAGE3D:
-        secondDim = imageInfo->height;
-        thirdDim = imageInfo->depth;
-        break;
-      case CL_MEM_OBJECT_IMAGE1D_ARRAY:
-        secondDim = imageInfo->arraySize;
-        thirdDim = 1;
-        break;
-      case CL_MEM_OBJECT_IMAGE2D_ARRAY:
-        secondDim = imageInfo->height;
-        thirdDim = imageInfo->arraySize;
-        break;
-      default:
-        log_error("Test error: unhandled image type at %s:%d\n",__FILE__,__LINE__);
+        case CL_MEM_OBJECT_IMAGE1D_BUFFER:
+        case CL_MEM_OBJECT_IMAGE1D:
+            secondDim = 1;
+            thirdDim = 1;
+            break;
+        case CL_MEM_OBJECT_IMAGE2D:
+            secondDim = imageInfo->height;
+            thirdDim = 1;
+            break;
+        case CL_MEM_OBJECT_IMAGE3D:
+            secondDim = imageInfo->height;
+            thirdDim = imageInfo->depth;
+            break;
+        case CL_MEM_OBJECT_IMAGE1D_ARRAY:
+            secondDim = imageInfo->arraySize;
+            thirdDim = 1;
+            break;
+        case CL_MEM_OBJECT_IMAGE2D_ARRAY:
+            secondDim = imageInfo->height;
+            thirdDim = imageInfo->arraySize;
+            break;
+        default:
+            log_error("Test error: unhandled image type at %s:%d\n", __FILE__,
+                      __LINE__);
     };
 
     // Count the number of bytes successfully matched
@@ -485,8 +616,10 @@ int test_fill_image_generic( cl_context context, cl_command_queue queue, image_d
 
             total_matched += scanlineSize;
             sourcePtr += imageInfo->rowPitch;
-            if((imageInfo->type == CL_MEM_OBJECT_IMAGE1D_ARRAY || imageInfo->type == CL_MEM_OBJECT_IMAGE1D))
-            destPtr += mappedSlice;
+            if ((imageInfo->type == CL_MEM_OBJECT_IMAGE1D_ARRAY
+                 || imageInfo->type == CL_MEM_OBJECT_IMAGE1D
+                 || imageInfo->type == CL_MEM_OBJECT_IMAGE1D_BUFFER))
+                destPtr += mappedSlice;
             else
             destPtr += mappedRow;
         }

test_conformance/images/clFillImage/test_loops.cpp

@@ -23,6 +23,11 @@ extern int test_fill_image_set_2D( cl_device_id device, cl_context context, cl_c
 extern int test_fill_image_set_3D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType );
 extern int test_fill_image_set_1D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType );
 extern int test_fill_image_set_2D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType );
+extern int test_fill_image_set_1D_buffer(cl_device_id device,
+                                         cl_context context,
+                                         cl_command_queue queue,
+                                         cl_image_format *format,
+                                         ExplicitType outputType);
 typedef int (*test_func)(cl_device_id device, cl_context context,
                          cl_command_queue queue, cl_image_format *format,
                          ExplicitType outputType);
@@ -60,6 +65,11 @@ int test_image_type( cl_device_id device, cl_context context, cl_command_queue q
             imageType = CL_MEM_OBJECT_IMAGE3D;
             test_fn = &test_fill_image_set_3D;
             break;
+        case k1DBuffer:
+            name = "1D Image Buffer Fill";
+            imageType = CL_MEM_OBJECT_IMAGE1D_BUFFER;
+            test_fn = &test_fill_image_set_1D_buffer;
+            break;
         default: log_error("Unhandled method\n"); return -1;
     }