1 //
2 // Copyright (c) 2022 The Khronos Group Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 #include "basic_command_buffer.h"
17 #include "svm_command_basic.h"
18 #include "harness/typeWrappers.h"
19 #include "procs.h"
20
21 #include <vector>
22
23
24 namespace {
25
26 ////////////////////////////////////////////////////////////////////////////////
27 // Command-buffer fill tests which handles below cases:
28 //
29 // -fill image
30 // -fill buffer
31
32 struct FillImageKHR : public BasicCommandBufferTest
33 {
34 using BasicCommandBufferTest::BasicCommandBufferTest;
35
Run__anon6dfc16ab0111::FillImageKHR36 cl_int Run() override
37 {
38 cl_int error =
39 clCommandFillImageKHR(command_buffer, nullptr, image, fill_color_1,
40 origin, region, 0, nullptr, nullptr, nullptr);
41
42 test_error(error, "clCommandFillImageKHR failed");
43
44 error = clFinalizeCommandBufferKHR(command_buffer);
45 test_error(error, "clFinalizeCommandBufferKHR failed");
46
47 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
48 nullptr, nullptr);
49 test_error(error, "clEnqueueCommandBufferKHR failed");
50
51 std::vector<cl_char> output_data_1(data_size);
52 error = clEnqueueReadImage(queue, image, CL_TRUE, origin, region, 0, 0,
53 output_data_1.data(), 0, nullptr, nullptr);
54
55 for (size_t i = 0; i < data_size; i++)
56 {
57 CHECK_VERIFICATION_ERROR(static_cast<cl_char>(pattern_1),
58 output_data_1[i], i);
59 }
60
61 /* Check second enqueue of command buffer */
62
63 error = clEnqueueFillImage(queue, image, fill_color_2, origin, region,
64 0, nullptr, nullptr);
65 test_error(error, "clEnqueueFillImage failed");
66
67 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
68 nullptr, nullptr);
69 test_error(error, "clEnqueueCommandBufferKHR failed");
70
71 std::vector<cl_char> output_data_2(data_size);
72 error = clEnqueueReadImage(queue, image, CL_TRUE, origin, region, 0, 0,
73 output_data_2.data(), 0, nullptr, nullptr);
74
75 for (size_t i = 0; i < data_size; i++)
76 {
77 CHECK_VERIFICATION_ERROR(static_cast<cl_char>(pattern_1),
78 output_data_2[i], i);
79 }
80
81 return CL_SUCCESS;
82 }
83
SetUp__anon6dfc16ab0111::FillImageKHR84 cl_int SetUp(int elements) override
85 {
86 cl_int error = BasicCommandBufferTest::SetUp(elements);
87 test_error(error, "BasicCommandBufferTest::SetUp failed");
88
89 image = create_image_2d(context, CL_MEM_READ_WRITE, &formats, img_width,
90 img_height, 0, NULL, &error);
91 test_error(error, "create_image_2d failed");
92
93 return CL_SUCCESS;
94 }
95
Skip__anon6dfc16ab0111::FillImageKHR96 bool Skip() override
97 {
98 bool imageSupport =
99 checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED;
100
101 return imageSupport || BasicCommandBufferTest::Skip();
102 }
103
104 const size_t img_width = 512;
105 const size_t img_height = 512;
106 const size_t data_size = img_width * img_height * 4 * sizeof(cl_char);
107 const size_t origin[3] = { 0, 0, 0 },
108 region[3] = { img_width, img_height, 1 };
109 const cl_uint pattern_1 = 0x10;
110 const cl_uint fill_color_1[4] = { pattern_1, pattern_1, pattern_1,
111 pattern_1 };
112 const cl_uint pattern_2 = 0x20;
113 const cl_uint fill_color_2[4] = { pattern_2, pattern_2, pattern_2,
114 pattern_2 };
115 const cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 };
116
117 clMemWrapper image;
118 };
119
120 struct FillBufferKHR : public BasicCommandBufferTest
121 {
122 using BasicCommandBufferTest::BasicCommandBufferTest;
123
Run__anon6dfc16ab0111::FillBufferKHR124 cl_int Run() override
125 {
126 cl_int error = clCommandFillBufferKHR(
127 command_buffer, nullptr, in_mem, &pattern_1, sizeof(cl_char), 0,
128 data_size(), 0, nullptr, nullptr, nullptr);
129
130 test_error(error, "clCommandFillBufferKHR failed");
131
132 error = clFinalizeCommandBufferKHR(command_buffer);
133 test_error(error, "clFinalizeCommandBufferKHR failed");
134
135 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
136 nullptr, nullptr);
137 test_error(error, "clEnqueueCommandBufferKHR failed");
138
139 std::vector<cl_char> output_data_1(data_size());
140 error = clEnqueueReadBuffer(queue, in_mem, CL_TRUE, 0, data_size(),
141 output_data_1.data(), 0, nullptr, nullptr);
142 test_error(error, "clEnqueueReadBuffer failed");
143
144 for (size_t i = 0; i < data_size(); i++)
145 {
146 CHECK_VERIFICATION_ERROR(pattern_1, output_data_1[i], i);
147 }
148
149 /* Check second enqueue of command buffer */
150
151 clEnqueueFillBuffer(queue, in_mem, &pattern_2, sizeof(cl_char), 0,
152 data_size(), 0, nullptr, nullptr);
153
154 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
155 nullptr, nullptr);
156 test_error(error, "clEnqueueCommandBufferKHR failed");
157
158 std::vector<cl_char> output_data_2(data_size());
159 error = clEnqueueReadBuffer(queue, in_mem, CL_TRUE, 0, data_size(),
160 output_data_2.data(), 0, nullptr, nullptr);
161 test_error(error, "clEnqueueReadBuffer failed");
162
163 for (size_t i = 0; i < data_size(); i++)
164 {
165 CHECK_VERIFICATION_ERROR(pattern_1, output_data_2[i], i);
166 }
167
168 return CL_SUCCESS;
169 }
170
171 const char pattern_1 = 0x15;
172 const char pattern_2 = 0x30;
173 };
174
175 struct FillSVMBufferKHR : public BasicSVMCommandBufferTest
176 {
177 using BasicSVMCommandBufferTest::BasicSVMCommandBufferTest;
178
Run__anon6dfc16ab0111::FillSVMBufferKHR179 cl_int Run() override
180 {
181 cl_int error = clCommandSVMMemFillKHR(
182 command_buffer, nullptr, svm_in_mem(), &pattern_1, sizeof(cl_char),
183 data_size(), 0, nullptr, nullptr, nullptr);
184 test_error(error, "clCommandSVMMemFillKHR failed");
185
186 error = clFinalizeCommandBufferKHR(command_buffer);
187 test_error(error, "clFinalizeCommandBufferKHR failed");
188
189 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
190 nullptr, nullptr);
191 test_error(error, "clEnqueueCommandBufferKHR failed");
192
193 std::vector<cl_char> output_data_1(data_size());
194
195 error =
196 clEnqueueSVMMemcpy(queue, CL_TRUE, output_data_1.data(),
197 svm_in_mem(), data_size(), 0, nullptr, nullptr);
198 test_error(error, "clEnqueueSVMMemcpy failed");
199
200 for (size_t i = 0; i < data_size(); i++)
201 {
202 CHECK_VERIFICATION_ERROR(pattern_1, output_data_1[i], i);
203 }
204
205 /* Check second enqueue of command buffer */
206 error = clEnqueueSVMMemFill(queue, svm_in_mem(), &pattern_2,
207 sizeof(cl_char), data_size(), 0, nullptr,
208 nullptr);
209 test_error(error, "clEnqueueSVMMemFill failed");
210
211 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
212 nullptr, nullptr);
213 test_error(error, "clEnqueueCommandBufferKHR failed");
214
215 std::vector<cl_char> output_data_2(data_size());
216
217 error =
218 clEnqueueSVMMemcpy(queue, CL_TRUE, output_data_2.data(),
219 svm_in_mem(), data_size(), 0, nullptr, nullptr);
220 test_error(error, "clEnqueueSVMMemcpy failed");
221
222 for (size_t i = 0; i < data_size(); i++)
223 {
224 CHECK_VERIFICATION_ERROR(pattern_1, output_data_2[i], i);
225 }
226
227 return CL_SUCCESS;
228 }
229
230 const char pattern_1 = 0x15;
231 const char pattern_2 = 0x30;
232 };
233 };
234
test_fill_buffer(cl_device_id device,cl_context context,cl_command_queue queue,int num_elements)235 int test_fill_buffer(cl_device_id device, cl_context context,
236 cl_command_queue queue, int num_elements)
237 {
238 return MakeAndRunTest<FillBufferKHR>(device, context, queue, num_elements);
239 }
240
test_fill_svm_buffer(cl_device_id device,cl_context context,cl_command_queue queue,int num_elements)241 int test_fill_svm_buffer(cl_device_id device, cl_context context,
242 cl_command_queue queue, int num_elements)
243 {
244 return MakeAndRunTest<FillSVMBufferKHR>(device, context, queue,
245 num_elements);
246 }
247
248
test_fill_image(cl_device_id device,cl_context context,cl_command_queue queue,int num_elements)249 int test_fill_image(cl_device_id device, cl_context context,
250 cl_command_queue queue, int num_elements)
251 {
252 return MakeAndRunTest<FillImageKHR>(device, context, queue, num_elements);
253 }
254