ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-20 06:29:02 +00:00
Code Packages Projects Releases Wiki Activity

Remove unnecessary cl_mem_flags casts (#1018)

Browse Source 
* api, atomics: remove unnecessary cl_mem_flags casts

Instances in api, atomics, buffers and c11_atomics suites

Contributes #759

Signed-off-by: Ellen Norris-Thompson <ellen.norris-thompson@arm.com>

* basic: remove unnecessary cl_mem_flags casts

Contributes #759

Signed-off-by: Ellen Norris-Thompson <ellen.norris-thompson@arm.com>

* spir, thread_dimensions: remove unnecessary cl_mem_flags casts

Instances in spir, thread_dimensions and workgroups tests

Contributes #759

Signed-off-by: Ellen Norris-Thompson <ellen.norris-thompson@arm.com>

* profiling, relationals: remove unnecessary cl_mem_flags casts

Includes relationals, profiling, muliple_device_context, integer_ops
tests

Contributes #759

Signed-off-by: Ellen Norris-Thompson <ellen.norris-thompson@arm.com>

* clcpp: remove unnecessary cl_mem_flags casts

Contibutes #759

Signed-off-by: Ellen Norris-Thompson <ellen.norris-thompson@arm.com>

* events, geometrics: remove unnecessary cl_mem_flags casts

Includes events, geometrics, gl and images tests

Contributes #759

Signed-off-by: Ellen Norris-Thompson <ellen.norris-thompson@arm.com>

* commonfs, compiler: remove unnecessary cl_mem_flags casts

Includes cast removal in commonfs, compiler and device_partition tests

Fixes #759

Signed-off-by: Ellen Norris-Thompson <ellen.norris-thompson@arm.com>

* Fix up formatting

Signed-off-by: Ellen Norris-Thompson <ellen.norris-thompson@arm.com>
This commit is contained in:
ellnor01
2020-10-19 13:56:02 +01:00
committed by GitHub
parent 8ca1537157
commit a6809710ea
140 changed files with 1077 additions and 556 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
test_conformance/clcpp/address_spaces/common.hpp
View File

@@ -165,9 +165,8 @@ int run_address_spaces_test(cl_device_id device, cl_context context, cl_command_
std::vector<TYPE> output = generate_output<TYPE>(work_size[0], 9999);
// output buffer
buffers[0] = clCreateBuffer
(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(TYPE) * output.size(), NULL, &err
);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(TYPE) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
// Execute test

3
test_conformance/clcpp/address_spaces/test_pointer_types.hpp
View File

@@ -357,7 +357,8 @@ struct constant_pointer_test : public address_spaces_test<T>
RETURN_ON_CL_ERROR(err, "clGetCommandQueueInfo");
// Create constant buffer
auto const_buff = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_ONLY), sizeof(cl_uint), NULL, &err);
auto const_buff = clCreateBuffer(context, CL_MEM_READ_ONLY,
sizeof(cl_uint), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
// Write m_test_value to const_buff

12
test_conformance/clcpp/api/test_ctors.hpp
View File

@@ -128,7 +128,9 @@ int test_ctors_execution(cl_device_id device,
// host vector, size == count, output[0...count-1] == 1
std::vector<cl_uint> output(count, cl_uint(1));
output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &error);
output_buffer =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &error);
RETURN_ON_CL_ERROR(error, "clCreateBuffer")
error = clEnqueueWriteBuffer(queue, output_buffer, CL_TRUE, 0, sizeof(cl_uint) * output.size(), static_cast<void *>(output.data()), 0, NULL, NULL);
@@ -298,7 +300,9 @@ AUTO_TEST_CASE(test_global_scope_ctors_executed_once)
// host vector, size == count, output[0...count-1] == 1
std::vector<cl_uint> output(count, cl_uint(1));
output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &error);
output_buffer =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &error);
RETURN_ON_CL_ERROR(error, "clCreateBuffer")
for(size_t i = 0; i < 4; i++)
@@ -435,7 +439,9 @@ AUTO_TEST_CASE(test_global_scope_ctors_ndrange)
// host vector, size == count, output[0...count-1] == 1
std::vector<cl_uint> output(count, cl_uint(1));
output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &error);
output_buffer =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &error);
RETURN_ON_CL_ERROR(error, "clCreateBuffer")
error = clEnqueueWriteBuffer(

12
test_conformance/clcpp/api/test_dtors.hpp
View File

@@ -114,7 +114,9 @@ AUTO_TEST_CASE(test_global_scope_dtor_is_executed)
// host vector, size == count, output[0...count-1] == 0xbeefbeef (3203383023)
// values in output __MUST BE__ greater than 0 for the test to work correctly
std::vector<cl_uint> output(count, cl_uint(0xbeefbeef));
output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &error);
output_buffer =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &error);
RETURN_ON_CL_ERROR(error, "clCreateBuffer")
error = clEnqueueWriteBuffer(
@@ -297,7 +299,9 @@ AUTO_TEST_CASE(test_global_scope_dtors_executed_once)
// values in output __MUST BE__ greater than 0 for the test to work correctly
cl_uint init_value = cl_uint(0xbeefbeef);
std::vector<cl_uint> output(count, init_value);
output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &error);
output_buffer =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &error);
RETURN_ON_CL_ERROR(error, "clCreateBuffer")
error = clEnqueueWriteBuffer(
@@ -497,7 +501,9 @@ AUTO_TEST_CASE(test_global_scope_dtor_ndrange)
// host vector, size == count, output[0...count-1] == 0xbeefbeef (3203383023)
// values in output __MUST BE__ greater than 0 for the test to work correctly
std::vector<cl_uint> output(count, cl_uint(0xbeefbeef));
output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &error);
output_buffer =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &error);
RETURN_ON_CL_ERROR(error, "clCreateBuffer")
error = clEnqueueWriteBuffer(

12
test_conformance/clcpp/api/test_spec_consts.hpp
View File

@@ -124,7 +124,9 @@ AUTO_TEST_CASE(test_spec_consts_defaults)
// host vector, size == 1, output[0] == 1
std::vector<cl_int> output(1, cl_int(1));
output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_int) * output.size(), NULL, &error);
output_buffer =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_int) * output.size(), NULL, &error);
RETURN_ON_CL_ERROR(error, "clCreateBuffer")
error = clEnqueueWriteBuffer(queue, output_buffer, CL_TRUE, 0, sizeof(cl_int) * output.size(), static_cast<void *>(output.data()), 0, NULL, NULL);
@@ -248,7 +250,9 @@ AUTO_TEST_CASE(test_spec_consts_many_constants)
// host vector, size == 1, output[0] == 1
std::vector<cl_int> output(1, cl_int(1));
output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_int) * output.size(), NULL, &error);
output_buffer =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_int) * output.size(), NULL, &error);
RETURN_ON_CL_ERROR(error, "clCreateBuffer")
error = clEnqueueWriteBuffer(queue, output_buffer, CL_TRUE, 0, sizeof(cl_int) * output.size(), static_cast<void *>(output.data()), 0, NULL, NULL);
@@ -443,7 +447,9 @@ AUTO_TEST_CASE(test_spec_consts_different_types)
// host vector, size == 1, output[0] == 1
std::vector<cl_int> output(1, cl_int(1));
output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_int) * output.size(), NULL, &error);
output_buffer =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_int) * output.size(), NULL, &error);
RETURN_ON_CL_ERROR(error, "clCreateBuffer")
error = clEnqueueWriteBuffer(queue, output_buffer, CL_TRUE, 0, sizeof(cl_int) * output.size(), static_cast<void *>(output.data()), 0, NULL, NULL);

