1 // Copyright 2020 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 <math.h>
7 #include <stddef.h>
8 #include <stdint.h>
9
10 #include <xnnpack.h>
11 #include <xnnpack/log.h>
12 #include <xnnpack/params.h>
13 #include <xnnpack/subgraph.h>
14
15
create_average_pooling_operator(const struct xnn_node * node,const struct xnn_value * values,size_t num_values,struct xnn_operator_data * opdata)16 static enum xnn_status create_average_pooling_operator(
17 const struct xnn_node* node,
18 const struct xnn_value* values,
19 size_t num_values,
20 struct xnn_operator_data* opdata)
21 {
22 assert(node->compute_type == xnn_compute_type_fp32);
23
24 assert(node->num_inputs == 1);
25 const uint32_t input_id = node->inputs[0];
26 assert(input_id != XNN_INVALID_VALUE_ID);
27 assert(input_id < num_values);
28
29 assert(node->num_outputs == 1);
30 const uint32_t output_id = node->outputs[0];
31 assert(output_id != XNN_INVALID_VALUE_ID);
32 assert(output_id < num_values);
33
34 const size_t channel_dim = values[input_id].shape.dim[3];
35 assert(channel_dim == values[output_id].shape.dim[3]);
36
37 const enum xnn_status status = xnn_create_average_pooling2d_nhwc_f32(
38 node->params.pooling_2d.padding_top,
39 node->params.pooling_2d.padding_right,
40 node->params.pooling_2d.padding_bottom,
41 node->params.pooling_2d.padding_left,
42 node->params.pooling_2d.pooling_height,
43 node->params.pooling_2d.pooling_width,
44 node->params.pooling_2d.stride_height,
45 node->params.pooling_2d.stride_width,
46 channel_dim /* channels */, channel_dim /* input stride */, channel_dim /* output stride */,
47 node->activation.output_min,
48 node->activation.output_max,
49 node->flags,
50 &opdata->operator_object);
51 if (status == xnn_status_success) {
52 opdata->batch_size = values[input_id].shape.dim[0];
53 opdata->input_height = values[input_id].shape.dim[1];
54 opdata->input_width = values[input_id].shape.dim[2];
55 opdata->inputs[0] = input_id;
56 opdata->outputs[0] = output_id;
57 }
58 return status;
59 }
60
setup_average_pooling_operator(const struct xnn_operator_data * opdata,const struct xnn_blob * blobs,size_t num_blobs,pthreadpool_t threadpool)61 static enum xnn_status setup_average_pooling_operator(
62 const struct xnn_operator_data* opdata,
63 const struct xnn_blob* blobs,
64 size_t num_blobs,
65 pthreadpool_t threadpool)
66 {
67 const uint32_t input_id = opdata->inputs[0];
68 assert(input_id != XNN_INVALID_VALUE_ID);
69 assert(input_id < num_blobs);
70
71 const uint32_t output_id = opdata->outputs[0];
72 assert(output_id != XNN_INVALID_VALUE_ID);
73 assert(output_id < num_blobs);
74
75 const struct xnn_blob* input_blob = blobs + input_id;
76 const void* input_data = input_blob->data;
77 assert(input_data != NULL);
78
79 const struct xnn_blob* output_blob = blobs + output_id;
80 void* output_data = output_blob->data;
81 assert(output_data != NULL);
82
83 return xnn_setup_average_pooling2d_nhwc_f32(
84 opdata->operator_object,
85 opdata->batch_size,
86 opdata->input_height,
87 opdata->input_width,
88 input_data,
89 output_data,
90 threadpool);
91 }
92
xnn_define_average_pooling_2d(xnn_subgraph_t subgraph,uint32_t input_padding_top,uint32_t input_padding_right,uint32_t input_padding_bottom,uint32_t input_padding_left,uint32_t pooling_height,uint32_t pooling_width,uint32_t stride_height,uint32_t stride_width,float output_min,float output_max,uint32_t input_id,uint32_t output_id,uint32_t flags)93 enum xnn_status xnn_define_average_pooling_2d(
94 xnn_subgraph_t subgraph,
95 uint32_t input_padding_top,
96 uint32_t input_padding_right,
97 uint32_t input_padding_bottom,
98 uint32_t input_padding_left,
99 uint32_t pooling_height,
100 uint32_t pooling_width,
101 uint32_t stride_height,
102 uint32_t stride_width,
103 float output_min,
104 float output_max,
105 uint32_t input_id,
106 uint32_t output_id,
107 uint32_t flags)
108 {
109 if ((xnn_params.init_flags & XNN_INIT_FLAG_XNNPACK) == 0) {
110 xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
111 xnn_node_type_to_string(xnn_node_type_average_pooling_2d));
112 return xnn_status_uninitialized;
113 }
114
115 const uint32_t pooling_size = pooling_height * pooling_width;
116 if (pooling_size == 0) {
117 xnn_log_error(
118 "failed to define %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
119 "pooling size dimensions must be non-zero",
120 xnn_node_type_to_string(xnn_node_type_average_pooling_2d), pooling_width, pooling_height);
121 return xnn_status_invalid_parameter;
122 }
123
124 if (pooling_size == 1) {
125 xnn_log_error(
126 "failed to define %s operator with 1 pooling element: 1x1 pooling is meaningless",
127 xnn_node_type_to_string(xnn_node_type_average_pooling_2d));
128 return xnn_status_invalid_parameter;
129 }
130
131 if (stride_height == 0 || stride_width == 0) {
132 xnn_log_error(
133 "failed to define %s operator with %" PRIu32 "x%" PRIu32 " stride: "
134 "stride dimensions must be non-zero",
135 xnn_node_type_to_string(xnn_node_type_average_pooling_2d), stride_width, stride_height);
136 return xnn_status_invalid_parameter;
137 }
138
139 if (isnan(output_min)) {
140 xnn_log_error(
141 "failed to define %s operator with NaN output lower bound: lower bound must be non-NaN",
142 xnn_node_type_to_string(xnn_node_type_average_pooling_2d));
143 return xnn_status_invalid_parameter;
144 }
145
146 if (isnan(output_max)) {
147 xnn_log_error(
148 "failed to define %s operator with NaN output upper bound: upper bound must be non-NaN",
149 xnn_node_type_to_string(xnn_node_type_average_pooling_2d));
150 return xnn_status_invalid_parameter;
151 }
152
153 if (output_min >= output_max) {
154 xnn_log_error(
155 "failed to define %s operator with [%.7g, %.7g] output range: lower bound must be below upper bound",
156 xnn_node_type_to_string(xnn_node_type_average_pooling_2d), output_min, output_max);
157 return xnn_status_invalid_parameter;
158 }
159
160 const bool any_padding = (input_padding_left | input_padding_top | input_padding_right | input_padding_bottom) != 0;
161 if ((flags & XNN_FLAG_TENSORFLOW_SAME_PADDING) != 0) {
162 if (any_padding) {
163 xnn_log_error(
164 "failed to define %s operator with %" PRIu32 "+%" PRIu32 "x%" PRIu32 "+%" PRIu32" padding: "
165 "TensorFlow SAME padding can't be combined with explicit padding specification",
166 xnn_node_type_to_string(xnn_node_type_average_pooling_2d),
167 input_padding_top, input_padding_left, input_padding_bottom, input_padding_right);
168 return xnn_status_invalid_parameter;
169 }
170 }
171
172 if (input_id >= subgraph->num_values) {
173 xnn_log_error(
174 "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
175 xnn_node_type_to_string(xnn_node_type_average_pooling_2d), input_id);
176 return xnn_status_invalid_parameter;
177 }
178
179 const struct xnn_value* input_value = &subgraph->values[input_id];
180 if (input_value->type != xnn_value_type_dense_tensor) {
181 xnn_log_error(
182 "failed to define %s operator with input ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
183 xnn_node_type_to_string(xnn_node_type_average_pooling_2d), input_id, input_value->type);
184 return xnn_status_invalid_parameter;
185 }
186
187 switch (input_value->datatype) {
188 case xnn_datatype_fp32:
189 break;
190 default:
191 xnn_log_error(
192 "failed to define %s operator with input ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
193 xnn_node_type_to_string(xnn_node_type_average_pooling_2d), input_id,
194 xnn_datatype_to_string(input_value->datatype), input_value->datatype);
195 return xnn_status_invalid_parameter;
196 }
197
198 if (output_id >= subgraph->num_values) {
199 xnn_log_error(
200 "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
201 xnn_node_type_to_string(xnn_node_type_average_pooling_2d), output_id);
202 return xnn_status_invalid_parameter;
203 }
204
205 const struct xnn_value* output_value = &subgraph->values[output_id];
206 if (output_value->type != xnn_value_type_dense_tensor) {
207 xnn_log_error(
208 "failed to define %s operator with output ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
209 xnn_node_type_to_string(xnn_node_type_average_pooling_2d), output_id, output_value->type);
210 return xnn_status_invalid_parameter;
211 }
212
213 switch (output_value->datatype) {
214 case xnn_datatype_fp32:
215 break;
216 default:
217 xnn_log_error(
218 "failed to define %s operator with output ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
219 xnn_node_type_to_string(xnn_node_type_average_pooling_2d), output_id,
220 xnn_datatype_to_string(output_value->datatype), output_value->datatype);
221 return xnn_status_invalid_parameter;
222 }
223
224 struct xnn_node* node = xnn_subgraph_new_node(subgraph);
225 if (node == NULL) {
226 return xnn_status_out_of_memory;
227 }
228
229 node->type = xnn_node_type_average_pooling_2d;
230 node->compute_type = xnn_compute_type_fp32;
231 node->params.pooling_2d.padding_top = input_padding_top;
232 node->params.pooling_2d.padding_right = input_padding_right;
233 node->params.pooling_2d.padding_bottom = input_padding_bottom;
234 node->params.pooling_2d.padding_left = input_padding_left;
235 node->params.pooling_2d.pooling_height = pooling_height;
236 node->params.pooling_2d.pooling_width = pooling_width;
237 node->params.pooling_2d.stride_height = stride_height;
238 node->params.pooling_2d.stride_width = stride_width;
239 node->activation.output_min = output_min;
240 node->activation.output_max = output_max;
241 node->num_inputs = 1;
242 node->inputs[0] = input_id;
243 node->num_outputs = 1;
244 node->outputs[0] = output_id;
245 node->flags = flags;
246
247 node->create = create_average_pooling_operator;
248 node->setup = setup_average_pooling_operator;
249
250 return xnn_status_success;
251 }
252