1 // Copyright 2022 Google LLC
2 //
3 // This source code is licensed under the BSD-style license found in the
4 // LICENSE file in the root directory of this source tree.
5
6 #include <algorithm>
7 #include <array>
8 #include <cstddef>
9 #include <cstdint>
10 #include <limits>
11 #include <memory>
12 #include <numeric>
13 #include <random>
14
15 #include <xnnpack.h>
16 #include <xnnpack/node-type.h>
17 #include <xnnpack/operator.h>
18 #include <xnnpack/subgraph.h>
19
20 #include <gtest/gtest.h>
21
22 template <typename T> class EvenSplit2Test : public ::testing::Test {
23 protected:
EvenSplit2Test()24 EvenSplit2Test()
25 {
26 random_device = std::unique_ptr<std::random_device>(new std::random_device());
27 rng = std::mt19937((*random_device)());
28 shape_dist = std::uniform_int_distribution<size_t>(1, XNN_MAX_TENSOR_DIMS);
29 dim_dist = std::uniform_int_distribution<size_t>(1, 9);
30 f32dist = std::uniform_real_distribution<float>();
31 i8dist =
32 std::uniform_int_distribution<int32_t>(std::numeric_limits<int8_t>::min(), std::numeric_limits<int8_t>::max());
33 u8dist =
34 std::uniform_int_distribution<int32_t>(std::numeric_limits<uint8_t>::min(), std::numeric_limits<uint8_t>::max());
35 scale_dist = std::uniform_real_distribution<float>(0.1f, 5.0f);
36
37 output1_dims = RandomShape();
38 axis = RandomAxis(output1_dims);
39 output2_dims = output1_dims;
40 input_dims = output1_dims;
41 input_dims[axis] = output1_dims[axis] + output2_dims[axis];
42
43 input = std::vector<T>(NumElements(input_dims));
44 operator_output1 = std::vector<T>(NumElements(output1_dims));
45 operator_output2 = std::vector<T>(NumElements(output2_dims));
46 subgraph_output1 = std::vector<T>(NumElements(output1_dims));
47 subgraph_output2 = std::vector<T>(NumElements(output2_dims));
48
49 signed_zero_point = i8dist(rng);
50 unsigned_zero_point = u8dist(rng);
51 scale = scale_dist(rng);
52
53 batch_size = 1;
54 input_stride = 1;
55 for (size_t i = 0; i < axis; i++) {
56 batch_size *= input_dims[i];
57 }
58
59 for (size_t i = axis; i < input_dims.size(); i++) {
60 input_stride *= input_dims[i];
61 }
62 channels = input_stride / 2;
63 }
64
RandomShape()65 std::vector<size_t> RandomShape()
66 {
67 std::vector<size_t> dims(shape_dist(rng));
68 std::generate(dims.begin(), dims.end(), [&] { return dim_dist(rng); });
69 return dims;
70 }
71
RandomAxis(const std::vector<size_t> & dims)72 size_t RandomAxis(const std::vector<size_t>& dims)
73 {
74 return std::uniform_int_distribution<size_t>(0, dims.size() - 1)(rng);
75 }
76
NumElements(const std::vector<size_t> & dims)77 size_t NumElements(const std::vector<size_t>& dims)
78 {
79 return std::accumulate(dims.begin(), dims.end(), size_t(1), std::multiplies<size_t>());
80 }
81
82 std::unique_ptr<std::random_device> random_device;
83 std::mt19937 rng;
84 std::uniform_int_distribution<size_t> shape_dist;
85 std::uniform_int_distribution<size_t> dim_dist;
86 std::uniform_real_distribution<float> f32dist;
87 std::uniform_int_distribution<int32_t> i8dist;
88 std::uniform_int_distribution<int32_t> u8dist;
89 std::uniform_real_distribution<float> scale_dist;
90
91 uint32_t output1_id;
92 uint32_t output2_id;
93 uint32_t input_id;
94
95 std::vector<size_t> output1_dims;
96 std::vector<size_t> output2_dims;
97 std::vector<size_t> input_dims;
98
99 size_t axis;
100 size_t batch_size;
101 size_t channels;
102 size_t input_stride;
103
104 int32_t signed_zero_point;
105 int32_t unsigned_zero_point;
106 float scale;
107
108 std::vector<T> operator_output1;
109 std::vector<T> operator_output2;
110 std::vector<T> subgraph_output1;
111 std::vector<T> subgraph_output2;
112 std::vector<T> input;
113 };
114
115 using EvenSplit2TestQS8 = EvenSplit2Test<int8_t>;
116 using EvenSplit2TestQU8 = EvenSplit2Test<uint8_t>;
117 using EvenSplit2TestF32 = EvenSplit2Test<float>;
118
TEST_F(EvenSplit2TestQS8,define)119 TEST_F(EvenSplit2TestQS8, define)
120 {
121 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
122
123 xnn_subgraph_t subgraph = nullptr;
124 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/3, /*flags=*/0, &subgraph));
125 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
126
127 input_id = XNN_INVALID_NODE_ID;
128 ASSERT_EQ(
129 xnn_status_success,
130 xnn_define_quantized_tensor_value(
131 subgraph, xnn_datatype_qint8, signed_zero_point, scale, input_dims.size(), input_dims.data(), nullptr, 0,
132 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
133 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
134
135 output1_id = XNN_INVALID_NODE_ID;
136 ASSERT_EQ(
137 xnn_status_success,
138 xnn_define_quantized_tensor_value(
139 subgraph, xnn_datatype_qint8, signed_zero_point, scale, output1_dims.size(), output1_dims.data(), nullptr, 1,
140 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output1_id));
141 ASSERT_NE(output1_id, XNN_INVALID_NODE_ID);
142
143 output2_id = XNN_INVALID_NODE_ID;
144 ASSERT_EQ(
145 xnn_status_success,
146 xnn_define_quantized_tensor_value(
147 subgraph, xnn_datatype_qint8, signed_zero_point, scale, output2_dims.size(), output2_dims.data(), nullptr, 2,
148 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output2_id));
149 ASSERT_NE(output2_id, XNN_INVALID_NODE_ID);
150
151 ASSERT_EQ(xnn_status_success, xnn_define_even_split2(subgraph, axis, input_id, output1_id, output2_id, /*flags=*/0));
152
153 ASSERT_EQ(subgraph->num_nodes, 1);
154 const struct xnn_node* node = &subgraph->nodes[0];
155 ASSERT_EQ(node->type, xnn_node_type_even_split2);
156 ASSERT_EQ(node->compute_type, xnn_compute_type_qs8);
157 ASSERT_EQ(node->params.even_split.axis, axis);
158 ASSERT_EQ(node->num_inputs, 1);
159 ASSERT_EQ(node->inputs[0], input_id);
160 ASSERT_EQ(node->num_outputs, 2);
161 ASSERT_EQ(node->outputs[0], output1_id);
162 ASSERT_EQ(node->outputs[1], output2_id);
163 ASSERT_EQ(node->flags, 0);
164 }
165
TEST_F(EvenSplit2TestQU8,define)166 TEST_F(EvenSplit2TestQU8, define)
167 {
168 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
169
170 xnn_subgraph_t subgraph = nullptr;
171 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/3, /*flags=*/0, &subgraph));
172 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
173
174 input_id = XNN_INVALID_NODE_ID;
175 ASSERT_EQ(
176 xnn_status_success,
177 xnn_define_quantized_tensor_value(
178 subgraph, xnn_datatype_quint8, unsigned_zero_point, scale, input_dims.size(), input_dims.data(), nullptr, 0,
179 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
180 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
181
182 output1_id = XNN_INVALID_NODE_ID;
183 ASSERT_EQ(
184 xnn_status_success,
185 xnn_define_quantized_tensor_value(
186 subgraph, xnn_datatype_quint8, unsigned_zero_point, scale, output1_dims.size(), output1_dims.data(), nullptr, 1,
187 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output1_id));
188 ASSERT_NE(output1_id, XNN_INVALID_NODE_ID);
189
190 output2_id = XNN_INVALID_NODE_ID;
191 ASSERT_EQ(
192 xnn_status_success,
193 xnn_define_quantized_tensor_value(
194 subgraph, xnn_datatype_quint8, unsigned_zero_point, scale, output2_dims.size(), output2_dims.data(), nullptr, 2,
195 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output2_id));
196 ASSERT_NE(output2_id, XNN_INVALID_NODE_ID);
197
198 ASSERT_EQ(xnn_status_success, xnn_define_even_split2(subgraph, axis, input_id, output1_id, output2_id, /*flags=*/0));
199
200 ASSERT_EQ(subgraph->num_nodes, 1);
201 const struct xnn_node* node = &subgraph->nodes[0];
202 ASSERT_EQ(node->type, xnn_node_type_even_split2);
203 ASSERT_EQ(node->compute_type, xnn_compute_type_qu8);
204 ASSERT_EQ(node->params.even_split.axis, axis);
205 ASSERT_EQ(node->num_inputs, 1);
206 ASSERT_EQ(node->inputs[0], input_id);
207 ASSERT_EQ(node->num_outputs, 2);
208 ASSERT_EQ(node->outputs[0], output1_id);
209 ASSERT_EQ(node->outputs[1], output2_id);
210 ASSERT_EQ(node->flags, 0);
211 }
212
TEST_F(EvenSplit2TestF32,define)213 TEST_F(EvenSplit2TestF32, define)
214 {
215 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
216
217 xnn_subgraph_t subgraph = nullptr;
218 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/3, /*flags=*/0, &subgraph));
219 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
220
221 input_id = XNN_INVALID_NODE_ID;
222 ASSERT_EQ(
223 xnn_status_success, xnn_define_tensor_value(
224 subgraph, xnn_datatype_fp32, input_dims.size(), input_dims.data(), nullptr, 0,
225 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
226 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
227
228 output1_id = XNN_INVALID_NODE_ID;
229 ASSERT_EQ(
230 xnn_status_success, xnn_define_tensor_value(
231 subgraph, xnn_datatype_fp32, output1_dims.size(), output1_dims.data(), nullptr, 1,
232 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output1_id));
233 ASSERT_NE(output1_id, XNN_INVALID_NODE_ID);
234
235 output2_id = XNN_INVALID_NODE_ID;
236 ASSERT_EQ(
237 xnn_status_success, xnn_define_tensor_value(
238 subgraph, xnn_datatype_fp32, output2_dims.size(), output2_dims.data(), nullptr, 2,
239 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output2_id));
240 ASSERT_NE(output2_id, XNN_INVALID_NODE_ID);
241 ASSERT_EQ(xnn_status_success, xnn_define_even_split2(subgraph, axis, input_id, output1_id, output2_id, /*flags=*/0));
242
243 ASSERT_EQ(subgraph->num_nodes, 1);
244 const struct xnn_node* node = &subgraph->nodes[0];
245 ASSERT_EQ(node->type, xnn_node_type_even_split2);
246 ASSERT_EQ(node->compute_type, xnn_compute_type_fp32);
247 ASSERT_EQ(node->params.even_split.axis, axis);
248 ASSERT_EQ(node->num_inputs, 1);
249 ASSERT_EQ(node->inputs[0], input_id);
250 ASSERT_EQ(node->num_outputs, 2);
251 ASSERT_EQ(node->outputs[0], output1_id);
252 ASSERT_EQ(node->outputs[1], output2_id);
253 ASSERT_EQ(node->flags, 0);
254 }
255
TEST_F(EvenSplit2TestQS8,matches_operator_api)256 TEST_F(EvenSplit2TestQS8, matches_operator_api)
257 {
258 std::generate(input.begin(), input.end(), [&]() { return i8dist(rng); });
259 std::fill(operator_output1.begin(), operator_output1.end(), INT8_C(0xA5));
260 std::fill(operator_output2.begin(), operator_output2.end(), INT8_C(0xA5));
261 std::fill(subgraph_output1.begin(), subgraph_output1.end(), INT8_C(0xA5));
262 std::fill(subgraph_output2.begin(), subgraph_output2.end(), INT8_C(0xA5));
263
264 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
265
266 xnn_operator_t op1 = nullptr;
267 xnn_operator_t op2 = nullptr;
268
269 // Call operator API.
270 ASSERT_EQ(xnn_status_success, xnn_create_copy_nc_x8(channels, input_stride, channels, /*flags=*/0, &op1));
271 std::unique_ptr<xnn_operator, decltype(&xnn_delete_operator)> auto_op1(op1, xnn_delete_operator);
272 ASSERT_EQ(xnn_status_success, xnn_create_copy_nc_x8(channels, input_stride, channels, /*flags=*/0, &op2));
273 std::unique_ptr<xnn_operator, decltype(&xnn_delete_operator)> auto_op2(op2, xnn_delete_operator);
274
275 ASSERT_EQ(
276 xnn_status_success,
277 xnn_setup_copy_nc_x8(op1, batch_size, input.data(), operator_output1.data(), nullptr /* thread pool */));
278 ASSERT_EQ(
279 xnn_status_success,
280 xnn_setup_copy_nc_x8(
281 op2, batch_size, (uint8_t*) input.data() + op1->channels, operator_output2.data(), nullptr /* thread pool */));
282
283 ASSERT_EQ(xnn_status_success, xnn_run_operator(op1, nullptr /* thread pool */));
284 ASSERT_EQ(xnn_status_success, xnn_run_operator(op2, nullptr /* thread pool */));
285
286 // Call subgraph API.
287 xnn_subgraph_t subgraph = nullptr;
288 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/3, /*flags=*/0, &subgraph));
289 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
290
291 input_id = XNN_INVALID_NODE_ID;
292 ASSERT_EQ(
293 xnn_status_success,
294 xnn_define_quantized_tensor_value(
295 subgraph, xnn_datatype_qint8, signed_zero_point, scale, input_dims.size(), input_dims.data(), nullptr, 0,
296 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
297 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
298
299 output1_id = XNN_INVALID_NODE_ID;
300 ASSERT_EQ(
301 xnn_status_success,
302 xnn_define_quantized_tensor_value(
303 subgraph, xnn_datatype_qint8, signed_zero_point, scale, output1_dims.size(), output1_dims.data(), nullptr, 1,
304 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output1_id));
305 ASSERT_NE(output1_id, XNN_INVALID_NODE_ID);
306
307 output2_id = XNN_INVALID_NODE_ID;
308 ASSERT_EQ(
309 xnn_status_success,
310 xnn_define_quantized_tensor_value(
311 subgraph, xnn_datatype_qint8, signed_zero_point, scale, output2_dims.size(), output2_dims.data(), nullptr, 2,
312 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output2_id));
313 ASSERT_NE(output2_id, XNN_INVALID_NODE_ID);
314
315 ASSERT_EQ(xnn_status_success, xnn_define_even_split2(subgraph, axis, input_id, output1_id, output2_id, /*flags=*/0));
316
317 xnn_runtime_t runtime = nullptr;
318 ASSERT_EQ(xnn_status_success, xnn_create_runtime_v3(subgraph, nullptr, nullptr, /*flags=*/0, &runtime));
319 ASSERT_NE(nullptr, runtime);
320 std::unique_ptr<xnn_runtime, decltype(&xnn_delete_runtime)> auto_runtime(runtime, xnn_delete_runtime);
321 std::array<xnn_external_value, 3> external = {
322 xnn_external_value{input_id, input.data()},
323 xnn_external_value{output1_id, subgraph_output1.data()},
324 xnn_external_value{output2_id, subgraph_output2.data()},
325 };
326 ASSERT_EQ(xnn_status_success, xnn_setup_runtime(runtime, external.size(), external.data()));
327 ASSERT_EQ(xnn_status_success, xnn_invoke_runtime(runtime));
328
329 ASSERT_EQ(subgraph_output1, operator_output1);
330 ASSERT_EQ(subgraph_output2, operator_output2);
331 }
332
TEST_F(EvenSplit2TestQU8,matches_operator_api)333 TEST_F(EvenSplit2TestQU8, matches_operator_api)
334 {
335 std::generate(input.begin(), input.end(), [&]() { return u8dist(rng); });
336 std::fill(operator_output1.begin(), operator_output1.end(), UINT8_C(0xA5));
337 std::fill(operator_output2.begin(), operator_output2.end(), UINT8_C(0xA5));
338 std::fill(subgraph_output1.begin(), subgraph_output1.end(), UINT8_C(0xA5));
339 std::fill(subgraph_output2.begin(), subgraph_output2.end(), UINT8_C(0xA5));
340
341 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
342
343 xnn_operator_t op1 = nullptr;
344 xnn_operator_t op2 = nullptr;
345
346 // Call operator API.
347 ASSERT_EQ(xnn_status_success, xnn_create_copy_nc_x8(channels, input_stride, channels, /*flags=*/0, &op1));
348 std::unique_ptr<xnn_operator, decltype(&xnn_delete_operator)> auto_op1(op1, xnn_delete_operator);
349 ASSERT_EQ(xnn_status_success, xnn_create_copy_nc_x8(channels, input_stride, channels, /*flags=*/0, &op2));
350 std::unique_ptr<xnn_operator, decltype(&xnn_delete_operator)> auto_op2(op2, xnn_delete_operator);
351
352 ASSERT_EQ(
353 xnn_status_success,
354 xnn_setup_copy_nc_x8(op1, batch_size, input.data(), operator_output1.data(), nullptr /* thread pool */));
355 ASSERT_EQ(
356 xnn_status_success,
357 xnn_setup_copy_nc_x8(
358 op2, batch_size, (uint8_t*) input.data() + op1->channels, operator_output2.data(), nullptr /* thread pool */));
359
360 ASSERT_EQ(xnn_status_success, xnn_run_operator(op1, nullptr /* thread pool */));
361 ASSERT_EQ(xnn_status_success, xnn_run_operator(op2, nullptr /* thread pool */));
362
363 // Call subgraph API.
364 xnn_subgraph_t subgraph = nullptr;
365 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/3, /*flags=*/0, &subgraph));
366 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
367
368 input_id = XNN_INVALID_NODE_ID;
369 ASSERT_EQ(
370 xnn_status_success,
371 xnn_define_quantized_tensor_value(
372 subgraph, xnn_datatype_quint8, unsigned_zero_point, scale, input_dims.size(), input_dims.data(), nullptr, 0,
373 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
374 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
375
376 output1_id = XNN_INVALID_NODE_ID;
377 ASSERT_EQ(
378 xnn_status_success,
379 xnn_define_quantized_tensor_value(
380 subgraph, xnn_datatype_quint8, unsigned_zero_point, scale, output1_dims.size(), output1_dims.data(), nullptr, 1,
381 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output1_id));
382 ASSERT_NE(output1_id, XNN_INVALID_NODE_ID);
383
384 output2_id = XNN_INVALID_NODE_ID;
385 ASSERT_EQ(
386 xnn_status_success,
387 xnn_define_quantized_tensor_value(
388 subgraph, xnn_datatype_quint8, unsigned_zero_point, scale, output2_dims.size(), output2_dims.data(), nullptr, 2,
389 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output2_id));
390 ASSERT_NE(output2_id, XNN_INVALID_NODE_ID);
391
392 ASSERT_EQ(xnn_status_success, xnn_define_even_split2(subgraph, axis, input_id, output1_id, output2_id, /*flags=*/0));
393
394 xnn_runtime_t runtime = nullptr;
395 ASSERT_EQ(xnn_status_success, xnn_create_runtime_v3(subgraph, nullptr, nullptr, /*flags=*/0, &runtime));
396 ASSERT_NE(nullptr, runtime);
397 std::unique_ptr<xnn_runtime, decltype(&xnn_delete_runtime)> auto_runtime(runtime, xnn_delete_runtime);
398 std::array<xnn_external_value, 3> external = {
399 xnn_external_value{input_id, input.data()},
400 xnn_external_value{output1_id, subgraph_output1.data()},
401 xnn_external_value{output2_id, subgraph_output2.data()},
402 };
403 ASSERT_EQ(xnn_status_success, xnn_setup_runtime(runtime, external.size(), external.data()));
404 ASSERT_EQ(xnn_status_success, xnn_invoke_runtime(runtime));
405
406 ASSERT_EQ(subgraph_output1, operator_output1);
407 ASSERT_EQ(subgraph_output2, operator_output2);
408 }
409
TEST_F(EvenSplit2TestF32,matches_operator_api)410 TEST_F(EvenSplit2TestF32, matches_operator_api)
411 {
412 std::generate(input.begin(), input.end(), [&]() { return f32dist(rng); });
413 std::fill(operator_output1.begin(), operator_output1.end(), std::nanf(""));
414 std::fill(operator_output2.begin(), operator_output2.end(), std::nanf(""));
415 std::fill(subgraph_output1.begin(), subgraph_output1.end(), std::nanf(""));
416 std::fill(subgraph_output2.begin(), subgraph_output2.end(), std::nanf(""));
417
418 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
419
420 xnn_operator_t op1 = nullptr;
421 xnn_operator_t op2 = nullptr;
422
423 // Call operator API.
424 ASSERT_EQ(xnn_status_success, xnn_create_copy_nc_x32(channels, input_stride, channels, /*flags=*/0, &op1));
425 std::unique_ptr<xnn_operator, decltype(&xnn_delete_operator)> auto_op1(op1, xnn_delete_operator);
426 ASSERT_EQ(xnn_status_success, xnn_create_copy_nc_x32(channels, input_stride, channels, /*flags=*/0, &op2));
427 std::unique_ptr<xnn_operator, decltype(&xnn_delete_operator)> auto_op2(op2, xnn_delete_operator);
428
429 ASSERT_EQ(
430 xnn_status_success,
431 xnn_setup_copy_nc_x32(op1, batch_size, input.data(), operator_output1.data(), nullptr /* thread pool */));
432 ASSERT_EQ(
433 xnn_status_success,
434 xnn_setup_copy_nc_x32(
435 op2, batch_size, (uint32_t*) input.data() + op1->channels, operator_output2.data(), nullptr /* thread pool */));
436
437 ASSERT_EQ(xnn_status_success, xnn_run_operator(op1, nullptr /* thread pool */));
438 ASSERT_EQ(xnn_status_success, xnn_run_operator(op2, nullptr /* thread pool */));
439
440 // Call subgraph API.
441 xnn_subgraph_t subgraph = nullptr;
442 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/3, /*flags=*/0, &subgraph));
443 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
444
445 input_id = XNN_INVALID_NODE_ID;
446 ASSERT_EQ(
447 xnn_status_success, xnn_define_tensor_value(
448 subgraph, xnn_datatype_fp32, input_dims.size(), input_dims.data(), nullptr, 0,
449 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
450 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
451
452 output1_id = XNN_INVALID_NODE_ID;
453 ASSERT_EQ(
454 xnn_status_success, xnn_define_tensor_value(
455 subgraph, xnn_datatype_fp32, output1_dims.size(), output1_dims.data(), nullptr, 1,
456 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output1_id));
457 ASSERT_NE(output1_id, XNN_INVALID_NODE_ID);
458
459 output2_id = XNN_INVALID_NODE_ID;
460 ASSERT_EQ(
461 xnn_status_success, xnn_define_tensor_value(
462 subgraph, xnn_datatype_fp32, output2_dims.size(), output2_dims.data(), nullptr, 2,
463 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output2_id));
464 ASSERT_NE(output2_id, XNN_INVALID_NODE_ID);
465
466 ASSERT_EQ(xnn_status_success, xnn_define_even_split2(subgraph, axis, input_id, output1_id, output2_id, /*flags=*/0));
467
468 xnn_runtime_t runtime = nullptr;
469 ASSERT_EQ(xnn_status_success, xnn_create_runtime_v3(subgraph, nullptr, nullptr, /*flags=*/0, &runtime));
470 ASSERT_NE(nullptr, runtime);
471 std::unique_ptr<xnn_runtime, decltype(&xnn_delete_runtime)> auto_runtime(runtime, xnn_delete_runtime);
472 std::array<xnn_external_value, 3> external = {
473 xnn_external_value{input_id, input.data()},
474 xnn_external_value{output1_id, subgraph_output1.data()},
475 xnn_external_value{output2_id, subgraph_output2.data()},
476 };
477 ASSERT_EQ(xnn_status_success, xnn_setup_runtime(runtime, external.size(), external.data()));
478 ASSERT_EQ(xnn_status_success, xnn_invoke_runtime(runtime));
479
480 ASSERT_EQ(subgraph_output1, operator_output1);
481 ASSERT_EQ(subgraph_output2, operator_output2);
482 }
483