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_argmax_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_argmax_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 == 2);
30 const uint32_t output_value_id = node->outputs[0];
31 assert(output_value_id != XNN_INVALID_VALUE_ID);
32 assert(output_value_id < num_values);
33 const uint32_t output_index_id = node->outputs[1];
34 assert(output_index_id != XNN_INVALID_VALUE_ID);
35 assert(output_index_id < num_values);
36
37 const size_t channel_dim = values[input_id].shape.dim[3];
38 assert(channel_dim == values[output_value_id].shape.dim[3]);
39 assert(channel_dim == values[output_index_id].shape.dim[3]);
40
41 const enum xnn_status status = xnn_create_argmax_pooling2d_nhwc_f32(
42 node->params.pooling_2d.padding_top,
43 node->params.pooling_2d.padding_right,
44 node->params.pooling_2d.padding_bottom,
45 node->params.pooling_2d.padding_left,
46 node->params.pooling_2d.pooling_height,
47 node->params.pooling_2d.pooling_width,
48 channel_dim /* channels */, channel_dim /* input stride */, channel_dim /* output stride */,
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_value_id;
57 opdata->outputs[1] = output_index_id;
58 }
59 return status;
60 }
61
setup_argmax_pooling_operator(const struct xnn_operator_data * opdata,const struct xnn_blob * blobs,size_t num_blobs,pthreadpool_t threadpool)62 static enum xnn_status setup_argmax_pooling_operator(
63 const struct xnn_operator_data* opdata,
64 const struct xnn_blob* blobs,
65 size_t num_blobs,
66 pthreadpool_t threadpool)
67 {
68 const uint32_t input_id = opdata->inputs[0];
69 assert(input_id != XNN_INVALID_VALUE_ID);
70 assert(input_id < num_blobs);
71
72 const uint32_t output_value_id = opdata->outputs[0];
73 assert(output_value_id != XNN_INVALID_VALUE_ID);
74 assert(output_value_id < num_blobs);
75
76 const uint32_t output_index_id = opdata->outputs[1];
77 assert(output_index_id != XNN_INVALID_VALUE_ID);
78 assert(output_index_id < num_blobs);
79
80 const struct xnn_blob* input_blob = blobs + input_id;
81 const void* input_data = input_blob->data;
82 assert(input_data != NULL);
83
84 const struct xnn_blob* output_value_blob = blobs + output_value_id;
85 void* output_value_data = output_value_blob->data;
86 assert(output_value_data != NULL);
87
88 const struct xnn_blob* output_index_blob = blobs + output_index_id;
89 void* output_index_data = output_index_blob->data;
90 assert(output_index_data != NULL);
91
92 return xnn_setup_argmax_pooling2d_nhwc_f32(
93 opdata->operator_object,
94 opdata->batch_size,
95 opdata->input_height,
96 opdata->input_width,
97 input_data,
98 output_value_data,
99 output_index_data,
100 threadpool);
101 }
102
xnn_define_argmax_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 input_id,uint32_t output_value_id,uint32_t output_index_id,uint32_t flags)103 enum xnn_status xnn_define_argmax_pooling_2d(
104 xnn_subgraph_t subgraph,
105 uint32_t input_padding_top,
106 uint32_t input_padding_right,
107 uint32_t input_padding_bottom,
108 uint32_t input_padding_left,
109 uint32_t pooling_height,
110 uint32_t pooling_width,
111 uint32_t input_id,
112 uint32_t output_value_id,
113 uint32_t output_index_id,
114 uint32_t flags)
115 {
116 if ((xnn_params.init_flags & XNN_INIT_FLAG_XNNPACK) == 0) {
117 xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
118 xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d));
119 return xnn_status_uninitialized;
120 }
121
122 const uint32_t pooling_size = pooling_height * pooling_width;
123 if (pooling_size == 0) {
124 xnn_log_error(
125 "failed to define %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
126 "pooling size dimensions must be non-zero",
127 xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), pooling_width, pooling_height);
128 return xnn_status_invalid_parameter;
129 }
130
131 if (pooling_size == 1) {
132 xnn_log_error(
133 "failed to define %s operator with 1 pooling element: 1x1 pooling is meaningless",
134 xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d));
135 return xnn_status_invalid_parameter;
136 }
137
138 if (input_id >= subgraph->num_values) {
139 xnn_log_error(
140 "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
141 xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), input_id);
142 return xnn_status_invalid_parameter;
143 }
144
145 const struct xnn_value* input_value = &subgraph->values[input_id];
146 if (input_value->type != xnn_value_type_dense_tensor) {
147 xnn_log_error(
148 "failed to define %s operator with input ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
149 xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), input_id, input_value->type);
150 return xnn_status_invalid_parameter;
151 }
152
153 switch (input_value->datatype) {
154 case xnn_datatype_fp32:
155 break;
156 default:
157 xnn_log_error(
158 "failed to define %s operator with input ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
159 xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), input_id,
160 xnn_datatype_to_string(input_value->datatype), input_value->datatype);
161 return xnn_status_invalid_parameter;
162 }
163
164 if (output_value_id >= subgraph->num_values) {
165 xnn_log_error(
166 "failed to define %s operator with output value ID #%" PRIu32 ": invalid Value ID",
167 xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), output_value_id);
168 return xnn_status_invalid_parameter;
169 }
170
171 const struct xnn_value* output_value_value = &subgraph->values[output_value_id];
172 if (output_value_value->type != xnn_value_type_dense_tensor) {
173 xnn_log_error(
174 "failed to define %s operator with output value ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
175 xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), output_value_id, output_value_value->type);
176 return xnn_status_invalid_parameter;
177 }
178
179 switch (output_value_value->datatype) {
180 case xnn_datatype_fp32:
181 break;
182 default:
183 xnn_log_error(
184 "failed to define %s operator with output value ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
185 xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), output_value_id,
186 xnn_datatype_to_string(output_value_value->datatype), output_value_value->datatype);
187 return xnn_status_invalid_parameter;
188 }
189
190 if (output_index_id >= subgraph->num_values) {
191 xnn_log_error(
192 "failed to define %s operator with output index ID #%" PRIu32 ": invalid Value ID",
193 xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), output_index_id);
194 return xnn_status_invalid_parameter;
195 }
196
197 const struct xnn_value* output_index_value = &subgraph->values[output_index_id];
198 if (output_index_value->type != xnn_value_type_dense_tensor) {
199 xnn_log_error(
200 "failed to define %s operator with output index ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
201 xnn_node_type_to_string(xnn_node_type_argmax_pooling_2d), output_index_id, output_index_value->type);
202 return xnn_status_invalid_parameter;
203 }
204
205 struct xnn_node* node = xnn_subgraph_new_node(subgraph);
206 if (node == NULL) {
207 return xnn_status_out_of_memory;
208 }
209
210 node->type = xnn_node_type_argmax_pooling_2d;
211 node->compute_type = xnn_compute_type_fp32;
212 node->params.pooling_2d.padding_top = input_padding_top;
213 node->params.pooling_2d.padding_right = input_padding_right;
214 node->params.pooling_2d.padding_bottom = input_padding_bottom;
215 node->params.pooling_2d.padding_left = input_padding_left;
216 node->params.pooling_2d.pooling_height = pooling_height;
217 node->params.pooling_2d.pooling_width = pooling_width;
218 node->num_inputs = 1;
219 node->inputs[0] = input_id;
220 node->num_outputs = 2;
221 node->outputs[0] = output_value_id;
222 node->outputs[1] = output_index_id;
223 node->flags = flags;
224
225 node->create = create_argmax_pooling_operator;
226 node->setup = setup_argmax_pooling_operator;
227
228 return xnn_status_success;
229 }
230