From cfdc23a94e9e95277190047ea7e4e6de159f5598 Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Thu, 10 Aug 2023 09:28:32 +0200 Subject: [PATCH 01/21] cl_copy_images --- test_common/harness/imageHelpers.cpp | 12 +- .../images/clCopyImage/CMakeLists.txt | 1 + test_conformance/images/clCopyImage/main.cpp | 18 + .../clCopyImage/test_copy_1D_buffer.cpp | 626 ++++++++++++++++++ .../images/clCopyImage/test_copy_generic.cpp | 51 ++ .../images/clCopyImage/test_loops.cpp | 34 + test_conformance/images/testBase.h | 3 + 7 files changed, 744 insertions(+), 1 deletion(-) create mode 100644 test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp diff --git a/test_common/harness/imageHelpers.cpp b/test_common/harness/imageHelpers.cpp index 49d5402a87..355fb5b434 100644 --- a/test_common/harness/imageHelpers.cpp +++ b/test_common/harness/imageHelpers.cpp @@ -768,7 +768,8 @@ void get_max_sizes( (*numberOfSizes) = 0; - if (image_type == CL_MEM_OBJECT_IMAGE1D) + if (image_type == CL_MEM_OBJECT_IMAGE1D + || image_type == CL_MEM_OBJECT_IMAGE1D_BUFFER) { size_t M = maximum_sizes[0]; @@ -859,6 +860,7 @@ void get_max_sizes( { switch (image_type) { + case CL_MEM_OBJECT_IMAGE1D_BUFFER: case CL_MEM_OBJECT_IMAGE1D: log_info(" size[%d] = [%zu] (%g MB image)\n", j, sizes[j][0], raw_pixel_size * sizes[j][0] * sizes[j][1] @@ -1079,6 +1081,7 @@ cl_ulong get_image_size(image_descriptor const *imageInfo) { switch (imageInfo->type) { + case CL_MEM_OBJECT_IMAGE1D_BUFFER: case CL_MEM_OBJECT_IMAGE1D: imageSize = imageInfo->rowPitch; break; case CL_MEM_OBJECT_IMAGE2D: imageSize = imageInfo->height * imageInfo->rowPitch; @@ -2316,6 +2319,7 @@ int debug_find_vector_in_image(void *imagePtr, image_descriptor *imageInfo, switch (imageInfo->type) { + case CL_MEM_OBJECT_IMAGE1D_BUFFER: case CL_MEM_OBJECT_IMAGE1D: width = (imageInfo->width >> lod) ? (imageInfo->width >> lod) : 1; height = 1; @@ -3512,6 +3516,7 @@ void copy_image_data(image_descriptor *srcImageInfo, switch (srcImageInfo->type) { + case CL_MEM_OBJECT_IMAGE1D_BUFFER: case CL_MEM_OBJECT_IMAGE1D: src_lod = sourcePos[1]; sourcePos_lod[1] = sourcePos_lod[2] = 0; @@ -3557,6 +3562,7 @@ void copy_image_data(image_descriptor *srcImageInfo, size_t dst_height_lod = 1 /*dstImageInfo->height*/; switch (dstImageInfo->type) { + case CL_MEM_OBJECT_IMAGE1D_BUFFER: case CL_MEM_OBJECT_IMAGE1D: dst_lod = destPos[1]; destPos_lod[1] = destPos_lod[2] = 0; @@ -4021,6 +4027,7 @@ cl_ulong compute_mipmapped_image_size(image_descriptor imageInfo) retSize += (cl_ulong)curr_width * curr_height * get_pixel_size(imageInfo.format); break; + case CL_MEM_OBJECT_IMAGE1D_BUFFER: case CL_MEM_OBJECT_IMAGE1D: retSize += (cl_ulong)curr_width * get_pixel_size(imageInfo.format); @@ -4042,6 +4049,7 @@ cl_ulong compute_mipmapped_image_size(image_descriptor imageInfo) case CL_MEM_OBJECT_IMAGE2D: case CL_MEM_OBJECT_IMAGE2D_ARRAY: curr_height = curr_height >> 1 ? curr_height >> 1 : 1; + case CL_MEM_OBJECT_IMAGE1D_BUFFER: case CL_MEM_OBJECT_IMAGE1D: case CL_MEM_OBJECT_IMAGE1D_ARRAY: curr_width = curr_width >> 1 ? curr_width >> 1 : 1; @@ -4079,6 +4087,7 @@ size_t compute_mip_level_offset(image_descriptor *imageInfo, size_t lod) retOffset += (size_t)width * height * get_pixel_size(imageInfo->format); break; + case CL_MEM_OBJECT_IMAGE1D_BUFFER: case CL_MEM_OBJECT_IMAGE1D: retOffset += (size_t)width * get_pixel_size(imageInfo->format); break; @@ -4091,6 +4100,7 @@ size_t compute_mip_level_offset(image_descriptor *imageInfo, size_t lod) case CL_MEM_OBJECT_IMAGE2D: case CL_MEM_OBJECT_IMAGE2D_ARRAY: height = (height >> 1) ? (height >> 1) : 1; + case CL_MEM_OBJECT_IMAGE1D_BUFFER: case CL_MEM_OBJECT_IMAGE1D_ARRAY: case CL_MEM_OBJECT_IMAGE1D: width = (width >> 1) ? (width >> 1) : 1; } diff --git a/test_conformance/images/clCopyImage/CMakeLists.txt b/test_conformance/images/clCopyImage/CMakeLists.txt index bf06dc6888..c50000ff7b 100644 --- a/test_conformance/images/clCopyImage/CMakeLists.txt +++ b/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 diff --git a/test_conformance/images/clCopyImage/main.cpp b/test_conformance/images/clCopyImage/main.cpp index c2cad01075..b0fd7454c6 100644 --- a/test_conformance/images/clCopyImage/main.cpp +++ b/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 ); @@ -90,6 +105,9 @@ test_definition test_list[] = { 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 ); diff --git a/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp b/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp new file mode 100644 index 0000000000..002a05ab40 --- /dev/null +++ b/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp @@ -0,0 +1,626 @@ +// +// 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 src_lod = 0, src_width_lod = srcImageInfo->width, src_row_pitch_lod; + size_t dst_lod = 0, dst_width_lod = srcImageInfo->width, dst_row_pitch_lod; + size_t width_lod = srcImageInfo->width; + size_t max_mip_level; + + if (gTestMipmaps) + { + max_mip_level = srcImageInfo->num_mip_levels; + // Work at a random mip level + src_lod = (size_t)random_in_range( + 0, max_mip_level ? max_mip_level - 1 : 0, d); + dst_lod = (size_t)random_in_range( + 0, max_mip_level ? max_mip_level - 1 : 0, d); + src_width_lod = (srcImageInfo->width >> src_lod) + ? (srcImageInfo->width >> src_lod) + : 1; + dst_width_lod = (srcImageInfo->width >> dst_lod) + ? (srcImageInfo->width >> dst_lod) + : 1; + width_lod = + (src_width_lod > dst_width_lod) ? dst_width_lod : src_width_lod; + src_row_pitch_lod = + src_width_lod * get_pixel_size(srcImageInfo->format); + dst_row_pitch_lod = + dst_width_lod * get_pixel_size(srcImageInfo->format); + } + + // 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; + + if (gTestMipmaps) + { + sourcePos[1] = src_lod; + destPos[1] = dst_lod; + regionSize[0] = width_lod; + } + + 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++) + { + if (gTestMipmaps) + { + // Work at a random mip level + src_lod = (size_t)random_in_range( + 0, max_mip_level ? max_mip_level - 1 : 0, d); + dst_lod = (size_t)random_in_range( + 0, max_mip_level ? max_mip_level - 1 : 0, d); + src_width_lod = (srcImageInfo->width >> src_lod) + ? (srcImageInfo->width >> src_lod) + : 1; + dst_width_lod = (srcImageInfo->width >> dst_lod) + ? (srcImageInfo->width >> dst_lod) + : 1; + width_lod = + (src_width_lod > dst_width_lod) ? dst_width_lod : src_width_lod; + sourcePos[1] = src_lod; + destPos[1] = dst_lod; + } + // 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; + + 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 (gTestMipmaps) + imageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), + seed); + + 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 (gTestMipmaps) + imageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), + seed); + + 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); + + 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); + size = size * 4; + } + else + { + 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); + if (gTestMipmaps) + log_info(" and %llu mip levels\n", + (size_t)imageInfo.num_mip_levels); + } + + 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; + + 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 (gTestMipmaps) + imageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), + seed); + + 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 (gTestMipmaps) + imageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), + seed); + + 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); + + 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); + size = size * 4; + } + else + { + 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); + if (gTestMipmaps) + log_info(" and %llu mip levels\n", + (size_t)imageInfo.num_mip_levels); + } + + 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; + + 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 (gTestMipmaps) + imageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), + seed); + + 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 (gTestMipmaps) + imageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), + seed); + + 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); + + 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); + size = size * 4; + } + else + { + 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); + if (gTestMipmaps) + log_info(" and %llu mip levels\n", + (size_t)imageInfo.num_mip_levels); + } + + 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; +} diff --git a/test_conformance/images/clCopyImage/test_copy_generic.cpp b/test_conformance/images/clCopyImage/test_copy_generic.cpp index 888ca6ec52..3f2cf2441c 100644 --- a/test_conformance/images/clCopyImage/test_copy_generic.cpp +++ b/test_conformance/images/clCopyImage/test_copy_generic.cpp @@ -20,6 +20,11 @@ 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& data, image_descriptor *imageInfo, int *error ) { cl_mem img; @@ -69,6 +74,25 @@ 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); + if (gEnablePitch) host_ptr = malloc(imageInfo->rowPitch); + { + cl_int err; + cl_mem buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, + 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 ) @@ -103,6 +127,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 +180,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 +206,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 +242,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 +257,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 +308,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,6 +440,7 @@ int test_copy_image_generic( cl_context context, cl_command_queue queue, image_d switch(dstImageInfo->type) { case CL_MEM_OBJECT_IMAGE1D: + case CL_MEM_OBJECT_IMAGE1D_BUFFER: dst_lod = destPos[1]; break; case CL_MEM_OBJECT_IMAGE1D_ARRAY: @@ -407,6 +457,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; diff --git a/test_conformance/images/clCopyImage/test_loops.cpp b/test_conformance/images/clCopyImage/test_loops.cpp index e839cfdf3e..ea60d3560e 100644 --- a/test_conformance/images/clCopyImage/test_loops.cpp +++ b/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++; diff --git a/test_conformance/images/testBase.h b/test_conformance/images/testBase.h index ad48f10d5c..8048d99449 100644 --- a/test_conformance/images/testBase.h +++ b/test_conformance/images/testBase.h @@ -53,6 +53,9 @@ enum MethodsToTest k2DTo2DArray = ( 1 << 8 ), k2DArrayTo3D = ( 1 << 9 ), k3DTo2DArray = ( 1 << 10 ), + k1DBuffer = (1 << 11), + k1DTo1DBuffer = (1 << 12), + k1DBufferTo1D = (1 << 13), }; From f6bcdb17054b0441a0d46059c9715ed15bae37b5 Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Thu, 10 Aug 2023 10:08:18 +0200 Subject: [PATCH 02/21] cl_get_info --- .../images/clGetInfo/CMakeLists.txt | 1 + test_conformance/images/clGetInfo/main.cpp | 6 + .../images/clGetInfo/test_1D_buffer.cpp | 174 ++++++++++++++++++ test_conformance/images/clGetInfo/test_2D.cpp | 27 +++ .../images/clGetInfo/test_loops.cpp | 8 + 5 files changed, 216 insertions(+) create mode 100644 test_conformance/images/clGetInfo/test_1D_buffer.cpp diff --git a/test_conformance/images/clGetInfo/CMakeLists.txt b/test_conformance/images/clGetInfo/CMakeLists.txt index f71c49cebc..c59f697627 100644 --- a/test_conformance/images/clGetInfo/CMakeLists.txt +++ b/test_conformance/images/clGetInfo/CMakeLists.txt @@ -7,6 +7,7 @@ set(${MODULE_NAME}_SOURCES test_2D.cpp test_loops.cpp test_3D.cpp + test_1D_buffer.cpp ../common.cpp ) diff --git a/test_conformance/images/clGetInfo/main.cpp b/test_conformance/images/clGetInfo/main.cpp index 80b3cbb205..4aac2c1505 100644 --- a/test_conformance/images/clGetInfo/main.cpp +++ b/test_conformance/images/clGetInfo/main.cpp @@ -54,6 +54,11 @@ int test_2Darray(cl_device_id device, cl_context context, cl_command_queue queue { return test_image_set( device, context, 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, CL_MEM_OBJECT_IMAGE1D_BUFFER); +} test_definition test_list[] = { ADD_TEST( 1D ), @@ -61,6 +66,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/clGetInfo/test_1D_buffer.cpp b/test_conformance/images/clGetInfo/test_1D_buffer.cpp new file mode 100644 index 0000000000..c3cb5bba25 --- /dev/null +++ b/test_conformance/images/clGetInfo/test_1D_buffer.cpp @@ -0,0 +1,174 @@ +// +// 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 + +extern int test_get_image_info_single(cl_context context, + image_descriptor *imageInfo, MTdata d, + cl_mem_flags flags, size_t row_pitch, + size_t slice_pitch); + + +int test_get_image_info_1D_buffer(cl_device_id device, cl_context context, + 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; + + cl_mem_flags all_host_ptr_flags[5] = { flags, CL_MEM_ALLOC_HOST_PTR | flags, + CL_MEM_COPY_HOST_PTR | flags, + CL_MEM_ALLOC_HOST_PTR + | CL_MEM_COPY_HOST_PTR | flags, + CL_MEM_USE_HOST_PTR | flags }; + + 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 1D 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; + for (unsigned int j = 0; + j < sizeof(all_host_ptr_flags) / sizeof(cl_mem_flags); j++) + { + if (gDebugTrace) + log_info(" at size %d (flags[%u] 0x%x pitch %d)\n", + (int)imageInfo.width, j, + (unsigned int)all_host_ptr_flags[j], + (int)imageInfo.rowPitch); + if (test_get_image_info_single(context, &imageInfo, seed, + all_host_ptr_flags[j], 0, 0)) + return -1; + if (all_host_ptr_flags[j] + & (CL_MEM_COPY_HOST_PTR | CL_MEM_USE_HOST_PTR)) + { // skip test when host_ptr is NULL + if (test_get_image_info_single(context, &imageInfo, seed, + all_host_ptr_flags[j], + imageInfo.rowPitch, 0)) + 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; + log_info("Testing %d x 1\n", (int)sizes[idx][0]); + for (unsigned int j = 0; + j < sizeof(all_host_ptr_flags) / sizeof(cl_mem_flags); j++) + { + if (gDebugTrace) + log_info(" at max size %d (flags[%u] 0x%x pitch %d)\n", + (int)imageInfo.width, j, + (unsigned int)all_host_ptr_flags[j], + (int)imageInfo.rowPitch); + if (test_get_image_info_single(context, &imageInfo, seed, + all_host_ptr_flags[j], 0, 0)) + return -1; + if (all_host_ptr_flags[j] + & (CL_MEM_COPY_HOST_PTR | CL_MEM_USE_HOST_PTR)) + { // skip test when host_ptr is NULL + if (test_get_image_info_single(context, &imageInfo, seed, + all_host_ptr_flags[j], + imageInfo.rowPitch, 0)) + 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; + size_t extraWidth = (int)random_log_in_range(0, 64, seed); + imageInfo.rowPitch += extraWidth; + + do + { + extraWidth++; + imageInfo.rowPitch += extraWidth; + } while ((imageInfo.rowPitch % pixelSize) != 0); + + size = (cl_ulong)imageInfo.rowPitch * 4; + } while (size > maxAllocSize || (size * 3) > memSize); + + for (unsigned int j = 0; + j < sizeof(all_host_ptr_flags) / sizeof(cl_mem_flags); j++) + { + if (gDebugTrace) + log_info( + " at size %d (flags[%u] 0x%x pitch %d) out of %d\n", + (int)imageInfo.width, j, + (unsigned int)all_host_ptr_flags[j], + (int)imageInfo.rowPitch, (int)maxWidth); + if (test_get_image_info_single(context, &imageInfo, seed, + all_host_ptr_flags[j], 0, 0)) + return -1; + if (all_host_ptr_flags[j] + & (CL_MEM_COPY_HOST_PTR | CL_MEM_USE_HOST_PTR)) + { // skip test when host_ptr is NULL + if (test_get_image_info_single(context, &imageInfo, seed, + all_host_ptr_flags[j], + imageInfo.rowPitch, 0)) + return -1; + } + } + } + } + + return 0; +} diff --git a/test_conformance/images/clGetInfo/test_2D.cpp b/test_conformance/images/clGetInfo/test_2D.cpp index 764b186d91..81fddab6d6 100644 --- a/test_conformance/images/clGetInfo/test_2D.cpp +++ b/test_conformance/images/clGetInfo/test_2D.cpp @@ -19,6 +19,7 @@ int test_get_image_info_single( cl_context context, image_descriptor *imageInfo, { int error; clMemWrapper image; + clMemWrapper buffer; cl_image_desc imageDesc; void *host_ptr = NULL; @@ -69,6 +70,24 @@ int test_get_image_info_single( cl_context context, image_descriptor *imageInfo, if ( gDebugTrace ) log_info( " - Creating 2D image array %d by %d by %d with flags=0x%lx row_pitch=%d slice_pitch=%d host_ptr=%p...\n", (int)imageInfo->width, (int)imageInfo->height, (int)imageInfo->arraySize, (unsigned long)flags, (int)row_pitch, (int)slice_pitch, host_ptr ); break; + case CL_MEM_OBJECT_IMAGE1D_BUFFER: + if (gDebugTrace) + log_info(" - Creating 1D buffer image %d with flags=0x%lx " + "row_pitch=%d slice_pitch=%d host_ptr=%p...\n", + (int)imageInfo->width, (unsigned long)flags, + (int)row_pitch, (int)slice_pitch, host_ptr); + int err; + buffer = clCreateBuffer(context, flags, imageInfo->rowPitch, + host_ptr, &err); + if (err != CL_SUCCESS) + { + log_error("ERROR: Unable to create buffer for 1D image buffer " + "of size %d (%s)", + (int)imageInfo->rowPitch, IGetErrorString(err)); + return -1; + } + imageDesc.buffer = imageInfo->buffer = buffer; + break; } image = clCreateImage(context, flags, imageInfo->format, &imageDesc, host_ptr, &error); @@ -92,6 +111,11 @@ int test_get_image_info_single( cl_context context, image_descriptor *imageInfo, case CL_MEM_OBJECT_IMAGE2D_ARRAY: log_error( "ERROR: Unable to create 2D image array of size %d x %d x %d (%s)", (int)imageInfo->width, (int)imageInfo->height, (int)imageInfo->arraySize, IGetErrorString( error ) ); break; + case CL_MEM_OBJECT_IMAGE1D_BUFFER: + log_error( + "ERROR: Unable to create 1D image buffer of size %d (%s)", + (int)imageInfo->width, IGetErrorString(error)); + break; } return -1; } @@ -148,6 +172,7 @@ int test_get_image_info_single( cl_context context, image_descriptor *imageInfo, switch (imageInfo->type) { case CL_MEM_OBJECT_IMAGE1D: + case CL_MEM_OBJECT_IMAGE1D_BUFFER: case CL_MEM_OBJECT_IMAGE1D_ARRAY: required_height = 0; break; @@ -175,6 +200,7 @@ int test_get_image_info_single( cl_context context, image_descriptor *imageInfo, case CL_MEM_OBJECT_IMAGE2D: case CL_MEM_OBJECT_IMAGE1D_ARRAY: case CL_MEM_OBJECT_IMAGE2D_ARRAY: + case CL_MEM_OBJECT_IMAGE1D_BUFFER: required_depth = 0; break; case CL_MEM_OBJECT_IMAGE3D: @@ -198,6 +224,7 @@ int test_get_image_info_single( cl_context context, image_descriptor *imageInfo, case CL_MEM_OBJECT_IMAGE1D: case CL_MEM_OBJECT_IMAGE2D: case CL_MEM_OBJECT_IMAGE3D: + case CL_MEM_OBJECT_IMAGE1D_BUFFER: required_array_size = 0; break; case CL_MEM_OBJECT_IMAGE1D_ARRAY: diff --git a/test_conformance/images/clGetInfo/test_loops.cpp b/test_conformance/images/clGetInfo/test_loops.cpp index 17f02d8b46..c3b13b37d7 100644 --- a/test_conformance/images/clGetInfo/test_loops.cpp +++ b/test_conformance/images/clGetInfo/test_loops.cpp @@ -21,6 +21,10 @@ extern int test_get_image_info_2D( cl_device_id device, cl_context context, cl_i extern int test_get_image_info_3D( cl_device_id device, cl_context context, cl_image_format *format, cl_mem_flags flags ); extern int test_get_image_info_1D_array( cl_device_id device, cl_context context, cl_image_format *format, cl_mem_flags flags ); extern int test_get_image_info_2D_array( cl_device_id device, cl_context context, cl_image_format *format, cl_mem_flags flags ); +extern int test_get_image_info_1D_buffer(cl_device_id device, + cl_context context, + cl_image_format *format, + cl_mem_flags flags); int test_image_type( cl_device_id device, cl_context context, cl_mem_object_type image_type, cl_mem_flags flags ) { @@ -66,6 +70,10 @@ int test_image_type( cl_device_id device, cl_context context, cl_mem_object_type case CL_MEM_OBJECT_IMAGE2D_ARRAY: test_return = test_get_image_info_2D_array( device, context, &formatList[ i ], flags ); break; + case CL_MEM_OBJECT_IMAGE1D_BUFFER: + test_return = test_get_image_info_1D_buffer(device, context, + &formatList[i], flags); + break; } if (test_return) { From 1992631ef9422db8f99353e361f2cc9bb209a28c Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Thu, 10 Aug 2023 10:24:00 +0200 Subject: [PATCH 03/21] cl_fill_image --- .../images/clFillImage/CMakeLists.txt | 1 + test_conformance/images/clFillImage/main.cpp | 6 + .../clFillImage/test_fill_1D_buffer.cpp | 203 ++++++++++++++++++ .../images/clFillImage/test_fill_generic.cpp | 56 ++++- .../images/clFillImage/test_loops.cpp | 10 + 5 files changed, 275 insertions(+), 1 deletion(-) create mode 100644 test_conformance/images/clFillImage/test_fill_1D_buffer.cpp diff --git a/test_conformance/images/clFillImage/CMakeLists.txt b/test_conformance/images/clFillImage/CMakeLists.txt index a4de321286..974aff291c 100644 --- a/test_conformance/images/clFillImage/CMakeLists.txt +++ b/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 diff --git a/test_conformance/images/clFillImage/main.cpp b/test_conformance/images/clFillImage/main.cpp index b19d85afdb..4d7b797936 100644 --- a/test_conformance/images/clFillImage/main.cpp +++ b/test_conformance/images/clFillImage/main.cpp @@ -52,6 +52,11 @@ 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 ), @@ -59,6 +64,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/clFillImage/test_fill_1D_buffer.cpp b/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp new file mode 100644 index 0000000000..e3079c4678 --- /dev/null +++ b/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; +} diff --git a/test_conformance/images/clFillImage/test_fill_generic.cpp b/test_conformance/images/clFillImage/test_fill_generic.cpp index 6cd6beb0ea..0f1e967760 100644 --- a/test_conformance/images/clFillImage/test_fill_generic.cpp +++ b/test_conformance/images/clFillImage/test_fill_generic.cpp @@ -21,6 +21,10 @@ 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& data, image_descriptor *imageInfo, int *error ) { @@ -70,6 +74,26 @@ 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); + if (gEnablePitch) host_ptr = malloc(imageInfo->rowPitch); + { + cl_int err; + cl_mem buffer = + clCreateBuffer(context, CL_MEM_READ_WRITE, + 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) @@ -101,6 +125,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 ); @@ -122,6 +161,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 +184,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,6 +240,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; } @@ -286,6 +333,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 +448,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,6 +488,7 @@ 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_BUFFER: case CL_MEM_OBJECT_IMAGE1D: secondDim = 1; thirdDim = 1; @@ -485,7 +537,9 @@ 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)) + 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; diff --git a/test_conformance/images/clFillImage/test_loops.cpp b/test_conformance/images/clFillImage/test_loops.cpp index 126ea0ebab..95677aec65 100644 --- a/test_conformance/images/clFillImage/test_loops.cpp +++ b/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; } From 0554854a64586e02ccb34328284970023a1d8dbb Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Thu, 10 Aug 2023 10:55:04 +0200 Subject: [PATCH 04/21] cl_read_write_image --- .../images/clReadWriteImage/CMakeLists.txt | 1 + .../images/clReadWriteImage/main.cpp | 6 + .../images/clReadWriteImage/test_loops.cpp | 9 + .../clReadWriteImage/test_read_1D_buffer.cpp | 327 ++++++++++++++++++ 4 files changed, 343 insertions(+) create mode 100644 test_conformance/images/clReadWriteImage/test_read_1D_buffer.cpp 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; +} From eb452c1fa72a1c483b46302250d29da1b270f198 Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Thu, 10 Aug 2023 11:26:40 +0200 Subject: [PATCH 05/21] kernel_image_methods --- .../kernel_image_methods/CMakeLists.txt | 1 + .../images/kernel_image_methods/main.cpp | 6 + .../kernel_image_methods/test_1D_buffer.cpp | 282 ++++++++++++++++++ .../kernel_image_methods/test_loops.cpp | 11 + 4 files changed, 300 insertions(+) create mode 100644 test_conformance/images/kernel_image_methods/test_1D_buffer.cpp diff --git a/test_conformance/images/kernel_image_methods/CMakeLists.txt b/test_conformance/images/kernel_image_methods/CMakeLists.txt index b06e7d5c85..607cbdee09 100644 --- a/test_conformance/images/kernel_image_methods/CMakeLists.txt +++ b/test_conformance/images/kernel_image_methods/CMakeLists.txt @@ -3,6 +3,7 @@ set(MODULE_NAME KERNEL_IMAGE_METHODS) set(${MODULE_NAME}_SOURCES main.cpp test_1D.cpp + test_1D_buffer.cpp test_1D_array.cpp test_2D.cpp test_2D_array.cpp diff --git a/test_conformance/images/kernel_image_methods/main.cpp b/test_conformance/images/kernel_image_methods/main.cpp index 50653ef55f..2de104f71d 100644 --- a/test_conformance/images/kernel_image_methods/main.cpp +++ b/test_conformance/images/kernel_image_methods/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/kernel_image_methods/test_1D_buffer.cpp b/test_conformance/images/kernel_image_methods/test_1D_buffer.cpp new file mode 100644 index 0000000000..1885cbd63e --- /dev/null +++ b/test_conformance/images/kernel_image_methods/test_1D_buffer.cpp @@ -0,0 +1,282 @@ +// +// 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 + + +struct image_kernel_data +{ + cl_int width; + cl_int channelType; + cl_int channelOrder; + cl_int expectedChannelType; + cl_int expectedChannelOrder; +}; + +static const char *methodTest1DImageKernelPattern = + "typedef struct {\n" + " int width;\n" + " int channelType;\n" + " int channelOrder;\n" + " int expectedChannelType;\n" + " int expectedChannelOrder;\n" + " } image_kernel_data;\n" + "__kernel void sample_kernel( %s image1d_buffer_t input, __global " + "image_kernel_data *outData )\n" + "{\n" + " outData->width = get_image_width( input );\n" + " outData->channelType = get_image_channel_data_type( input );\n" + " outData->channelOrder = get_image_channel_order( input );\n" + "\n" + " outData->expectedChannelType = %s;\n" + " outData->expectedChannelOrder = %s;\n" + "}"; + +static int test_get_1Dimage_buffer_info_single(cl_context context, + cl_command_queue queue, + image_descriptor *imageInfo, + MTdata d, cl_mem_flags flags) +{ + int error = 0; + + clProgramWrapper program; + clKernelWrapper kernel; + clMemWrapper image, outDataBuffer, buffer; + char programSrc[10240]; + + image_kernel_data outKernelData; + + // Generate some data to test against + BufferOwningPtr imageValues; + generate_random_image_data(imageInfo, imageValues, d); + + // Construct testing source + if (gDebugTrace) + log_info(" - Creating 1D image %d ...\n", (int)imageInfo->width); + + buffer = clCreateBuffer( + context, flags, imageInfo->width * get_pixel_size(imageInfo->format), + 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)); + } + + image = create_image_1d(context, flags, imageInfo->format, imageInfo->width, + imageInfo->rowPitch, NULL, buffer, &error); + if (image == NULL) + { + log_error("ERROR: Unable to create 1D image of size %d (%s)", + (int)imageInfo->width, IGetErrorString(error)); + return -1; + } + + char channelTypeConstantString[256] = { 0 }; + char channelOrderConstantString[256] = { 0 }; + + const char *channelTypeName = + GetChannelTypeName(imageInfo->format->image_channel_data_type); + const char *channelOrderName = + GetChannelOrderName(imageInfo->format->image_channel_order); + const char *image_access_qualifier = + (flags == CL_MEM_READ_ONLY) ? "read_only" : "write_only"; + + if (channelTypeName && strlen(channelTypeName)) + sprintf(channelTypeConstantString, "CLK_%s", + &channelTypeName[3]); // replace CL_* with CLK_* + + if (channelOrderName && strlen(channelOrderName)) + sprintf(channelOrderConstantString, "CLK_%s", + &channelOrderName[3]); // replace CL_* with CLK_* + + // Create a program to run against + sprintf(programSrc, methodTest1DImageKernelPattern, image_access_qualifier, + channelTypeConstantString, channelOrderConstantString); + + // log_info("-----------------------------------\n%s\n", programSrc); + error = clFinish(queue); + if (error) print_error(error, "clFinish failed.\n"); + const char *ptr = programSrc; + error = create_single_kernel_helper(context, &program, &kernel, 1, &ptr, + "sample_kernel"); + test_error(error, "Unable to create kernel to test against"); + + // Create an output buffer + outDataBuffer = clCreateBuffer(context, CL_MEM_READ_WRITE, + sizeof(outKernelData), NULL, &error); + test_error(error, "Unable to create output buffer"); + + // Set up arguments and run + error = clSetKernelArg(kernel, 0, sizeof(image), &image); + test_error(error, "Unable to set kernel argument"); + error = clSetKernelArg(kernel, 1, sizeof(outDataBuffer), &outDataBuffer); + test_error(error, "Unable to set kernel argument"); + + size_t threads[1] = { 1 }, localThreads[1] = { 1 }; + + error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads, + localThreads, 0, NULL, NULL); + test_error(error, "Unable to run kernel"); + + error = clEnqueueReadBuffer(queue, outDataBuffer, CL_TRUE, 0, + sizeof(outKernelData), &outKernelData, 0, NULL, + NULL); + test_error(error, "Unable to read data buffer"); + + + // Verify the results now + if (outKernelData.width != (cl_int)imageInfo->width) + { + log_error( + "ERROR: Returned width did not validate (expected %d, got %d)\n", + (int)imageInfo->width, (int)outKernelData.width); + error = -1; + } + if (outKernelData.channelType != (cl_int)outKernelData.expectedChannelType) + { + log_error( + "ERROR: Returned channel type did not validate (expected %s (%d), " + "got %d)\n", + GetChannelTypeName(imageInfo->format->image_channel_data_type), + (int)outKernelData.expectedChannelType, + (int)outKernelData.channelType); + error = -1; + } + if (outKernelData.channelOrder + != (cl_int)outKernelData.expectedChannelOrder) + { + log_error("ERROR: Returned channel order did not validate (expected %s " + "(%d), got %d)\n", + GetChannelOrderName(imageInfo->format->image_channel_order), + (int)outKernelData.expectedChannelOrder, + (int)outKernelData.channelOrder); + error = -1; + } + + if (clFinish(queue) != CL_SUCCESS) + { + log_error("ERROR: CL Finished failed in %s \n", __FUNCTION__); + error = -1; + } + + return error; +} + +int test_get_image_info_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 1D 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 (gDebugTrace) log_info(" at size %d\n", (int)imageInfo.width); + + int ret = test_get_1Dimage_buffer_info_single( + 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; + + log_info("Testing %d\n", (int)sizes[idx][0]); + if (gDebugTrace) + log_info(" at max size %d\n", (int)sizes[idx][0]); + if (test_get_1Dimage_buffer_info_single(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); + + imageInfo.rowPitch = imageInfo.width * pixelSize; + size_t extraWidth = (int)random_log_in_range(0, 64, seed); + imageInfo.rowPitch += extraWidth; + + do + { + extraWidth++; + imageInfo.rowPitch += extraWidth; + } while ((imageInfo.rowPitch % pixelSize) != 0); + + size = (cl_ulong)imageInfo.rowPitch * (cl_ulong)imageInfo.height + * 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_get_1Dimage_buffer_info_single( + context, queue, &imageInfo, seed, flags); + if (ret) return -1; + } + } + + return 0; +} diff --git a/test_conformance/images/kernel_image_methods/test_loops.cpp b/test_conformance/images/kernel_image_methods/test_loops.cpp index 1d892a9b0b..31fd7a3f38 100644 --- a/test_conformance/images/kernel_image_methods/test_loops.cpp +++ b/test_conformance/images/kernel_image_methods/test_loops.cpp @@ -34,6 +34,11 @@ extern int test_get_image_info_2D_array(cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, cl_mem_flags flags); +extern int test_get_image_info_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 ) { @@ -84,6 +89,10 @@ int test_image_type( cl_device_id device, cl_context context, cl_command_queue q test_return = test_get_image_info_2D_array( device, context, queue, &formatList[i], flags); break; + case CL_MEM_OBJECT_IMAGE1D_BUFFER: + test_return = test_get_image_info_1D_buffer( + device, context, queue, &formatList[i], flags); + break; } if (test_return) { @@ -109,6 +118,8 @@ int test_image_set( cl_device_id device, cl_context context, cl_command_queue qu switch (imageType) { case CL_MEM_OBJECT_IMAGE1D: test_missing_feature(version_check, "image_1D"); + case CL_MEM_OBJECT_IMAGE1D_BUFFER: + test_missing_feature(version_check, "image_1D_buffer"); case CL_MEM_OBJECT_IMAGE1D_ARRAY: test_missing_feature(version_check, "image_1D_array"); case CL_MEM_OBJECT_IMAGE2D_ARRAY: From 1db645f5afbe4fcd054bdd6ee32984fa07f23b01 Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Mon, 16 Oct 2023 09:04:38 +0200 Subject: [PATCH 06/21] IMAGE1D_BUFFER cannot be created with (USE_|ALLOC_|COPY_)_HOST_PTR --- .../images/clGetInfo/test_1D_buffer.cpp | 88 +++++-------------- 1 file changed, 21 insertions(+), 67 deletions(-) diff --git a/test_conformance/images/clGetInfo/test_1D_buffer.cpp b/test_conformance/images/clGetInfo/test_1D_buffer.cpp index c3cb5bba25..7b0c2d1c6d 100644 --- a/test_conformance/images/clGetInfo/test_1D_buffer.cpp +++ b/test_conformance/images/clGetInfo/test_1D_buffer.cpp @@ -31,12 +31,6 @@ int test_get_image_info_1D_buffer(cl_device_id device, cl_context context, RandomSeed seed(gRandomSeed); size_t pixelSize; - cl_mem_flags all_host_ptr_flags[5] = { flags, CL_MEM_ALLOC_HOST_PTR | flags, - CL_MEM_COPY_HOST_PTR | flags, - CL_MEM_ALLOC_HOST_PTR - | CL_MEM_COPY_HOST_PTR | flags, - CL_MEM_USE_HOST_PTR | flags }; - memset(&imageInfo, 0x0, sizeof(image_descriptor)); imageInfo.type = CL_MEM_OBJECT_IMAGE1D_BUFFER; imageInfo.format = format; @@ -61,26 +55,13 @@ int test_get_image_info_1D_buffer(cl_device_id device, cl_context context, for (imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++) { imageInfo.rowPitch = imageInfo.width * pixelSize; - for (unsigned int j = 0; - j < sizeof(all_host_ptr_flags) / sizeof(cl_mem_flags); j++) - { - if (gDebugTrace) - log_info(" at size %d (flags[%u] 0x%x pitch %d)\n", - (int)imageInfo.width, j, - (unsigned int)all_host_ptr_flags[j], - (int)imageInfo.rowPitch); - if (test_get_image_info_single(context, &imageInfo, seed, - all_host_ptr_flags[j], 0, 0)) - return -1; - if (all_host_ptr_flags[j] - & (CL_MEM_COPY_HOST_PTR | CL_MEM_USE_HOST_PTR)) - { // skip test when host_ptr is NULL - if (test_get_image_info_single(context, &imageInfo, seed, - all_host_ptr_flags[j], - imageInfo.rowPitch, 0)) - return -1; - } - } + if (gDebugTrace) + log_info(" at size %d (flags 0x%x pitch %d)\n", + (int)imageInfo.width, (unsigned int)flags, + (int)imageInfo.rowPitch); + if (test_get_image_info_single(context, &imageInfo, seed, flags, 0, + 0)) + return -1; } } else if (gTestMaxImages) @@ -98,26 +79,13 @@ int test_get_image_info_1D_buffer(cl_device_id device, cl_context context, imageInfo.width = sizes[idx][0]; imageInfo.rowPitch = imageInfo.width * pixelSize; log_info("Testing %d x 1\n", (int)sizes[idx][0]); - for (unsigned int j = 0; - j < sizeof(all_host_ptr_flags) / sizeof(cl_mem_flags); j++) - { - if (gDebugTrace) - log_info(" at max size %d (flags[%u] 0x%x pitch %d)\n", - (int)imageInfo.width, j, - (unsigned int)all_host_ptr_flags[j], - (int)imageInfo.rowPitch); - if (test_get_image_info_single(context, &imageInfo, seed, - all_host_ptr_flags[j], 0, 0)) - return -1; - if (all_host_ptr_flags[j] - & (CL_MEM_COPY_HOST_PTR | CL_MEM_USE_HOST_PTR)) - { // skip test when host_ptr is NULL - if (test_get_image_info_single(context, &imageInfo, seed, - all_host_ptr_flags[j], - imageInfo.rowPitch, 0)) - return -1; - } - } + if (gDebugTrace) + log_info(" at max size %d (flags 0x%x pitch %d)\n", + (int)imageInfo.width, (unsigned int)flags, + (int)imageInfo.rowPitch); + if (test_get_image_info_single(context, &imageInfo, seed, flags, 0, + 0)) + return -1; } } else @@ -146,27 +114,13 @@ int test_get_image_info_1D_buffer(cl_device_id device, cl_context context, size = (cl_ulong)imageInfo.rowPitch * 4; } while (size > maxAllocSize || (size * 3) > memSize); - for (unsigned int j = 0; - j < sizeof(all_host_ptr_flags) / sizeof(cl_mem_flags); j++) - { - if (gDebugTrace) - log_info( - " at size %d (flags[%u] 0x%x pitch %d) out of %d\n", - (int)imageInfo.width, j, - (unsigned int)all_host_ptr_flags[j], - (int)imageInfo.rowPitch, (int)maxWidth); - if (test_get_image_info_single(context, &imageInfo, seed, - all_host_ptr_flags[j], 0, 0)) - return -1; - if (all_host_ptr_flags[j] - & (CL_MEM_COPY_HOST_PTR | CL_MEM_USE_HOST_PTR)) - { // skip test when host_ptr is NULL - if (test_get_image_info_single(context, &imageInfo, seed, - all_host_ptr_flags[j], - imageInfo.rowPitch, 0)) - return -1; - } - } + if (gDebugTrace) + log_info(" at size %d (flags 0x%x pitch %d) out of %d\n", + (int)imageInfo.width, (unsigned int)flags, + (int)imageInfo.rowPitch, (int)maxWidth); + if (test_get_image_info_single(context, &imageInfo, seed, flags, 0, + 0)) + return -1; } } From 598bb722eff20e941fbcad6c8d405f1ff186120f Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Fri, 10 Nov 2023 11:33:57 +0100 Subject: [PATCH 07/21] do not allow mipmap with 1D buffer --- .../clCopyImage/test_copy_1D_buffer.cpp | 209 ++++---------- .../clReadWriteImage/test_read_1D_buffer.cpp | 257 +++++++----------- 2 files changed, 144 insertions(+), 322 deletions(-) diff --git a/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp b/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp index 002a05ab40..4947b786ea 100644 --- a/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp +++ b/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp @@ -33,28 +33,6 @@ int test_copy_image_size_1D_buffer(cl_context context, cl_command_queue queue, size_t width_lod = srcImageInfo->width; size_t max_mip_level; - if (gTestMipmaps) - { - max_mip_level = srcImageInfo->num_mip_levels; - // Work at a random mip level - src_lod = (size_t)random_in_range( - 0, max_mip_level ? max_mip_level - 1 : 0, d); - dst_lod = (size_t)random_in_range( - 0, max_mip_level ? max_mip_level - 1 : 0, d); - src_width_lod = (srcImageInfo->width >> src_lod) - ? (srcImageInfo->width >> src_lod) - : 1; - dst_width_lod = (srcImageInfo->width >> dst_lod) - ? (srcImageInfo->width >> dst_lod) - : 1; - width_lod = - (src_width_lod > dst_width_lod) ? dst_width_lod : src_width_lod; - src_row_pitch_lod = - src_width_lod * get_pixel_size(srcImageInfo->format); - dst_row_pitch_lod = - dst_width_lod * get_pixel_size(srcImageInfo->format); - } - // First, try just a full covering region sourcePos[0] = sourcePos[1] = sourcePos[2] = 0; destPos[0] = destPos[1] = destPos[2] = 0; @@ -62,13 +40,6 @@ int test_copy_image_size_1D_buffer(cl_context context, cl_command_queue queue, regionSize[1] = 1; regionSize[2] = 1; - if (gTestMipmaps) - { - sourcePos[1] = src_lod; - destPos[1] = dst_lod; - regionSize[0] = width_lod; - } - retCode = test_copy_image_generic(context, queue, srcImageInfo, dstImageInfo, sourcePos, destPos, regionSize, d); @@ -80,24 +51,6 @@ int test_copy_image_size_1D_buffer(cl_context context, cl_command_queue queue, // Now try a sampling of different random regions for (int i = 0; i < 8; i++) { - if (gTestMipmaps) - { - // Work at a random mip level - src_lod = (size_t)random_in_range( - 0, max_mip_level ? max_mip_level - 1 : 0, d); - dst_lod = (size_t)random_in_range( - 0, max_mip_level ? max_mip_level - 1 : 0, d); - src_width_lod = (srcImageInfo->width >> src_lod) - ? (srcImageInfo->width >> src_lod) - : 1; - dst_width_lod = (srcImageInfo->width >> dst_lod) - ? (srcImageInfo->width >> dst_lod) - : 1; - width_lod = - (src_width_lod > dst_width_lod) ? dst_width_lod : src_width_lod; - sourcePos[1] = src_lod; - destPos[1] = dst_lod; - } // Pick a random size regionSize[0] = (width_lod > 8) ? (size_t)random_in_range(8, (int)width_lod - 1, d) @@ -135,6 +88,13 @@ int test_copy_image_set_1D_buffer(cl_device_id device, cl_context context, 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; @@ -162,11 +122,6 @@ int test_copy_image_set_1D_buffer(cl_device_id device, cl_context context, size_t rowPadding = gEnablePitch ? 48 : 0; imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint)random_log_in_range( - 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), - seed); - if (gEnablePitch) { do @@ -200,11 +155,6 @@ int test_copy_image_set_1D_buffer(cl_device_id device, cl_context context, imageInfo.width = sizes[idx][0]; imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint)random_log_in_range( - 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), - seed); - if (gEnablePitch) { do @@ -237,33 +187,19 @@ int test_copy_image_set_1D_buffer(cl_device_id device, cl_context context, 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); - size = size * 4; - } - else - { - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; + imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - if (gEnablePitch) + if (gEnablePitch) + { + do { - do - { - rowPadding++; - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } - - size = (size_t)imageInfo.rowPitch * 4; + 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) @@ -271,9 +207,6 @@ int test_copy_image_set_1D_buffer(cl_device_id device, cl_context context, log_info(" at size %d (row pitch %d) out of %d\n", (int)imageInfo.width, (int)imageInfo.rowPitch, (int)maxWidth); - if (gTestMipmaps) - log_info(" and %llu mip levels\n", - (size_t)imageInfo.num_mip_levels); } int ret = test_copy_image_size_1D_buffer(context, queue, &imageInfo, @@ -295,6 +228,13 @@ int test_copy_image_set_1D_1D_buffer(cl_device_id device, cl_context context, 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; @@ -322,11 +262,6 @@ int test_copy_image_set_1D_1D_buffer(cl_device_id device, cl_context context, size_t rowPadding = gEnablePitch ? 48 : 0; imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint)random_log_in_range( - 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), - seed); - if (gEnablePitch) { do @@ -363,11 +298,6 @@ int test_copy_image_set_1D_1D_buffer(cl_device_id device, cl_context context, imageInfo.width = sizes[idx][0]; imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint)random_log_in_range( - 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), - seed); - if (gEnablePitch) { do @@ -404,33 +334,19 @@ int test_copy_image_set_1D_1D_buffer(cl_device_id device, cl_context context, 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); - size = size * 4; - } - else - { - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; + imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - if (gEnablePitch) + if (gEnablePitch) + { + do { - do - { - rowPadding++; - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } - - size = (size_t)imageInfo.rowPitch * 4; + 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) @@ -438,9 +354,6 @@ int test_copy_image_set_1D_1D_buffer(cl_device_id device, cl_context context, log_info(" at size %d (row pitch %d) out of %d\n", (int)imageInfo.width, (int)imageInfo.rowPitch, (int)maxWidth); - if (gTestMipmaps) - log_info(" and %llu mip levels\n", - (size_t)imageInfo.num_mip_levels); } image_descriptor srcImageInfo = imageInfo; @@ -465,6 +378,13 @@ int test_copy_image_set_1D_buffer_1D(cl_device_id device, cl_context context, 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; @@ -492,11 +412,6 @@ int test_copy_image_set_1D_buffer_1D(cl_device_id device, cl_context context, size_t rowPadding = gEnablePitch ? 48 : 0; imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint)random_log_in_range( - 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), - seed); - if (gEnablePitch) { do @@ -533,11 +448,6 @@ int test_copy_image_set_1D_buffer_1D(cl_device_id device, cl_context context, imageInfo.width = sizes[idx][0]; imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint)random_log_in_range( - 2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), - seed); - if (gEnablePitch) { do @@ -574,33 +484,19 @@ int test_copy_image_set_1D_buffer_1D(cl_device_id device, cl_context context, 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); - size = size * 4; - } - else - { - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; + imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - if (gEnablePitch) + if (gEnablePitch) + { + do { - do - { - rowPadding++; - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } - - size = (size_t)imageInfo.rowPitch * 4; + 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) @@ -608,9 +504,6 @@ int test_copy_image_set_1D_buffer_1D(cl_device_id device, cl_context context, log_info(" at size %d (row pitch %d) out of %d\n", (int)imageInfo.width, (int)imageInfo.rowPitch, (int)maxWidth); - if (gTestMipmaps) - log_info(" and %llu mip levels\n", - (size_t)imageInfo.num_mip_levels); } image_descriptor dstImageInfo = imageInfo; diff --git a/test_conformance/images/clReadWriteImage/test_read_1D_buffer.cpp b/test_conformance/images/clReadWriteImage/test_read_1D_buffer.cpp index 578092aec5..1304161e18 100644 --- a/test_conformance/images/clReadWriteImage/test_read_1D_buffer.cpp +++ b/test_conformance/images/clReadWriteImage/test_read_1D_buffer.cpp @@ -31,8 +31,7 @@ int test_read_image_1D_buffer(cl_context context, cl_command_queue queue, if (gDebugTrace) { - log_info(" - Creating %s 1D image %d...\n", - gTestMipmaps ? "mipmapped" : "", (int)imageInfo->width); + log_info(" - Creating 1D image %d...\n", (int)imageInfo->width); log_info(" with %llu mip levels\n", (unsigned long long)imageInfo->num_mip_levels); } @@ -45,161 +44,107 @@ int test_read_image_1D_buffer(cl_context context, cl_command_queue queue, (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) { - 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; - } + log_error("ERROR: Unable to create 1D image buffer of size %d (%s)", + (int)imageInfo->width, IGetErrorString(error)); + return -1; } 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; - } + size_t 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++) + error = clEnqueueWriteImage(queue, image, CL_FALSE, origin, region, + (gEnablePitch ? imageInfo->rowPitch : 0), 0, + (char *)imageValues + imgValMipLevelOffset, 0, + NULL, NULL); + if (error != CL_SUCCESS) { - 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; - } + log_error("ERROR: Unable to write to 1D image of size %d \n", + (int)imageInfo->width); + 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"); - } + // 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); + // Note: we read back without any pitch, to verify pitch actually WORKED + size_t scanlineSize = imageInfo->width * get_pixel_size(imageInfo->format); + size_t imageSize = scanlineSize; + memset(resultValues, 0xff, imageSize); - if (gDebugTrace) log_info(" - Reading results...\n"); + 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"); + 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; + // Verify scanline by scanline, since the pitches are different + char *sourcePtr = (char *)imageValues + imgValMipLevelOffset; + char *destPtr = resultValues; - if (memcmp(sourcePtr, destPtr, scanlineSize) != 0) + if (memcmp(sourcePtr, destPtr, scanlineSize) != 0) + { + log_error("ERROR: Scanline did not verify for image size %d pitch " + "%d (extra %d bytes)\n", + (int)imageInfo->width, (int)imageInfo->rowPitch, + (int)imageInfo->rowPitch + - (int)imageInfo->width + * (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)(imageInfo->width - 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) { - 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); - } + 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(" Unable to determine offset\n"); - } - return -1; + log_error( + " Calculated offset is %d but unable to verify\n", + returnedOffset); + } + else + { + log_error(" Unable to determine offset\n"); } - imgValMipLevelOffset += width_lod * get_pixel_size(imageInfo->format); + return -1; } + imgValMipLevelOffset += + imageInfo->width * get_pixel_size(imageInfo->format); return 0; } @@ -213,6 +158,13 @@ int test_read_image_set_1D_buffer(cl_device_id device, cl_context context, 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.type = CL_MEM_OBJECT_IMAGE1D_BUFFER; imageInfo.format = format; imageInfo.height = imageInfo.depth = imageInfo.slicePitch = 0; @@ -238,11 +190,6 @@ int test_read_image_set_1D_buffer(cl_device_id device, cl_context context, { 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, @@ -265,11 +212,6 @@ int test_read_image_set_1D_buffer(cl_device_id device, cl_context context, 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, @@ -290,27 +232,14 @@ int test_read_image_set_1D_buffer(cl_device_id device, cl_context context, imageInfo.width = (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); - if (gTestMipmaps) + imageInfo.rowPitch = imageInfo.width * pixelSize; + if (gEnablePitch) { - 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; + 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) From d471d472d6324c4c44a3467537ba590adad264a1 Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Fri, 10 Nov 2023 11:41:19 +0100 Subject: [PATCH 08/21] adjust M to be within maximum_sizes and max_pixels --- test_common/harness/imageHelpers.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/test_common/harness/imageHelpers.cpp b/test_common/harness/imageHelpers.cpp index 355fb5b434..d23e842c10 100644 --- a/test_common/harness/imageHelpers.cpp +++ b/test_common/harness/imageHelpers.cpp @@ -773,6 +773,9 @@ void get_max_sizes( { size_t M = maximum_sizes[0]; + size_t A = max_pixels; + + M = static_cast(fmin(A / M, M)); // Store the size sizes[(*numberOfSizes)][0] = M; From 7e51654f6d2a71822b6af16c1775c9940ede8cfd Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Fri, 10 Nov 2023 16:44:00 +0100 Subject: [PATCH 09/21] remove unused variables --- test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp b/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp index 4947b786ea..f8f14bd442 100644 --- a/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp +++ b/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp @@ -28,10 +28,7 @@ int test_copy_image_size_1D_buffer(cl_context context, cl_command_queue queue, { size_t sourcePos[3], destPos[3], regionSize[3]; int ret = 0, retCode; - size_t src_lod = 0, src_width_lod = srcImageInfo->width, src_row_pitch_lod; - size_t dst_lod = 0, dst_width_lod = srcImageInfo->width, dst_row_pitch_lod; size_t width_lod = srcImageInfo->width; - size_t max_mip_level; // First, try just a full covering region sourcePos[0] = sourcePos[1] = sourcePos[2] = 0; From 4ca814c24a52067ea07e4eecbdcd93b7fcf4e5ad Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Sun, 7 Jan 2024 09:58:07 +0100 Subject: [PATCH 10/21] make sure M will never be 0 --- test_common/harness/imageHelpers.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test_common/harness/imageHelpers.cpp b/test_common/harness/imageHelpers.cpp index d23e842c10..c17ac74fac 100644 --- a/test_common/harness/imageHelpers.cpp +++ b/test_common/harness/imageHelpers.cpp @@ -775,7 +775,7 @@ void get_max_sizes( size_t M = maximum_sizes[0]; size_t A = max_pixels; - M = static_cast(fmin(A / M, M)); + M = static_cast(fmax(1, fmin(A / M, M))); // Store the size sizes[(*numberOfSizes)][0] = M; From 16e334348e7481b13ff35002cbc28f29c59579f4 Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Sun, 7 Jan 2024 09:58:22 +0100 Subject: [PATCH 11/21] fix region[0] after refactoring removing mipmap --- .../images/clReadWriteImage/test_read_1D_buffer.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test_conformance/images/clReadWriteImage/test_read_1D_buffer.cpp b/test_conformance/images/clReadWriteImage/test_read_1D_buffer.cpp index 1304161e18..01dd80dc39 100644 --- a/test_conformance/images/clReadWriteImage/test_read_1D_buffer.cpp +++ b/test_conformance/images/clReadWriteImage/test_read_1D_buffer.cpp @@ -56,7 +56,7 @@ int test_read_image_1D_buffer(cl_context context, cl_command_queue queue, if (gDebugTrace) log_info(" - Writing image...\n"); size_t origin[3] = { 0, 0, 0 }; - size_t region[3] = { 0, 1, 1 }; + size_t region[3] = { imageInfo->width, 1, 1 }; size_t fullImageSize = imageInfo->rowPitch; BufferOwningPtr resultValues(malloc(fullImageSize)); From 5c62489556f574f0087fb9f60fbf166563889c91 Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Tue, 13 Feb 2024 14:52:15 +0100 Subject: [PATCH 12/21] fix formatting --- test_conformance/images/clCopyImage/main.cpp | 19 ++----- .../clCopyImage/test_copy_1D_buffer.cpp | 14 ++--- .../images/clCopyImage/test_copy_generic.cpp | 4 +- test_conformance/images/clFillImage/main.cpp | 8 +-- .../clFillImage/test_fill_1D_buffer.cpp | 7 +-- .../images/clFillImage/test_fill_generic.cpp | 53 +++++++++---------- test_conformance/images/clGetInfo/main.cpp | 8 +-- test_conformance/images/clGetInfo/test_2D.cpp | 8 +-- .../images/clGetInfo/test_loops.cpp | 6 +-- .../images/clReadWriteImage/main.cpp | 8 +-- .../images/kernel_image_methods/main.cpp | 8 +-- .../kernel_image_methods/test_loops.cpp | 2 +- test_conformance/images/testBase.h | 22 ++++---- 13 files changed, 69 insertions(+), 98 deletions(-) diff --git a/test_conformance/images/clCopyImage/main.cpp b/test_conformance/images/clCopyImage/main.cpp index b0fd7454c6..5526c39805 100644 --- a/test_conformance/images/clCopyImage/main.cpp +++ b/test_conformance/images/clCopyImage/main.cpp @@ -94,20 +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( 1Dbuffer), - ADD_TEST( 1DTo1Dbuffer ), - ADD_TEST( 1DbufferTo1D ), + 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 ); diff --git a/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp b/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp index f8f14bd442..e741854b35 100644 --- a/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp +++ b/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp @@ -54,12 +54,14 @@ int test_copy_image_size_1D_buffer(cl_context context, cl_command_queue queue, : 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; + 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! diff --git a/test_conformance/images/clCopyImage/test_copy_generic.cpp b/test_conformance/images/clCopyImage/test_copy_generic.cpp index 3f2cf2441c..4103ee8315 100644 --- a/test_conformance/images/clCopyImage/test_copy_generic.cpp +++ b/test_conformance/images/clCopyImage/test_copy_generic.cpp @@ -440,9 +440,7 @@ int test_copy_image_generic( cl_context context, cl_command_queue queue, image_d switch(dstImageInfo->type) { case CL_MEM_OBJECT_IMAGE1D: - case CL_MEM_OBJECT_IMAGE1D_BUFFER: - 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]; diff --git a/test_conformance/images/clFillImage/main.cpp b/test_conformance/images/clFillImage/main.cpp index 4d7b797936..62e62c63c6 100644 --- a/test_conformance/images/clFillImage/main.cpp +++ b/test_conformance/images/clFillImage/main.cpp @@ -59,12 +59,8 @@ int test_1Dbuffer(cl_device_id device, cl_context context, } test_definition test_list[] = { - ADD_TEST( 1D ), - ADD_TEST( 2D ), - ADD_TEST( 3D ), - ADD_TEST( 1Darray ), - ADD_TEST( 2Darray ), - ADD_TEST( 1Dbuffer ), + 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 ); diff --git a/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp b/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp index e3079c4678..c6e29ddbdd 100644 --- a/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp +++ b/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp @@ -51,9 +51,10 @@ int test_fill_image_size_1D_buffer(cl_context context, cl_command_queue queue, : 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; + 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, diff --git a/test_conformance/images/clFillImage/test_fill_generic.cpp b/test_conformance/images/clFillImage/test_fill_generic.cpp index 0f1e967760..c8c8b9d705 100644 --- a/test_conformance/images/clFillImage/test_fill_generic.cpp +++ b/test_conformance/images/clFillImage/test_fill_generic.cpp @@ -240,9 +240,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; + case CL_MEM_OBJECT_IMAGE1D_BUFFER: dstPitch2D = mappedSlice; break; } for ( size_t z = 0; z < depth; z++ ) @@ -488,29 +486,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_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__); + 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 @@ -540,7 +539,7 @@ int test_fill_image_generic( cl_context context, cl_command_queue queue, image_d if ((imageInfo->type == CL_MEM_OBJECT_IMAGE1D_ARRAY || imageInfo->type == CL_MEM_OBJECT_IMAGE1D || imageInfo->type == CL_MEM_OBJECT_IMAGE1D_BUFFER)) - destPtr += mappedSlice; + destPtr += mappedSlice; else destPtr += mappedRow; } diff --git a/test_conformance/images/clGetInfo/main.cpp b/test_conformance/images/clGetInfo/main.cpp index 4aac2c1505..933eb00fcd 100644 --- a/test_conformance/images/clGetInfo/main.cpp +++ b/test_conformance/images/clGetInfo/main.cpp @@ -61,12 +61,8 @@ int test_1Dbuffer(cl_device_id device, cl_context context, } test_definition test_list[] = { - ADD_TEST( 1D ), - ADD_TEST( 2D ), - ADD_TEST( 3D ), - ADD_TEST( 1Darray ), - ADD_TEST( 2Darray ), - ADD_TEST( 1Dbuffer ), + 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 ); diff --git a/test_conformance/images/clGetInfo/test_2D.cpp b/test_conformance/images/clGetInfo/test_2D.cpp index 81fddab6d6..12c1202678 100644 --- a/test_conformance/images/clGetInfo/test_2D.cpp +++ b/test_conformance/images/clGetInfo/test_2D.cpp @@ -200,9 +200,7 @@ int test_get_image_info_single( cl_context context, image_descriptor *imageInfo, case CL_MEM_OBJECT_IMAGE2D: case CL_MEM_OBJECT_IMAGE1D_ARRAY: case CL_MEM_OBJECT_IMAGE2D_ARRAY: - case CL_MEM_OBJECT_IMAGE1D_BUFFER: - required_depth = 0; - break; + case CL_MEM_OBJECT_IMAGE1D_BUFFER: required_depth = 0; break; case CL_MEM_OBJECT_IMAGE3D: required_depth = imageInfo->depth; break; @@ -224,9 +222,7 @@ int test_get_image_info_single( cl_context context, image_descriptor *imageInfo, case CL_MEM_OBJECT_IMAGE1D: case CL_MEM_OBJECT_IMAGE2D: case CL_MEM_OBJECT_IMAGE3D: - case CL_MEM_OBJECT_IMAGE1D_BUFFER: - required_array_size = 0; - break; + case CL_MEM_OBJECT_IMAGE1D_BUFFER: required_array_size = 0; break; case CL_MEM_OBJECT_IMAGE1D_ARRAY: case CL_MEM_OBJECT_IMAGE2D_ARRAY: required_array_size = imageInfo->arraySize; diff --git a/test_conformance/images/clGetInfo/test_loops.cpp b/test_conformance/images/clGetInfo/test_loops.cpp index c3b13b37d7..d5c6260616 100644 --- a/test_conformance/images/clGetInfo/test_loops.cpp +++ b/test_conformance/images/clGetInfo/test_loops.cpp @@ -71,9 +71,9 @@ int test_image_type( cl_device_id device, cl_context context, cl_mem_object_type test_return = test_get_image_info_2D_array( device, context, &formatList[ i ], flags ); break; case CL_MEM_OBJECT_IMAGE1D_BUFFER: - test_return = test_get_image_info_1D_buffer(device, context, - &formatList[i], flags); - break; + test_return = test_get_image_info_1D_buffer( + device, context, &formatList[i], flags); + break; } if (test_return) { diff --git a/test_conformance/images/clReadWriteImage/main.cpp b/test_conformance/images/clReadWriteImage/main.cpp index fa94a2eb4f..642b8a5729 100644 --- a/test_conformance/images/clReadWriteImage/main.cpp +++ b/test_conformance/images/clReadWriteImage/main.cpp @@ -58,12 +58,8 @@ int test_1Dbuffer(cl_device_id device, cl_context context, } test_definition test_list[] = { - ADD_TEST( 1D ), - ADD_TEST( 2D ), - ADD_TEST( 3D ), - ADD_TEST( 1Darray ), - ADD_TEST( 2Darray ), - ADD_TEST( 1Dbuffer ), + 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 ); diff --git a/test_conformance/images/kernel_image_methods/main.cpp b/test_conformance/images/kernel_image_methods/main.cpp index 2de104f71d..a0a6fc57cd 100644 --- a/test_conformance/images/kernel_image_methods/main.cpp +++ b/test_conformance/images/kernel_image_methods/main.cpp @@ -58,12 +58,8 @@ int test_1Dbuffer(cl_device_id device, cl_context context, } test_definition test_list[] = { - ADD_TEST( 1D ), - ADD_TEST( 2D ), - ADD_TEST( 3D ), - ADD_TEST( 1Darray ), - ADD_TEST( 2Darray ), - ADD_TEST( 1Dbuffer ), + 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 ); diff --git a/test_conformance/images/kernel_image_methods/test_loops.cpp b/test_conformance/images/kernel_image_methods/test_loops.cpp index 31fd7a3f38..c04b1338af 100644 --- a/test_conformance/images/kernel_image_methods/test_loops.cpp +++ b/test_conformance/images/kernel_image_methods/test_loops.cpp @@ -119,7 +119,7 @@ int test_image_set( cl_device_id device, cl_context context, cl_command_queue qu case CL_MEM_OBJECT_IMAGE1D: test_missing_feature(version_check, "image_1D"); case CL_MEM_OBJECT_IMAGE1D_BUFFER: - test_missing_feature(version_check, "image_1D_buffer"); + test_missing_feature(version_check, "image_1D_buffer"); case CL_MEM_OBJECT_IMAGE1D_ARRAY: test_missing_feature(version_check, "image_1D_array"); case CL_MEM_OBJECT_IMAGE2D_ARRAY: diff --git a/test_conformance/images/testBase.h b/test_conformance/images/testBase.h index 8048d99449..2e5eea9679 100644 --- a/test_conformance/images/testBase.h +++ b/test_conformance/images/testBase.h @@ -42,17 +42,17 @@ enum TypesToTest // For the clCopyImage test enum MethodsToTest { - k1D = ( 1 << 0 ), - k2D = ( 1 << 1 ), - k1DArray = ( 1 << 2 ), - k2DArray = ( 1 << 3 ), - k3D = ( 1 << 4 ), - k2DTo3D = ( 1 << 5 ), - k3DTo2D = ( 1 << 6 ), - k2DArrayTo2D = ( 1 << 7 ), - k2DTo2DArray = ( 1 << 8 ), - k2DArrayTo3D = ( 1 << 9 ), - k3DTo2DArray = ( 1 << 10 ), + k1D = (1 << 0), + k2D = (1 << 1), + k1DArray = (1 << 2), + k2DArray = (1 << 3), + k3D = (1 << 4), + k2DTo3D = (1 << 5), + k3DTo2D = (1 << 6), + k2DArrayTo2D = (1 << 7), + k2DTo2DArray = (1 << 8), + k2DArrayTo3D = (1 << 9), + k3DTo2DArray = (1 << 10), k1DBuffer = (1 << 11), k1DTo1DBuffer = (1 << 12), k1DBufferTo1D = (1 << 13), From b3cca5c34324bf48a77447824dda72e1ba972be1 Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Tue, 13 Feb 2024 14:58:33 +0100 Subject: [PATCH 13/21] format with clang-format-11 --- .../images/clCopyImage/test_copy_1D_buffer.cpp | 14 ++++++-------- .../images/clFillImage/test_fill_1D_buffer.cpp | 7 +++---- 2 files changed, 9 insertions(+), 12 deletions(-) diff --git a/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp b/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp index e741854b35..f8f14bd442 100644 --- a/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp +++ b/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp @@ -54,14 +54,12 @@ int test_copy_image_size_1D_buffer(cl_context context, cl_command_queue queue, : 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; + 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! diff --git a/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp b/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp index c6e29ddbdd..e3079c4678 100644 --- a/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp +++ b/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp @@ -51,10 +51,9 @@ int test_fill_image_size_1D_buffer(cl_context context, cl_command_queue queue, : 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; + 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, From 9c6c16609b079f89bd045acae559bd0006c72748 Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Tue, 27 Feb 2024 19:02:23 +0100 Subject: [PATCH 14/21] fix image1d_buffer creation with gEnablePitch --- .../images/clFillImage/test_fill_generic.cpp | 28 +++++++++++++++---- 1 file changed, 22 insertions(+), 6 deletions(-) diff --git a/test_conformance/images/clFillImage/test_fill_generic.cpp b/test_conformance/images/clFillImage/test_fill_generic.cpp index c8c8b9d705..e138b52f74 100644 --- a/test_conformance/images/clFillImage/test_fill_generic.cpp +++ b/test_conformance/images/clFillImage/test_fill_generic.cpp @@ -78,12 +78,16 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr if (gDebugTrace) log_info(" - Creating 1D buffer image %d ...\n", (int)imageInfo->width); - if (gEnablePitch) host_ptr = malloc(imageInfo->rowPitch); { cl_int err; - cl_mem buffer = - clCreateBuffer(context, CL_MEM_READ_WRITE, - imageInfo->rowPitch, host_ptr, &err); + cl_mem_flags buffer_flags = CL_MEM_READ_WRITE; + if (gEnablePitch) + { + host_ptr = malloc(imageInfo->rowPitch); + 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 " @@ -103,10 +107,22 @@ 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) { From f101b60f14fb63c711df372cdded4f05ef7855ad Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Wed, 28 Feb 2024 11:32:06 +0100 Subject: [PATCH 15/21] add missing case in switch --- test_conformance/images/clCopyImage/test_copy_generic.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test_conformance/images/clCopyImage/test_copy_generic.cpp b/test_conformance/images/clCopyImage/test_copy_generic.cpp index 4103ee8315..c377c1e921 100644 --- a/test_conformance/images/clCopyImage/test_copy_generic.cpp +++ b/test_conformance/images/clCopyImage/test_copy_generic.cpp @@ -14,6 +14,7 @@ // limitations under the License. // #include "../testBase.h" +#include static void CL_CALLBACK free_pitch_buffer( cl_mem image, void *buf ) { @@ -591,6 +592,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; } From 8d5fee92cfd9fc1dcfbe06ae0999c8202c00d82f Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Tue, 5 Mar 2024 09:36:15 +0100 Subject: [PATCH 16/21] use align_malloc when CL version is at least 2.0 --- .../images/clCopyImage/test_copy_generic.cpp | 55 ++++++++++++++++++- .../images/clFillImage/test_fill_generic.cpp | 42 +++++++++++++- 2 files changed, 93 insertions(+), 4 deletions(-) diff --git a/test_conformance/images/clCopyImage/test_copy_generic.cpp b/test_conformance/images/clCopyImage/test_copy_generic.cpp index c377c1e921..54a156fed9 100644 --- a/test_conformance/images/clCopyImage/test_copy_generic.cpp +++ b/test_conformance/images/clCopyImage/test_copy_generic.cpp @@ -79,10 +79,56 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr if (gDebugTrace) log_info(" - Creating 1D buffer image %d ...\n", (int)imageInfo->width); - if (gEnablePitch) host_ptr = malloc(imageInfo->rowPitch); { cl_int err; - cl_mem buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, + 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) { @@ -106,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); diff --git a/test_conformance/images/clFillImage/test_fill_generic.cpp b/test_conformance/images/clFillImage/test_fill_generic.cpp index e138b52f74..f558256811 100644 --- a/test_conformance/images/clFillImage/test_fill_generic.cpp +++ b/test_conformance/images/clFillImage/test_fill_generic.cpp @@ -83,7 +83,47 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr cl_mem_flags buffer_flags = CL_MEM_READ_WRITE; if (gEnablePitch) { - host_ptr = malloc(imageInfo->rowPitch); + 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( From 84e5fc2ac190a0142c94d11ef5f205573cc7dc3a Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Tue, 12 Mar 2024 08:00:14 +0100 Subject: [PATCH 17/21] use CL_DEVICE_NUMERIC_VERSION and align_free --- .../images/clFillImage/test_fill_generic.cpp | 66 ++++++++++++------- 1 file changed, 42 insertions(+), 24 deletions(-) diff --git a/test_conformance/images/clFillImage/test_fill_generic.cpp b/test_conformance/images/clFillImage/test_fill_generic.cpp index f558256811..6ddaab442a 100644 --- a/test_conformance/images/clFillImage/test_fill_generic.cpp +++ b/test_conformance/images/clFillImage/test_fill_generic.cpp @@ -42,6 +42,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_VERSION from " + "device"); + return NULL; + } + } + switch (imageInfo->type) { case CL_MEM_OBJECT_IMAGE1D: @@ -83,27 +103,7 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr 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') + if (CL_VERSION_MAJOR(version) == 1) { host_ptr = malloc(imageInfo->rowPitch); } @@ -171,14 +171,32 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr int callbackError = clSetMemObjectDestructorCallback( img, free_pitch_buffer, host_ptr ); if ( CL_SUCCESS != callbackError ) { - free( host_ptr ); - log_error( "ERROR: Unable to attach destructor callback to pitched 3D image. Err: %d\n", callbackError ); + if (CL_VERSION_MAJOR(version) == 1) + { + free(host_ptr); + } + else + { + align_free(host_ptr); + } + log_error("ERROR: Unable to attach destructor callback to " + "pitched 3D image. Err: %d\n", + callbackError); clReleaseMemObject( img ); return NULL; } } else - free(host_ptr); + { + if (CL_VERSION_MAJOR(version) == 1) + { + free(host_ptr); + } + else + { + align_free(host_ptr); + } + } } if (imageDesc.buffer != NULL) From 9a49a34650113a02acd082361f553e0574b0958e Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Wed, 27 Mar 2024 09:36:38 +0100 Subject: [PATCH 18/21] fix free of pitch buffer --- .../images/clFillImage/test_fill_generic.cpp | 48 ++++++++++--------- 1 file changed, 25 insertions(+), 23 deletions(-) diff --git a/test_conformance/images/clFillImage/test_fill_generic.cpp b/test_conformance/images/clFillImage/test_fill_generic.cpp index 6ddaab442a..d8ec968b5d 100644 --- a/test_conformance/images/clFillImage/test_fill_generic.cpp +++ b/test_conformance/images/clFillImage/test_fill_generic.cpp @@ -17,9 +17,19 @@ 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 { + void *buf; + bool is_aligned; +}; +static void CL_CALLBACK free_pitch_buffer( cl_mem image, void *data ) { - free( buf ); + 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) { @@ -56,7 +66,7 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr sizeof(version), &version, nullptr); if (err != CL_SUCCESS) { - log_error("Error: Could not get CL_DEVICE_VERSION from " + log_error("Error: Could not get CL_DEVICE_NUMERIC_VERSION from " "device"); return NULL; } @@ -166,36 +176,28 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr 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) { - if (CL_VERSION_MAJOR(version) == 1) - { - free(host_ptr); - } - else - { - align_free(host_ptr); - } + free_pitch_buffer(img, data); log_error("ERROR: Unable to attach destructor callback to " "pitched 3D image. Err: %d\n", callbackError); - clReleaseMemObject( img ); + clReleaseMemObject(img); return NULL; } } else { - if (CL_VERSION_MAJOR(version) == 1) - { - free(host_ptr); - } - else - { - align_free(host_ptr); - } + free_pitch_buffer(img, data); } } From cd53e2859fddae29ee850e6d57fa114106da175a Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Wed, 27 Mar 2024 10:13:35 +0100 Subject: [PATCH 19/21] fix formatting --- .../images/clFillImage/test_fill_generic.cpp | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/test_conformance/images/clFillImage/test_fill_generic.cpp b/test_conformance/images/clFillImage/test_fill_generic.cpp index d8ec968b5d..6179f73a54 100644 --- a/test_conformance/images/clFillImage/test_fill_generic.cpp +++ b/test_conformance/images/clFillImage/test_fill_generic.cpp @@ -17,16 +17,20 @@ extern void read_image_pixel_float( void *imageData, image_descriptor *imageInfo, int x, int y, int z, float *outData ); -struct pitch_buffer_data { +struct pitch_buffer_data +{ 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) { + if (d->is_aligned) + { align_free(d->buf); - } else { + } + else + { free(d->buf); } free(d); From 26255dd89235e01734eb61fedfad3020380acb6c Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Wed, 27 Mar 2024 11:26:34 +0100 Subject: [PATCH 20/21] fix formatting --- test_conformance/images/clFillImage/test_fill_generic.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test_conformance/images/clFillImage/test_fill_generic.cpp b/test_conformance/images/clFillImage/test_fill_generic.cpp index 6179f73a54..2607a1a9e8 100644 --- a/test_conformance/images/clFillImage/test_fill_generic.cpp +++ b/test_conformance/images/clFillImage/test_fill_generic.cpp @@ -22,7 +22,7 @@ struct pitch_buffer_data void *buf; bool is_aligned; }; -static void CL_CALLBACK free_pitch_buffer( cl_mem image, void *data ) +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) From 71eca12de88f4dbbe1293b8d5f360fb9ed83db6b Mon Sep 17 00:00:00 2001 From: Romaric Jodin Date: Sat, 30 Mar 2024 09:38:04 +0100 Subject: [PATCH 21/21] fix data->is_aligned --- test_conformance/images/clFillImage/test_fill_generic.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test_conformance/images/clFillImage/test_fill_generic.cpp b/test_conformance/images/clFillImage/test_fill_generic.cpp index 2607a1a9e8..ca9a1bfa3a 100644 --- a/test_conformance/images/clFillImage/test_fill_generic.cpp +++ b/test_conformance/images/clFillImage/test_fill_generic.cpp @@ -183,8 +183,8 @@ cl_mem create_image( cl_context context, cl_command_queue queue, BufferOwningPtr 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; + data->is_aligned = (CL_VERSION_MAJOR(version) != 1) + && (imageInfo->type == CL_MEM_OBJECT_IMAGE1D_BUFFER); if (*error == CL_SUCCESS) { int callbackError =