images/kernel_read_write/test_loops.cpp

//
// Copyright (c) 2017 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 "../common.h"

extern cl_filter_mode gFilterModeToUse;
extern cl_addressing_mode gAddressModeToUse;
extern int gNormalizedModeToUse;
extern int gTypesToTest;
extern int gtestTypesToRun;

extern int test_read_image_set_1D(cl_device_id device, cl_context context,
                                  cl_command_queue queue,
                                  const cl_image_format *format,
                                  image_sampler_data *imageSampler,
                                  bool floatCoords, ExplicitType outputType);
extern int test_read_image_set_2D(cl_device_id device, cl_context context,
                                  cl_command_queue queue,
                                  const cl_image_format *format,
                                  image_sampler_data *imageSampler,
                                  bool floatCoords, ExplicitType outputType);
extern int test_read_image_set_3D(cl_device_id device, cl_context context,
                                  cl_command_queue queue,
                                  const cl_image_format *format,
                                  image_sampler_data *imageSampler,
                                  bool floatCoords, ExplicitType outputType);
extern int test_read_image_set_1D_array(cl_device_id device, cl_context context,
                                        cl_command_queue queue,
                                        const cl_image_format *format,
                                        image_sampler_data *imageSampler,
                                        bool floatCoords,
                                        ExplicitType outputType);
extern int test_read_image_set_2D_array(cl_device_id device, cl_context context,
                                        cl_command_queue queue,
                                        const cl_image_format *format,
                                        image_sampler_data *imageSampler,
                                        bool floatCoords,
                                        ExplicitType outputType);

int test_read_image_type(cl_device_id device, cl_context context,
                         cl_command_queue queue, const cl_image_format *format,
                         bool floatCoords, image_sampler_data *imageSampler,
                         ExplicitType outputType, cl_mem_object_type imageType)
{
    int ret = 0;
    cl_addressing_mode *addressModes = NULL;

    // The sampler-less read image functions behave exactly as the corresponding
    // read image functions described in section 6.13.14.2 that take integer
    // coordinates and a sampler with filter mode set to CLK_FILTER_NEAREST,
    // normalized coordinates set to CLK_NORMALIZED_COORDS_FALSE and addressing
    // mode to CLK_ADDRESS_NONE
    cl_addressing_mode addressModes_rw[] = { CL_ADDRESS_NONE,
                                             (cl_addressing_mode)-1 };
    cl_addressing_mode addressModes_ro[] = {
        /* CL_ADDRESS_CLAMP_NONE,*/ CL_ADDRESS_CLAMP_TO_EDGE, CL_ADDRESS_CLAMP,
        CL_ADDRESS_REPEAT, CL_ADDRESS_MIRRORED_REPEAT, (cl_addressing_mode)-1
    };

    if (gtestTypesToRun & kReadWriteTests)
    {
        addressModes = addressModes_rw;
    }
    else
    {
        addressModes = addressModes_ro;
    }

#if defined(__APPLE__)
    // According to the OpenCL specification, we do not guarantee the precision
    // of operations for linear filtering on the GPU.  We do not test linear
    // filtering for the CL_RGB CL_UNORM_INT_101010 image format; however, we
    // test it internally for a set of other image formats.
    if ((gDeviceType & CL_DEVICE_TYPE_GPU)
        && (imageSampler->filter_mode == CL_FILTER_LINEAR)
        && (format->image_channel_order == CL_RGB)
        && (format->image_channel_data_type == CL_UNORM_INT_101010))
    {
        log_info("--- Skipping CL_RGB CL_UNORM_INT_101010 format with "
                 "CL_FILTER_LINEAR on GPU.\n");
        return 0;
    }
#endif

    for (int adMode = 0; addressModes[adMode] != (cl_addressing_mode)-1;
         adMode++)
    {
        imageSampler->addressing_mode = addressModes[adMode];

        if ((addressModes[adMode] == CL_ADDRESS_REPEAT
             || addressModes[adMode] == CL_ADDRESS_MIRRORED_REPEAT)
            && !(imageSampler->normalized_coords))
            continue; // Repeat doesn't make sense for non-normalized coords

        // Use this run if we were told to only run a certain filter mode
        if (gAddressModeToUse != (cl_addressing_mode)-1
            && imageSampler->addressing_mode != gAddressModeToUse)
            continue;

        /*
         Remove redundant check to see if workaround still necessary
         // Check added in because this case was leaking through causing a crash
         on CPU if( ! imageSampler->normalized_coords &&
         imageSampler->addressing_mode == CL_ADDRESS_REPEAT ) continue; //repeat
         mode requires normalized coordinates
         */
        print_read_header(format, imageSampler, false);

        gTestCount++;

        int retCode = 0;
        switch (imageType)
        {
            case CL_MEM_OBJECT_IMAGE1D:
                retCode = test_read_image_set_1D(device, context, queue, format,
                                                 imageSampler, floatCoords,
                                                 outputType);
                break;
            case CL_MEM_OBJECT_IMAGE1D_ARRAY:
                retCode = test_read_image_set_1D_array(device, context, queue,
                                                       format, imageSampler,
                                                       floatCoords, outputType);
                break;
            case CL_MEM_OBJECT_IMAGE2D:
                retCode = test_read_image_set_2D(device, context, queue, format,
                                                 imageSampler, floatCoords,
                                                 outputType);
                break;
            case CL_MEM_OBJECT_IMAGE2D_ARRAY:
                retCode = test_read_image_set_2D_array(device, context, queue,
                                                       format, imageSampler,
                                                       floatCoords, outputType);
                break;
            case CL_MEM_OBJECT_IMAGE3D:
                retCode = test_read_image_set_3D(device, context, queue, format,
                                                 imageSampler, floatCoords,
                                                 outputType);
                break;
        }
        if (retCode != 0)
        {
            gFailCount++;
            log_error("FAILED: ");
            print_read_header(format, imageSampler, true);
            log_info("\n");
        }
        ret |= retCode;
    }

    return ret;
}