6
test_conformance/clcpp/atomics/atomic_fetch.hpp
View File

@@ -130,10 +130,12 @@ int test_atomic_fetch_func(cl_device_id device, cl_context context, cl_command_q
std::vector<TYPE> input = generate_input<TYPE>(count, op.min1(), op.max1(), std::vector<TYPE>());
std::vector<TYPE> output = generate_output<TYPE>((count - 1) / atomic_bucket_size + 1);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(TYPE) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(TYPE) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(TYPE) * output.size(), NULL, &err);
buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(TYPE) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
err = clEnqueueWriteBuffer(

3
test_conformance/clcpp/math_funcs/logarithmic_funcs.hpp
View File

@@ -49,7 +49,8 @@ int get_ilogb_nan_zero(cl_device_id device, cl_context context, cl_command_queue
std::vector<cl_int> output = generate_output<cl_int>(2);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_int) * output.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_int) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
err = clSetKernelArg(kernel, 0, sizeof(buffers[0]), &buffers[0]);

5
test_conformance/clcpp/program_scope_ctors_dtors/common.hpp
View File

@@ -230,9 +230,8 @@ int run_ps_ctor_dtor_test(cl_device_id device, cl_context context, cl_command_qu
std::vector<cl_uint> output = generate_output<cl_uint>(work_size[0], 9999);
// device output buffer
buffers[0] = clCreateBuffer(
context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err
);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
// Execute test

5
test_conformance/clcpp/spec_constants/common.hpp
View File

@@ -213,9 +213,8 @@ int run_spec_constants_test(cl_device_id device, cl_context context, cl_command_
std::vector<TYPE> output = generate_output<TYPE>(work_size[0], 9999);
// device output buffer
buffers[0] = clCreateBuffer(
context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(TYPE) * output.size(), NULL, &err
);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(TYPE) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
// Execute test

6
test_conformance/clcpp/subgroups/test_sg_all.hpp
View File

@@ -169,10 +169,12 @@ int sub_group_all(cl_device_id device, cl_context context, cl_command_queue queu
std::vector<cl_uint> input = generate_input_sg_all(flat_work_size + 1, wg_size);
std::vector<cl_uint> output = generate_output_sg_all(flat_work_size, wg_size);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

6
test_conformance/clcpp/subgroups/test_sg_any.hpp
View File

@@ -169,10 +169,12 @@ int sub_group_any(cl_device_id device, cl_context context, cl_command_queue queu
std::vector<cl_uint> input = generate_input_sg_any(flat_work_size + 1, wg_size);
std::vector<cl_uint> output = generate_output_sg_any(flat_work_size, wg_size);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

6
test_conformance/clcpp/subgroups/test_sg_broadcast.hpp
View File

@@ -156,10 +156,12 @@ int sub_group_broadcast(cl_device_id device, cl_context context, cl_command_queu
std::vector<cl_uint> input = generate_input_sg_broadcast(flat_work_size, wg_size);
std::vector<cl_uint> output = generate_output_sg_broadcast(flat_work_size, wg_size);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * input.size(), NULL,&err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

7
test_conformance/clcpp/subgroups/test_sg_reduce.hpp
View File

@@ -223,10 +223,13 @@ int sub_group_reduce(cl_device_id device, cl_context context, cl_command_queue q
std::vector<CL_INT_TYPE> input = generate_input<CL_INT_TYPE, op>(flat_work_size, wg_size);
std::vector<CL_INT_TYPE> output = generate_output<CL_INT_TYPE, op>(flat_work_size, wg_size);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
buffers[1] =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

7
test_conformance/clcpp/subgroups/test_sg_scan_exclusive.hpp
View File

@@ -210,10 +210,13 @@ int sub_group_scan_exclusive(cl_device_id device, cl_context context, cl_command
std::vector<CL_INT_TYPE> input = generate_input<CL_INT_TYPE, op>(flat_work_size, wg_size);
std::vector<CL_INT_TYPE> output = generate_output<CL_INT_TYPE, op>(flat_work_size, wg_size);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
buffers[1] =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

7
test_conformance/clcpp/subgroups/test_sg_scan_inclusive.hpp
View File

@@ -210,10 +210,13 @@ int sub_group_scan_inclusive(cl_device_id device, cl_context context, cl_command
std::vector<CL_INT_TYPE> input = generate_input<CL_INT_TYPE, op>(flat_work_size, wg_size);
std::vector<CL_INT_TYPE> output = generate_output<CL_INT_TYPE, op>(flat_work_size, wg_size);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
buffers[1] =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

3
test_conformance/clcpp/synchronization/named_barrier/common.hpp
View File

@@ -133,7 +133,8 @@ int run_work_group_named_barrier_barrier_test(cl_device_id device, cl_context co
std::vector<cl_uint> output = generate_output<cl_uint>(work_size[0], 9999);
// device output buffer
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
// Execute test kernels

11
test_conformance/clcpp/synchronization/named_barrier/test_named_barrier.hpp
View File

@@ -276,7 +276,9 @@ struct global_fence_named_barrier_test : public work_group_named_barrier_test_ba
RETURN_ON_CL_ERROR(err, "clGetCommandQueueInfo")
// create temp buffer
auto temp_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * work_size, NULL, &err);
auto temp_buffer =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * work_size, NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
err = clSetKernelArg(kernel, 0, sizeof(output_buffer), &output_buffer);
@@ -420,10 +422,9 @@ struct global_local_fence_named_barrier_test : public work_group_named_barrier_t
RETURN_ON_CL_ERROR(err, "clGetCommandQueueInfo")
// create temp buffer
auto temp_buffer = clCreateBuffer(
context, (cl_mem_flags)(CL_MEM_READ_WRITE),
sizeof(cl_uint) * work_size, NULL, &err
);
auto temp_buffer =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * work_size, NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
err = clSetKernelArg(kernel, 0, sizeof(output_buffer), &output_buffer);

4
test_conformance/clcpp/synchronization/named_barrier/test_spec_example.hpp
View File

@@ -270,7 +270,9 @@ struct spec_example_work_group_named_barrier_test : public work_group_named_barr
RETURN_ON_CL_ERROR(err, "clGetCommandQueueInfo")
// create temp buffer
auto temp_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * work_size, NULL, &err);
auto temp_buffer =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * work_size, NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
err = clSetKernelArg(kernel, 0, sizeof(output_buffer), &output_buffer);

15
test_conformance/clcpp/utils_test/binary.hpp
View File

@@ -243,19 +243,16 @@ int test_binary_func(cl_device_id device, cl_context context, cl_command_queue q
std::vector<INPUT2> input2 = generate_input<INPUT2>(count, op.min2(), op.max2(), in2_spec_cases);
std::vector<OUTPUT> output = generate_output<OUTPUT>(count);
buffers[0] = clCreateBuffer(
context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT1) * input1.size(), NULL, &err
);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(INPUT1) * input1.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
buffers[1] = clCreateBuffer(
context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT2) * input2.size(), NULL, &err
);
buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(INPUT2) * input2.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
buffers[2] = clCreateBuffer(
context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(OUTPUT) * output.size(), NULL, &err
);
buffers[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(OUTPUT) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
err = clEnqueueWriteBuffer(

20
test_conformance/clcpp/utils_test/ternary.hpp
View File

@@ -284,24 +284,20 @@ int test_ternary_func(cl_device_id device, cl_context context, cl_command_queue
std::vector<INPUT3> input3 = generate_input<INPUT3>(count, op.min3(), op.max3(), in3_spec_cases);
std::vector<OUTPUT> output = generate_output<OUTPUT>(count);
buffers[0] = clCreateBuffer(
context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT1) * input1.size(), NULL, &err
);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(INPUT1) * input1.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
buffers[1] = clCreateBuffer(
context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT2) * input2.size(), NULL, &err
);
buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(INPUT2) * input2.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
buffers[2] = clCreateBuffer(
context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT3) * input3.size(), NULL, &err
);
buffers[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(INPUT3) * input3.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
buffers[3] = clCreateBuffer(
context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(OUTPUT) * output.size(), NULL, &err
);
buffers[3] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(OUTPUT) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
err = clEnqueueWriteBuffer(

10
test_conformance/clcpp/utils_test/unary.hpp
View File

@@ -215,14 +215,12 @@ int test_unary_func(cl_device_id device, cl_context context, cl_command_queue qu
std::vector<INPUT> input = generate_input<INPUT>(count, op.min1(), op.max1(), op.in_special_cases());
std::vector<OUTPUT> output = generate_output<OUTPUT>(count);
buffers[0] = clCreateBuffer(
context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT) * input.size(), NULL, &err
);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(INPUT) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
buffers[1] = clCreateBuffer(
context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(OUTPUT) * output.size(), NULL, &err
);
buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(OUTPUT) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer")
err = clEnqueueWriteBuffer(

6
test_conformance/clcpp/vload_vstore/vload_funcs.hpp
View File

@@ -140,10 +140,12 @@ int test_vload_func(cl_device_id device, cl_context context, cl_command_queue qu
);
std::vector<OUTPUT> output = generate_output<OUTPUT>(count);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(INPUT) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(OUTPUT) * output.size(), NULL, &err);
buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(OUTPUT) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

6
test_conformance/clcpp/vload_vstore/vstore_funcs.hpp
View File

@@ -138,10 +138,12 @@ int test_vstore_func(cl_device_id device, cl_context context, cl_command_queue q
std::vector<INPUT> input = generate_input<INPUT>(count, op.min1(), op.max1(), op.in_special_cases());
std::vector<OUTPUT> output = generate_output<OUTPUT>(count * vector_size<INPUT>::value);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(INPUT) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(OUTPUT) * output.size(), NULL, &err);
buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(OUTPUT) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

6
test_conformance/clcpp/workgroups/test_wg_all.hpp
View File

@@ -164,10 +164,12 @@ int work_group_all(cl_device_id device, cl_context context, cl_command_queue que
std::vector<cl_uint> input = generate_input_wg_all(flat_work_size + 1, wg_size);
std::vector<cl_uint> output = generate_output_wg_all(flat_work_size, wg_size);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

6
test_conformance/clcpp/workgroups/test_wg_any.hpp
View File

@@ -164,10 +164,12 @@ int work_group_any(cl_device_id device, cl_context context, cl_command_queue que
std::vector<cl_uint> input = generate_input_wg_any(flat_work_size + 1, wg_size);
std::vector<cl_uint> output = generate_output_wg_any(flat_work_size, wg_size);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

6
test_conformance/clcpp/workgroups/test_wg_broadcast.hpp
View File

@@ -368,10 +368,12 @@ int work_group_broadcast(cl_device_id device, cl_context context, cl_command_que
std::vector<cl_uint> input = generate_input_wg_broadcast(flat_work_size, flat_wg_size);
std::vector<cl_uint> output = generate_output_wg_broadcast(flat_work_size, flat_wg_size);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_uint) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

7
test_conformance/clcpp/workgroups/test_wg_reduce.hpp
View File

@@ -209,10 +209,13 @@ int work_group_reduce(cl_device_id device, cl_context context, cl_command_queue
std::vector<CL_INT_TYPE> input = generate_input<CL_INT_TYPE, op>(flat_work_size, wg_size);
std::vector<CL_INT_TYPE> output = generate_output<CL_INT_TYPE, op>(flat_work_size, wg_size);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
buffers[1] =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

7
test_conformance/clcpp/workgroups/test_wg_scan_exclusive.hpp
View File

@@ -202,10 +202,13 @@ int work_group_scan_exclusive(cl_device_id device, cl_context context, cl_comman
std::vector<CL_INT_TYPE> input = generate_input<CL_INT_TYPE, op>(flat_work_size, wg_size);
std::vector<CL_INT_TYPE> output = generate_output<CL_INT_TYPE, op>(flat_work_size, wg_size);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
buffers[1] =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(

7
test_conformance/clcpp/workgroups/test_wg_scan_inclusive.hpp
View File

@@ -202,10 +202,13 @@ int work_group_scan_inclusive(cl_device_id device, cl_context context, cl_comman
std::vector<CL_INT_TYPE> input = generate_input<CL_INT_TYPE, op>(flat_work_size, wg_size);
std::vector<CL_INT_TYPE> output = generate_output<CL_INT_TYPE, op>(flat_work_size, wg_size);
buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
buffers[1] =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
RETURN_ON_CL_ERROR(err, "clCreateBuffer");
err = clEnqueueWriteBuffer(