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 class AveragePoolingTestF32 : public ::testing::Test {
22 protected:
AveragePoolingTestF32()23 AveragePoolingTestF32()
24 {
25 random_device = std::unique_ptr<std::random_device>(new std::random_device());
26 rng = std::mt19937((*random_device)());
27 input_size_dist = std::uniform_int_distribution<uint32_t>(10, 15);
28 pooling_size_dist = std::uniform_int_distribution<uint32_t>(2, 5);
29 stride_dist = std::uniform_int_distribution<uint32_t>(1, 2);
30 batch_size = input_size_dist(rng);
31 input_height = input_size_dist(rng);
32 input_width = input_size_dist(rng);
33 channels = input_size_dist(rng);
34 pooling_height = pooling_size_dist(rng);
35 pooling_width = pooling_size_dist(rng);
36 // Avoid padding == pooling dimension because it will result in NaNs and cause comparison to fail.
37 input_padding_top = std::uniform_int_distribution<uint32_t>(0, pooling_height - 1)(rng);
38 input_padding_right = std::uniform_int_distribution<uint32_t>(0, pooling_width - 1)(rng);
39 input_padding_bottom = std::uniform_int_distribution<uint32_t>(0, pooling_height - 1)(rng);
40 input_padding_left = std::uniform_int_distribution<uint32_t>(0, pooling_width - 1)(rng);
41 stride_height = stride_dist(rng);
42 stride_width = stride_dist(rng);
43 output_height = xnn_compute_convolution_output_dimension(
44 input_padding_top + input_height + input_padding_bottom, pooling_height, 1, stride_height);
45 output_width = xnn_compute_convolution_output_dimension(
46 input_padding_left + input_width + input_padding_right, pooling_width, 1, stride_width);
47 output_min = std::uniform_real_distribution<float>(-255.0f, 0.0f)(rng);
48 output_max = std::uniform_real_distribution<float>(0.1f, 255.0f)(rng);
49 input_dims = {batch_size, input_height, input_width, channels};
50 output_dims = {batch_size, output_height, output_width, channels};
51 input = std::vector<float>(XNN_EXTRA_BYTES / sizeof(float) + batch_size * input_height * input_width * channels);
52 operator_output = std::vector<float>(batch_size * output_height * output_width * channels);
53 subgraph_output = std::vector<float>(batch_size * output_height * output_width * channels);
54 }
55
56 std::unique_ptr<std::random_device> random_device;
57 std::mt19937 rng;
58 std::uniform_int_distribution<uint32_t> input_size_dist;
59 std::uniform_int_distribution<uint32_t> pooling_size_dist;
60 std::uniform_int_distribution<uint32_t> stride_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 uint32_t stride_height;
70 uint32_t stride_width;
71 std::array<size_t, 4> input_dims;
72 std::array<size_t, 4> output_dims;
73 uint32_t input_padding_top;
74 uint32_t input_padding_right;
75 uint32_t input_padding_bottom;
76 uint32_t input_padding_left;
77 float output_min;
78 float output_max;
79
80 uint32_t input_id;
81 uint32_t output_id;
82
83 std::vector<float> input;
84 std::vector<float> operator_output;
85 std::vector<float> subgraph_output;
86 };
87
TEST_F(AveragePoolingTestF32,define)88 TEST_F(AveragePoolingTestF32, define)
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=*/2, /*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_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_id));
108 ASSERT_NE(output_id, XNN_INVALID_NODE_ID);
109
110 ASSERT_EQ(
111 xnn_status_success,
112 xnn_define_average_pooling_2d(
113 subgraph, input_padding_top, input_padding_right, input_padding_bottom, input_padding_left, pooling_height,
114 pooling_width, stride_height, stride_width, output_min, output_max, input_id, output_id,
115 /*flags=*/0));
116
117 ASSERT_EQ(subgraph->num_nodes, 1);
118 const struct xnn_node* node = &subgraph->nodes[0];
119 ASSERT_EQ(node->type, xnn_node_type_average_pooling_2d);
120 ASSERT_EQ(node->compute_type, xnn_compute_type_fp32);
121
122 ASSERT_EQ(node->params.pooling_2d.padding_top, input_padding_top);
123 ASSERT_EQ(node->params.pooling_2d.padding_right, input_padding_right);
124 ASSERT_EQ(node->params.pooling_2d.padding_bottom, input_padding_bottom);
125 ASSERT_EQ(node->params.pooling_2d.padding_left, input_padding_left);
126 ASSERT_EQ(node->params.pooling_2d.pooling_height, pooling_height);
127 ASSERT_EQ(node->params.pooling_2d.pooling_width, pooling_width);
128 ASSERT_EQ(node->params.pooling_2d.stride_height, stride_height);
129 ASSERT_EQ(node->params.pooling_2d.stride_width, stride_width);
130 ASSERT_EQ(node->activation.output_min, output_min);
131 ASSERT_EQ(node->activation.output_max, output_max);
132 ASSERT_EQ(node->num_inputs, 1);
133 ASSERT_EQ(node->inputs[0], input_id);
134 ASSERT_EQ(node->num_outputs, 1);
135 ASSERT_EQ(node->outputs[0], output_id);
136 ASSERT_EQ(node->flags, 0);
137 }
138
TEST_F(AveragePoolingTestF32,matches_operator_api)139 TEST_F(AveragePoolingTestF32, matches_operator_api)
140 {
141 std::uniform_real_distribution<float> f32dist;
142 std::generate(input.begin(), input.end(), [&]() { return f32dist(rng); });
143 std::fill(operator_output.begin(), operator_output.end(), nanf(""));
144 std::fill(subgraph_output.begin(), subgraph_output.end(), nanf(""));
145
146 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
147
148 // Call operator API.
149 xnn_operator_t op = nullptr;
150 const xnn_status status = xnn_create_average_pooling2d_nhwc_f32(
151 input_padding_top, input_padding_right, input_padding_bottom, input_padding_left, pooling_height, pooling_width,
152 stride_height, stride_width, channels, channels, channels, output_min, output_max, /*flags=*/0, &op);
153 if (status == xnn_status_unsupported_hardware) {
154 GTEST_SKIP();
155 }
156
157 ASSERT_EQ(xnn_status_success, status);
158 ASSERT_NE(nullptr, op);
159 std::unique_ptr<xnn_operator, decltype(&xnn_delete_operator)> auto_op(op, xnn_delete_operator);
160
161 ASSERT_EQ(
162 xnn_status_success, xnn_setup_average_pooling2d_nhwc_f32(
163 op, batch_size, input_height, input_width, input.data(), operator_output.data(),
164 /*threadpool=*/nullptr));
165
166 ASSERT_EQ(xnn_status_success, xnn_run_operator(op, /*threadpool=*/nullptr));
167
168 // Call subgraph API.
169 xnn_subgraph_t subgraph = nullptr;
170 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/2, /*flags=*/0, &subgraph));
171 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
172 input_id = XNN_INVALID_NODE_ID;
173 ASSERT_EQ(
174 xnn_status_success, xnn_define_tensor_value(
175 subgraph, xnn_datatype_fp32, input_dims.size(), input_dims.data(), nullptr, /*external_id=*/0,
176 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
177 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
178
179 output_id = XNN_INVALID_NODE_ID;
180 ASSERT_EQ(
181 xnn_status_success,
182 xnn_define_tensor_value(
183 subgraph, xnn_datatype_fp32, output_dims.size(), output_dims.data(), nullptr, /*external_id=*/1,
184 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output_id));
185 ASSERT_NE(output_id, XNN_INVALID_NODE_ID);
186
187 xnn_runtime_t runtime = nullptr;
188 ASSERT_EQ(
189 xnn_status_success,
190 xnn_define_average_pooling_2d(
191 subgraph, input_padding_top, input_padding_right, input_padding_bottom, input_padding_left, pooling_height,
192 pooling_width, stride_height, stride_width, output_min, output_max, input_id, output_id,
193 /*flags=*/0));
194 ASSERT_EQ(xnn_status_success, xnn_create_runtime_v3(subgraph, nullptr, nullptr, /*flags=*/0, &runtime));
195 ASSERT_NE(nullptr, runtime);
196 std::unique_ptr<xnn_runtime, decltype(&xnn_delete_runtime)> auto_runtime(runtime, xnn_delete_runtime);
197 std::array<xnn_external_value, 2> external = {
198 xnn_external_value{input_id, input.data()}, xnn_external_value{output_id, subgraph_output.data()}};
199 ASSERT_EQ(xnn_status_success, xnn_setup_runtime(runtime, external.size(), external.data()));
200 ASSERT_EQ(xnn_status_success, xnn_invoke_runtime(runtime));
201
202 ASSERT_EQ(subgraph_output, operator_output);
203 }
204