int test_read_image_formats(cl_device_id device, cl_context context,
                            cl_command_queue queue,
                            const std::vector<cl_image_format> &formatList,
                            const std::vector<bool> &filterFlags,
                            image_sampler_data *imageSampler,
                            ExplicitType outputType,
                            cl_mem_object_type imageType)
{
    int ret = 0;
    bool flipFlop[2] = { false, true };
    int normalizedIdx, floatCoordIdx;


    // Use this run if we were told to only run a certain filter mode
    if (gFilterModeToUse != (cl_filter_mode)-1
        && imageSampler->filter_mode != gFilterModeToUse)
        return 0;

    // Test normalized/non-normalized
    for (normalizedIdx = 0; normalizedIdx < 2; normalizedIdx++)
    {
        imageSampler->normalized_coords = flipFlop[normalizedIdx];
        if (gNormalizedModeToUse != 7
            && gNormalizedModeToUse != (int)imageSampler->normalized_coords)
            continue;

        for (floatCoordIdx = 0; floatCoordIdx < 2; floatCoordIdx++)
        {
            // Checks added in because this case was leaking through causing a
            // crash on CPU
            if (!flipFlop[floatCoordIdx])
                if (imageSampler->filter_mode != CL_FILTER_NEAREST
                    || // integer coords can only be used with nearest
                    flipFlop[normalizedIdx]) // Normalized integer coords makes
                                             // no sense (they'd all be zero)
                    continue;

            if (flipFlop[floatCoordIdx] && (gtestTypesToRun & kReadWriteTests))
                // sampler-less read in read_write tests run only integer coord
                continue;


            log_info("read_image (%s coords, %s results) "
                     "*****************************\n",
                     flipFlop[floatCoordIdx] ? (imageSampler->normalized_coords
                                                    ? "normalized float"
                                                    : "unnormalized float")
                                             : "integer",
                     get_explicit_type_name(outputType));

            for (unsigned int i = 0; i < formatList.size(); i++)
            {
                if (filterFlags[i]) continue;

                const cl_image_format &imageFormat = formatList[i];

                ret |=
                    test_read_image_type(device, context, queue, &imageFormat,
                                         flipFlop[floatCoordIdx], imageSampler,
                                         outputType, imageType);
            }
        }
    }
    return ret;
}


