Function REGISTER_TEST

test_conformance/buffers/test_buffer_fill.cpp:712–905

REGISTER_TEST(buffer_fill_struct)
{
    TestStruct pattern;
    size_t      ptrSize = sizeof( TestStruct );
    size_t      global_work_size[3];
    int         n, err;
    size_t      j, offset_elements, fill_elements;
    int         src_flag_id;
    int         total_errors = 0;
    MTdata      d = init_genrand( gRandomSeed );

    size_t      min_alignment = get_min_alignment(context);

    global_work_size[0] = (size_t)num_elements;


    for (src_flag_id = 0; src_flag_id < NUM_FLAGS; src_flag_id++)
    {
        // Skip immutable memory flags
        if (flag_set[src_flag_id] & CL_MEM_IMMUTABLE_EXT)
        {
            continue;
        }

        clProgramWrapper program;
        clKernelWrapper kernel;
        log_info("Testing with cl_mem_flags: %s\n",
                 flag_set_names[src_flag_id]);

        err = create_single_kernel_helper(context, &program, &kernel, 1,
                                          &struct_kernel_code,
                                          "read_fill_struct");
        if (err)
        {
            log_error(" Error creating program for struct\n");
            free_mtdata(d);
            return -1;
        }

        // Test with random offsets and fill sizes
        for (n = 0; n < 8; n++)
        {
            clEventWrapper event[2];
            clMemWrapper buffers[2];
            void *outptr;
            TestStruct *inptr;
            TestStruct *hostptr;

            offset_elements =
                (size_t)get_random_float(0.f, (float)(num_elements - 8), d);
            fill_elements = (size_t)get_random_float(
                8.f, (float)(num_elements - offset_elements), d);
            log_info("Testing random fill from offset %d for %d elements: \n",
                     (int)offset_elements, (int)fill_elements);

            pattern.a = (cl_int)genrand_int32(d);
            pattern.b = (cl_float)get_random_float(-FLT_MAX, FLT_MAX, d);