diff --git a/test_conformance/images/clReadWriteImage/CMakeLists.txt b/test_conformance/images/clReadWriteImage/CMakeLists.txt index bc1600ff81..9e0bbbc9c9 100644 --- a/test_conformance/images/clReadWriteImage/CMakeLists.txt +++ b/test_conformance/images/clReadWriteImage/CMakeLists.txt @@ -3,6 +3,7 @@ set(MODULE_NAME CL_READ_WRITE_IMAGES) set(${MODULE_NAME}_SOURCES main.cpp test_read_1D.cpp + test_read_1D_buffer.cpp test_read_1D_array.cpp test_read_2D.cpp test_read_2D_array.cpp diff --git a/test_conformance/images/clReadWriteImage/main.cpp b/test_conformance/images/clReadWriteImage/main.cpp index 18c7e2397a..fa94a2eb4f 100644 --- a/test_conformance/images/clReadWriteImage/main.cpp +++ b/test_conformance/images/clReadWriteImage/main.cpp @@ -51,6 +51,11 @@ int test_2Darray(cl_device_id device, cl_context context, cl_command_queue queue { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE2D_ARRAY ); } +int test_1Dbuffer(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements) +{ + return test_image_set(device, context, queue, CL_MEM_OBJECT_IMAGE1D_BUFFER); +} test_definition test_list[] = { ADD_TEST( 1D ), @@ -58,6 +63,7 @@ test_definition test_list[] = { ADD_TEST( 3D ), ADD_TEST( 1Darray ), ADD_TEST( 2Darray ), + ADD_TEST( 1Dbuffer ), }; const int test_num = ARRAY_SIZE( test_list ); diff --git a/test_conformance/images/clReadWriteImage/test_loops.cpp b/test_conformance/images/clReadWriteImage/test_loops.cpp index 782e4b37d5..175a49b8f1 100644 --- a/test_conformance/images/clReadWriteImage/test_loops.cpp +++ b/test_conformance/images/clReadWriteImage/test_loops.cpp @@ -33,6 +33,11 @@ extern int test_read_image_set_2D_array(cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, cl_mem_flags flags); +extern int test_read_image_set_1D_buffer(cl_device_id device, + cl_context context, + cl_command_queue queue, + cl_image_format *format, + cl_mem_flags flags); int test_image_type( cl_device_id device, cl_context context, cl_command_queue queue, cl_mem_object_type imageType, cl_mem_flags flags ) { @@ -97,6 +102,10 @@ int test_image_type( cl_device_id device, cl_context context, cl_command_queue q test_return = test_read_image_set_2D_array( device, context, queue, &formatList[i], flags); break; + case CL_MEM_OBJECT_IMAGE1D_BUFFER: + test_return = test_read_image_set_1D_buffer( + device, context, queue, &formatList[i], flags); + break; } if (test_return) diff --git a/test_conformance/images/clReadWriteImage/test_read_1D_buffer.cpp b/test_conformance/images/clReadWriteImage/test_read_1D_buffer.cpp new file mode 100644 index 0000000000..578092aec5 --- /dev/null +++ b/test_conformance/images/clReadWriteImage/test_read_1D_buffer.cpp @@ -0,0 +1,327 @@ +// +// 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" +#include + +int test_read_image_1D_buffer(cl_context context, cl_command_queue queue, + image_descriptor *imageInfo, MTdata d, + cl_mem_flags flags) +{ + int error; + + clMemWrapper image; + clMemWrapper buffer; + + // Generate some data to test against + BufferOwningPtr imageValues; + generate_random_image_data(imageInfo, imageValues, d); + + if (gDebugTrace) + { + log_info(" - Creating %s 1D image %d...\n", + gTestMipmaps ? "mipmapped" : "", (int)imageInfo->width); + log_info(" with %llu mip levels\n", + (unsigned long long)imageInfo->num_mip_levels); + } + + buffer = clCreateBuffer(context, flags, imageInfo->rowPitch, NULL, &error); + if (error != CL_SUCCESS) + { + log_error("ERROR: Unable to create buffer for 1D image buffer of size " + "%d (%s)", + (int)imageInfo->rowPitch, IGetErrorString(error)); + } + + // Construct testing sources + if (!gTestMipmaps) + { + image = create_image_1d(context, flags, imageInfo->format, + imageInfo->width, 0, NULL, buffer, &error); + if (image == NULL) + { + log_error("ERROR: Unable to create 1D image buffer of size %d (%s)", + (int)imageInfo->width, IGetErrorString(error)); + return -1; + } + } + else + { + cl_image_desc image_desc = { 0 }; + image_desc.image_type = CL_MEM_OBJECT_IMAGE1D_BUFFER; + image_desc.image_width = imageInfo->width; + image_desc.num_mip_levels = imageInfo->num_mip_levels; + image_desc.buffer = buffer; + + image = clCreateImage(context, flags, imageInfo->format, &image_desc, + NULL, &error); + if (error != CL_SUCCESS) + { + log_error( + "ERROR: Unable to create %d level mipmapped 1D image buffer of " + "size %d x %d (pitch %d ) (%s)", + (int)imageInfo->num_mip_levels, (int)imageInfo->width, + (int)imageInfo->height, (int)imageInfo->rowPitch, + IGetErrorString(error)); + return error; + } + } + + if (gDebugTrace) log_info(" - Writing image...\n"); + + size_t origin[3] = { 0, 0, 0 }; + size_t region[3] = { 0, 1, 1 }; + size_t fullImageSize; + if (gTestMipmaps) + { + fullImageSize = (size_t)compute_mipmapped_image_size(*imageInfo); + } + else + { + fullImageSize = imageInfo->rowPitch; + } + + BufferOwningPtr resultValues(malloc(fullImageSize)); + size_t imgValMipLevelOffset = 0; + + for (size_t lod = 0; (gTestMipmaps && lod < imageInfo->num_mip_levels) + || (!gTestMipmaps && lod < 1); + lod++) + { + origin[1] = lod; + size_t width_lod, row_pitch_lod; + + width_lod = (imageInfo->width >> lod) ? (imageInfo->width >> lod) : 1; + row_pitch_lod = gTestMipmaps + ? (width_lod * get_pixel_size(imageInfo->format)) + : imageInfo->rowPitch; + + region[0] = width_lod; + + if (gDebugTrace) + if (gTestMipmaps) + { + log_info(" - Working at mipLevel :%llu\n", + (unsigned long long)lod); + } + error = clEnqueueWriteImage(queue, image, CL_FALSE, origin, region, + (gEnablePitch ? row_pitch_lod : 0), 0, + (char *)imageValues + imgValMipLevelOffset, + 0, NULL, NULL); + if (error != CL_SUCCESS) + { + log_error("ERROR: Unable to write to 1D image of size %d \n", + (int)width_lod); + return -1; + } + + // To verify, we just read the results right back and see whether they + // match the input + if (gDebugTrace) + { + log_info(" - Initing result array...\n"); + } + + // Note: we read back without any pitch, to verify pitch actually WORKED + size_t scanlineSize = width_lod * get_pixel_size(imageInfo->format); + size_t imageSize = scanlineSize; + memset(resultValues, 0xff, imageSize); + + if (gDebugTrace) log_info(" - Reading results...\n"); + + error = clEnqueueReadImage(queue, image, CL_TRUE, origin, region, 0, 0, + resultValues, 0, NULL, NULL); + test_error(error, "Unable to read image values"); + + // Verify scanline by scanline, since the pitches are different + char *sourcePtr = (char *)imageValues + imgValMipLevelOffset; + char *destPtr = resultValues; + + if (memcmp(sourcePtr, destPtr, scanlineSize) != 0) + { + log_error("ERROR: Scanline did not verify for image size %d pitch " + "%d (extra %d bytes)\n", + (int)width_lod, (int)row_pitch_lod, + (int)row_pitch_lod + - (int)width_lod + * (int)get_pixel_size(imageInfo->format)); + + log_error("First few values: \n"); + log_error(" Input: "); + uint32_t *s = (uint32_t *)sourcePtr; + uint32_t *d = (uint32_t *)destPtr; + for (int q = 0; q < 12; q++) log_error("%08x ", s[q]); + log_error("\nOutput: "); + for (int q = 0; q < 12; q++) log_error("%08x ", d[q]); + log_error("\n"); + + int outX; + int offset = + (int)get_pixel_size(imageInfo->format) * (int)(width_lod - 16); + if (offset < 0) offset = 0; + int foundCount = debug_find_vector_in_image( + (char *)imageValues + imgValMipLevelOffset, imageInfo, + destPtr + offset, get_pixel_size(imageInfo->format), &outX, + NULL, NULL); + if (foundCount > 0) + { + int returnedOffset = + (offset / (int)get_pixel_size(imageInfo->format)) - outX; + + if (memcmp(sourcePtr + + returnedOffset + * get_pixel_size(imageInfo->format), + destPtr, get_pixel_size(imageInfo->format) * 8) + == 0) + log_error(" Values appear to be offsetted by %d\n", + returnedOffset); + else + log_error( + " Calculated offset is %d but unable to verify\n", + returnedOffset); + } + else + { + log_error(" Unable to determine offset\n"); + } + return -1; + } + imgValMipLevelOffset += width_lod * get_pixel_size(imageInfo->format); + } + return 0; +} + +int test_read_image_set_1D_buffer(cl_device_id device, cl_context context, + cl_command_queue queue, + cl_image_format *format, cl_mem_flags flags) +{ + size_t maxWidth; + cl_ulong maxAllocSize, memSize; + image_descriptor imageInfo = { 0 }; + RandomSeed seed(gRandomSeed); + size_t pixelSize; + + imageInfo.type = CL_MEM_OBJECT_IMAGE1D_BUFFER; + imageInfo.format = format; + imageInfo.height = imageInfo.depth = imageInfo.slicePitch = 0; + 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; + + if (gTestMipmaps) + imageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), + seed); + + if (gDebugTrace) log_info(" at size %d\n", (int)imageInfo.width); + + int ret = test_read_image_1D_buffer(context, queue, &imageInfo, + seed, flags); + 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; + + if (gTestMipmaps) + imageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), + seed); + + log_info("Testing %d\n", (int)imageInfo.width); + if (gDebugTrace) log_info(" at max size %d\n", (int)maxWidth); + if (test_read_image_1D_buffer(context, queue, &imageInfo, seed, + flags)) + 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); + + if (gTestMipmaps) + { + imageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), + seed); + imageInfo.rowPitch = + imageInfo.width * get_pixel_size(imageInfo.format); + size = compute_mipmapped_image_size(imageInfo); + } + else + { + imageInfo.rowPitch = imageInfo.width * pixelSize; + if (gEnablePitch) + { + size_t extraWidth = + (int)random_log_in_range(0, 64, seed); + imageInfo.rowPitch += extraWidth * pixelSize; + } + + 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_read_image_1D_buffer(context, queue, &imageInfo, + seed, flags); + if (ret) return -1; + } + } + + return 0; +}