int test_image_set(cl_device_id device, cl_context context,
                   cl_command_queue queue, test_format_set_fn formatTestFn,
                   cl_mem_object_type imageType)
{
    int ret = 0;
    static int printedFormatList = -1;


    if ((imageType == CL_MEM_OBJECT_IMAGE3D)
        && (formatTestFn == test_write_image_formats))
    {
        if (0 == is_extension_available(device, "cl_khr_3d_image_writes"))
        {
            log_info("-----------------------------------------------------\n");
            log_info(
                "This device does not support "
                "cl_khr_3d_image_writes.\nSkipping 3d image write test. \n");
            log_info(
                "-----------------------------------------------------\n\n");
            return 0;
        }
    }

    if (gTestMipmaps)
    {
        if (0 == is_extension_available(device, "cl_khr_mipmap_image"))
        {
            log_info("-----------------------------------------------------\n");
            log_info("This device does not support "
                     "cl_khr_mipmap_image.\nSkipping mipmapped image test. \n");
            log_info(
                "-----------------------------------------------------\n\n");
            return 0;
        }
        if ((0 == is_extension_available(device, "cl_khr_mipmap_image_writes"))
            && (formatTestFn == test_write_image_formats))
        {
            log_info("-----------------------------------------------------\n");
            log_info("This device does not support "
                     "cl_khr_mipmap_image_writes.\nSkipping mipmapped image "
                     "write test. \n");
            log_info(
                "-----------------------------------------------------\n\n");
            return 0;
        }
    }

    int version_check = (get_device_cl_version(device) < Version(1, 2));
    if (version_check != 0)
    {
        switch (imageType)
        {
            case CL_MEM_OBJECT_IMAGE1D:
                test_missing_feature(version_check, "image_1D");
            case CL_MEM_OBJECT_IMAGE1D_ARRAY:
                test_missing_feature(version_check, "image_1D_array");
            case CL_MEM_OBJECT_IMAGE2D_ARRAY:
                test_missing_feature(version_check, "image_2D_array");
        }
    }

    // This flag is only for querying the list of supported formats
    // The flag for creating image will be set explicitly in test functions
    cl_mem_flags flags;
    const char *flagNames;
    if (formatTestFn == test_read_image_formats)
    {
        if (gtestTypesToRun & kReadTests)
        {
            flags = CL_MEM_READ_ONLY;
            flagNames = "read";
        }
        else
        {
            flags = CL_MEM_KERNEL_READ_AND_WRITE;
            flagNames = "read_write";
        }
    }
    else
    {
        if (gtestTypesToRun & kWriteTests)
        {
            flags = CL_MEM_WRITE_ONLY;
            flagNames = "write";
        }
        else
        {
            flags = CL_MEM_KERNEL_READ_AND_WRITE;
            flagNames = "read_write";
        }
    }

    // Grab the list of supported image formats for integer reads
    std::vector<cl_image_format> formatList;
    if (get_format_list(context, imageType, formatList, flags)) return -1;

    // First time through, we'll go ahead and print the formats supported,
    // regardless of type
    int test = imageType
        | (formatTestFn == test_read_image_formats ? (1 << 16) : (1 << 17));
    if (printedFormatList != test)
    {
        log_info("---- Supported %s %s formats for this device ---- \n",
                 convert_image_type_to_string(imageType), flagNames);
        for (unsigned int f = 0; f < formatList.size(); f++)
        {
            if (IsChannelOrderSupported(formatList[f].image_channel_order)
                && IsChannelTypeSupported(
                    formatList[f].image_channel_data_type))
                log_info(
                    "  %-7s %-24s %d\n",
                    GetChannelOrderName(formatList[f].image_channel_order),
                    GetChannelTypeName(formatList[f].image_channel_data_type),
                    (int)get_format_channel_count(&formatList[f]));
        }
        log_info("------------------------------------------- \n");
        printedFormatList = test;
    }

    image_sampler_data imageSampler;

    for (auto test : imageTestTypes)
    {
        if (gTypesToTest & test.type)
        {
            std::vector<bool> filterFlags(formatList.size(), false);
            if (filter_formats(formatList, filterFlags, test.channelTypes,
                               gTestMipmaps)
                == 0)
            {
                log_info("No formats supported for %s type\n", test.name);
            }
            else
            {
                imageSampler.filter_mode = CL_FILTER_NEAREST;
                ret += formatTestFn(device, context, queue, formatList,
                                    filterFlags, &imageSampler,
                                    test.explicitType, imageType);

                // Linear filtering is only supported with floats
                if (test.type == kTestFloat)
                {
                    imageSampler.filter_mode = CL_FILTER_LINEAR;
                    ret += formatTestFn(device, context, queue, formatList,
                                        filterFlags, &imageSampler,
                                        test.explicitType, imageType);
                }
            }
        }
    }
    return ret;
}