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 <random>
13
14 #include <xnnpack.h>
15 #include <xnnpack/node-type.h>
16 #include <xnnpack/operator.h>
17 #include <xnnpack/subgraph.h>
18
19 #include <gtest/gtest.h>
20
21 namespace {
compute_output_dimension(size_t padded_input_dimension,size_t kernel_dimension)22 inline size_t compute_output_dimension(size_t padded_input_dimension, size_t kernel_dimension)
23 {
24 return padded_input_dimension / kernel_dimension;
25 }
26 } // namespace
27
28 class ArgmaxPoolingTestF32 : public ::testing::Test {
29 protected:
ArgmaxPoolingTestF32()30 ArgmaxPoolingTestF32()
31 {
32 random_device = std::unique_ptr<std::random_device>(new std::random_device());
33 rng = std::mt19937((*random_device)());
34 input_size_dist = std::uniform_int_distribution<uint32_t>(10, 15);
35 pooling_size_dist = std::uniform_int_distribution<uint32_t>(2, 5);
36 batch_size = input_size_dist(rng);
37 input_height = input_size_dist(rng);
38 input_width = input_size_dist(rng);
39 channels = input_size_dist(rng);
40 pooling_height = pooling_size_dist(rng);
41 pooling_width = pooling_size_dist(rng);
42 input_padding_top = input_size_dist(rng);
43 input_padding_right = input_size_dist(rng);
44 input_padding_bottom = input_size_dist(rng);
45 input_padding_left = input_size_dist(rng);
46 output_height = compute_output_dimension(input_height + input_padding_top + input_padding_bottom, pooling_height);
47 output_width = compute_output_dimension(input_width + input_padding_left + input_padding_right, pooling_width);
48 input_dims = {batch_size, input_height, input_width, channels};
49 output_dims = {batch_size, output_height, output_width, channels};
50 input = std::vector<float>(XNN_EXTRA_BYTES / sizeof(float) + batch_size * input_height * input_width * channels);
51 operator_output = std::vector<float>(batch_size * output_height * output_width * channels);
52 operator_output_index = std::vector<uint32_t>(batch_size * output_height * output_width * channels);
53 subgraph_output = std::vector<float>(batch_size * output_height * output_width * channels);
54 subgraph_output_index = std::vector<uint32_t>(batch_size * output_height * output_width * channels);
55 }
56
57 std::unique_ptr<std::random_device> random_device;
58 std::mt19937 rng;
59 std::uniform_int_distribution<uint32_t> input_size_dist;
60 std::uniform_int_distribution<uint32_t> pooling_size_dist;
61 uint32_t batch_size;
62 uint32_t input_height;
63 uint32_t input_width;
64 uint32_t channels;
65 uint32_t pooling_height;
66 uint32_t pooling_width;
67 uint32_t output_height;
68 uint32_t output_width;
69 std::array<size_t, 4> input_dims;
70 std::array<size_t, 4> output_dims;
71 uint32_t input_padding_top;
72 uint32_t input_padding_right;
73 uint32_t input_padding_bottom;
74 uint32_t input_padding_left;
75
76 uint32_t input_id;
77 uint32_t output_value_id;
78 uint32_t output_index_id;
79
80 std::vector<float> input;
81 std::vector<float> operator_output;
82 std::vector<uint32_t> operator_output_index;
83 std::vector<float> subgraph_output;
84 std::vector<uint32_t> subgraph_output_index;
85 };
86
TEST_F(ArgmaxPoolingTestF32,define)87 TEST_F(ArgmaxPoolingTestF32, define)
88 {
89
90 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
91
92 xnn_subgraph_t subgraph = nullptr;
93 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/3, /*flags=*/0, &subgraph));
94 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
95
96 input_id = XNN_INVALID_NODE_ID;
97 ASSERT_EQ(
98 xnn_status_success, xnn_define_tensor_value(
99 subgraph, xnn_datatype_fp32, input_dims.size(), input_dims.data(), nullptr, 0,
100 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
101 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
102
103 output_value_id = XNN_INVALID_NODE_ID;
104 ASSERT_EQ(
105 xnn_status_success, xnn_define_tensor_value(
106 subgraph, xnn_datatype_fp32, output_dims.size(), output_dims.data(), nullptr, 1,
107 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output_value_id));
108 ASSERT_NE(output_value_id, XNN_INVALID_NODE_ID);
109
110 output_index_id = XNN_INVALID_NODE_ID;
111 ASSERT_EQ(
112 xnn_status_success, xnn_define_tensor_value(
113 subgraph, xnn_datatype_fp32, output_dims.size(), output_dims.data(), nullptr, 2,
114 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output_index_id));
115 ASSERT_NE(output_index_id, XNN_INVALID_NODE_ID);
116
117 ASSERT_EQ(
118 xnn_status_success, xnn_define_argmax_pooling_2d(
119 subgraph, input_padding_top, input_padding_right, input_padding_bottom, input_padding_left,
120 pooling_height, pooling_width, input_id, output_value_id, output_index_id,
121 /*flags=*/0));
122
123 ASSERT_EQ(subgraph->num_nodes, 1);
124 const struct xnn_node* node = &subgraph->nodes[0];
125 ASSERT_EQ(node->type, xnn_node_type_argmax_pooling_2d);
126 ASSERT_EQ(node->compute_type, xnn_compute_type_fp32);
127 ASSERT_EQ(node->params.pooling_2d.padding_top, input_padding_top);
128 ASSERT_EQ(node->params.pooling_2d.padding_right, input_padding_right);
129 ASSERT_EQ(node->params.pooling_2d.padding_bottom, input_padding_bottom);
130 ASSERT_EQ(node->params.pooling_2d.padding_left, input_padding_left);
131 ASSERT_EQ(node->params.pooling_2d.pooling_height, pooling_height);
132 ASSERT_EQ(node->params.pooling_2d.pooling_width, pooling_width);
133 ASSERT_EQ(node->num_inputs, 1);
134 ASSERT_EQ(node->inputs[0], input_id);
135 ASSERT_EQ(node->num_outputs, 2);
136 ASSERT_EQ(node->outputs[0], output_value_id);
137 ASSERT_EQ(node->outputs[1], output_index_id);
138 ASSERT_EQ(node->flags, 0);
139 }
140
TEST_F(ArgmaxPoolingTestF32,matches_operator_api)141 TEST_F(ArgmaxPoolingTestF32, matches_operator_api)
142 {
143 std::uniform_real_distribution<float> f32dist(-255.0f, 255.0f);
144 std::generate(input.begin(), input.end(), [&]() { return f32dist(rng); });
145 std::fill(operator_output.begin(), operator_output.end(), nanf(""));
146 std::fill(subgraph_output.begin(), subgraph_output.end(), nanf(""));
147
148 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
149
150 // Call operator API.
151 xnn_operator_t op = nullptr;
152 const xnn_status status = xnn_create_argmax_pooling2d_nhwc_f32(
153 input_padding_top, input_padding_right, input_padding_bottom, input_padding_left, pooling_height, pooling_width,
154 channels, channels, channels, /*flags=*/0, &op);
155 if (status == xnn_status_unsupported_hardware) {
156 GTEST_SKIP();
157 }
158
159 ASSERT_EQ(xnn_status_success, status);
160 ASSERT_NE(nullptr, op);
161 std::unique_ptr<xnn_operator, decltype(&xnn_delete_operator)> auto_op(op, xnn_delete_operator);
162
163 ASSERT_EQ(
164 xnn_status_success, xnn_setup_argmax_pooling2d_nhwc_f32(
165 op, batch_size, input_height, input_width, input.data(), operator_output.data(),
166 operator_output_index.data(), /*threadpool=*/nullptr));
167
168 ASSERT_EQ(xnn_status_success, xnn_run_operator(op, /*threadpool=*/nullptr));
169
170 // Call subgraph API.
171 xnn_subgraph_t subgraph = nullptr;
172 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/3, /*flags=*/0, &subgraph));
173 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
174 input_id = XNN_INVALID_NODE_ID;
175 ASSERT_EQ(
176 xnn_status_success, xnn_define_tensor_value(
177 subgraph, xnn_datatype_fp32, input_dims.size(), input_dims.data(), nullptr, /*external_id=*/0,
178 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
179 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
180
181 output_value_id = XNN_INVALID_NODE_ID;
182 ASSERT_EQ(
183 xnn_status_success,
184 xnn_define_tensor_value(
185 subgraph, xnn_datatype_fp32, output_dims.size(), output_dims.data(), nullptr, /*external_id=*/1,
186 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output_value_id));
187 ASSERT_NE(output_value_id, XNN_INVALID_NODE_ID);
188
189 output_index_id = XNN_INVALID_NODE_ID;
190 ASSERT_EQ(
191 xnn_status_success,
192 xnn_define_tensor_value(
193 subgraph, xnn_datatype_fp32, output_dims.size(), output_dims.data(), nullptr, /*external_id=*/2,
194 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output_index_id));
195 ASSERT_NE(output_index_id, XNN_INVALID_NODE_ID);
196
197 xnn_runtime_t runtime = nullptr;
198 ASSERT_EQ(
199 xnn_status_success, xnn_define_argmax_pooling_2d(
200 subgraph, input_padding_top, input_padding_right, input_padding_bottom, input_padding_left,
201 pooling_height, pooling_width, input_id, output_value_id, output_index_id,
202 /*flags=*/0));
203 ASSERT_EQ(xnn_status_success, xnn_create_runtime_v3(subgraph, nullptr, nullptr, /*flags=*/0, &runtime));
204 ASSERT_NE(nullptr, runtime);
205 std::unique_ptr<xnn_runtime, decltype(&xnn_delete_runtime)> auto_runtime(runtime, xnn_delete_runtime);
206 std::array<xnn_external_value, 3> external = {
207 xnn_external_value{input_id, input.data()}, xnn_external_value{output_value_id, subgraph_output.data()},
208 xnn_external_value{output_index_id, subgraph_output_index.data()}};
209 ASSERT_EQ(xnn_status_success, xnn_setup_runtime(runtime, external.size(), external.data()));
210 ASSERT_EQ(xnn_status_success, xnn_invoke_runtime(runtime));
211
212 ASSERT_EQ(subgraph_output, operator_output);
213 }
214