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 <assert.h>
7 #include <math.h>
8 #include <stddef.h>
9 #include <stdint.h>
10
11 #include <xnnpack.h>
12 #include <xnnpack/log.h>
13 #include <xnnpack/params.h>
14 #include <xnnpack/subgraph.h>
15 #include <xnnpack/subgraph-validation.h>
16
17
create_unpooling_operator(const struct xnn_node * node,const struct xnn_value * values,size_t num_values,struct xnn_operator_data * opdata,const struct xnn_caches * caches)18 static enum xnn_status create_unpooling_operator(
19 const struct xnn_node* node,
20 const struct xnn_value* values,
21 size_t num_values,
22 struct xnn_operator_data* opdata,
23 const struct xnn_caches* caches)
24 {
25 assert(node->compute_type == xnn_compute_type_fp32);
26
27 assert(node->num_inputs == 2);
28 const uint32_t input_value_id = node->inputs[0];
29 assert(input_value_id != XNN_INVALID_VALUE_ID);
30 assert(input_value_id < num_values);
31 const uint32_t input_index_id = node->inputs[1];
32 assert(input_index_id != XNN_INVALID_VALUE_ID);
33 assert(input_index_id < num_values);
34
35 assert(node->num_outputs == 1);
36 const uint32_t output_id = node->outputs[0];
37 assert(output_id != XNN_INVALID_VALUE_ID);
38 assert(output_id < num_values);
39
40 const size_t channel_dim = values[input_value_id].shape.dim[3];
41 assert(channel_dim == values[input_index_id].shape.dim[3]);
42 assert(channel_dim == values[output_id].shape.dim[3]);
43
44 const enum xnn_status status = xnn_create_unpooling2d_nhwc_x32(
45 node->params.pooling_2d.padding_top,
46 node->params.pooling_2d.padding_right,
47 node->params.pooling_2d.padding_bottom,
48 node->params.pooling_2d.padding_left,
49 node->params.pooling_2d.pooling_height,
50 node->params.pooling_2d.pooling_width,
51 channel_dim /* channels */, channel_dim /* input stride */, channel_dim /* output stride */,
52 node->flags,
53 &opdata->operator_objects[0]);
54 if (status == xnn_status_success) {
55 opdata->batch_size = values[input_value_id].shape.dim[0];
56 opdata->input_height = values[input_value_id].shape.dim[1];
57 opdata->input_width = values[input_value_id].shape.dim[2];
58 opdata->inputs[0] = input_value_id;
59 opdata->inputs[1] = input_index_id;
60 opdata->outputs[0] = output_id;
61 }
62 return status;
63 }
64
setup_unpooling_operator(const struct xnn_operator_data * opdata,const struct xnn_blob * blobs,size_t num_blobs,pthreadpool_t threadpool)65 static enum xnn_status setup_unpooling_operator(
66 const struct xnn_operator_data* opdata,
67 const struct xnn_blob* blobs,
68 size_t num_blobs,
69 pthreadpool_t threadpool)
70 {
71 const uint32_t input_value_id = opdata->inputs[0];
72 assert(input_value_id != XNN_INVALID_VALUE_ID);
73 assert(input_value_id < num_blobs);
74
75 const uint32_t input_index_id = opdata->inputs[1];
76 assert(input_index_id != XNN_INVALID_VALUE_ID);
77 assert(input_index_id < num_blobs);
78
79 const uint32_t output_id = opdata->outputs[0];
80 assert(output_id != XNN_INVALID_VALUE_ID);
81 assert(output_id < num_blobs);
82
83 const struct xnn_blob* input_value_blob = blobs + input_value_id;
84 const void* input_value_data = input_value_blob->data;
85 assert(input_value_data != NULL);
86
87 const struct xnn_blob* input_index_blob = blobs + input_index_id;
88 const void* input_index_data = input_index_blob->data;
89 assert(input_index_data != NULL);
90
91 const struct xnn_blob* output_blob = blobs + output_id;
92 void* output_data = output_blob->data;
93 assert(output_data != NULL);
94
95 return xnn_setup_unpooling2d_nhwc_x32(
96 opdata->operator_objects[0],
97 opdata->batch_size,
98 opdata->input_height,
99 opdata->input_width,
100 input_value_data,
101 input_index_data,
102 output_data,
103 threadpool);
104 }
105
xnn_define_unpooling_2d(xnn_subgraph_t subgraph,uint32_t padding_top,uint32_t padding_right,uint32_t padding_bottom,uint32_t padding_left,uint32_t pooling_height,uint32_t pooling_width,uint32_t input_value_id,uint32_t input_index_id,uint32_t output_id,uint32_t flags)106 enum xnn_status xnn_define_unpooling_2d(
107 xnn_subgraph_t subgraph,
108 uint32_t padding_top,
109 uint32_t padding_right,
110 uint32_t padding_bottom,
111 uint32_t padding_left,
112 uint32_t pooling_height,
113 uint32_t pooling_width,
114 uint32_t input_value_id,
115 uint32_t input_index_id,
116 uint32_t output_id,
117 uint32_t flags)
118 {
119 enum xnn_status status;
120 if ((status = xnn_subgraph_check_xnnpack_initialized(xnn_node_type_unpooling_2d)) != xnn_status_success) {
121 return status;
122 }
123
124 const uint32_t pooling_size = pooling_height * pooling_width;
125 if (pooling_size == 0) {
126 xnn_log_error(
127 "failed to define %s operator with %" PRIu32 "x%" PRIu32 " pooling size: "
128 "pooling size dimensions must be non-zero",
129 xnn_node_type_to_string(xnn_node_type_unpooling_2d), pooling_width, pooling_height);
130 return xnn_status_invalid_parameter;
131 }
132
133 if (pooling_size == 1) {
134 xnn_log_error(
135 "failed to define %s operator with 1 pooling element: 1x1 pooling is meaningless",
136 xnn_node_type_to_string(xnn_node_type_unpooling_2d));
137 return xnn_status_invalid_parameter;
138 }
139
140 if ((status = xnn_subgraph_check_input_node_id(xnn_node_type_unpooling_2d, input_value_id, subgraph->num_values)) !=
141 xnn_status_success) {
142 return status;
143 }
144
145 const struct xnn_value* input_value_value = &subgraph->values[input_value_id];
146 if (input_value_value->type != xnn_value_type_dense_tensor) {
147 xnn_log_error(
148 "failed to define %s operator with input value ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
149 xnn_node_type_to_string(xnn_node_type_unpooling_2d), input_value_id, input_value_value->type);
150 return xnn_status_invalid_parameter;
151 }
152
153 switch (input_value_value->datatype) {
154 case xnn_datatype_fp32:
155 break;
156 default:
157 xnn_log_error(
158 "failed to define %s operator with input value ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
159 xnn_node_type_to_string(xnn_node_type_unpooling_2d), input_value_id,
160 xnn_datatype_to_string(input_value_value->datatype), input_value_value->datatype);
161 return xnn_status_invalid_parameter;
162 }
163
164 if (input_index_id >= subgraph->num_values) {
165 xnn_log_error(
166 "failed to define %s operator with input index ID #%" PRIu32 ": invalid Value ID",
167 xnn_node_type_to_string(xnn_node_type_unpooling_2d), input_index_id);
168 return xnn_status_invalid_parameter;
169 }
170
171 const struct xnn_value* input_index_value = &subgraph->values[input_index_id];
172 if (input_index_value->type != xnn_value_type_dense_tensor) {
173 xnn_log_error(
174 "failed to define %s operator with input index ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
175 xnn_node_type_to_string(xnn_node_type_unpooling_2d), input_index_id, input_index_value->type);
176 return xnn_status_invalid_parameter;
177 }
178
179 status = xnn_subgraph_check_output_node_id(xnn_node_type_unpooling_2d, output_id, subgraph->num_values);
180 if (status != xnn_status_success) {
181 return status;
182 }
183
184 const struct xnn_value* output_value = &subgraph->values[output_id];
185 status = xnn_subgraph_check_output_type_dense(xnn_node_type_unpooling_2d, output_id, output_value);
186 if (status != xnn_status_success) {
187 return status;
188 }
189
190 switch (output_value->datatype) {
191 case xnn_datatype_fp32:
192 break;
193 default:
194 xnn_log_error(
195 "failed to define %s operator with output ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
196 xnn_node_type_to_string(xnn_node_type_unpooling_2d), output_id,
197 xnn_datatype_to_string(output_value->datatype), output_value->datatype);
198 return xnn_status_invalid_parameter;
199 }
200
201 struct xnn_node* node = xnn_subgraph_new_node(subgraph);
202 if (node == NULL) {
203 return xnn_status_out_of_memory;
204 }
205
206 node->type = xnn_node_type_unpooling_2d;
207 node->compute_type = xnn_compute_type_fp32;
208 node->params.pooling_2d.padding_top = padding_top;
209 node->params.pooling_2d.padding_right = padding_right;
210 node->params.pooling_2d.padding_bottom = padding_bottom;
211 node->params.pooling_2d.padding_left = padding_left;
212 node->params.pooling_2d.pooling_height = pooling_height;
213 node->params.pooling_2d.pooling_width = pooling_width;
214 node->num_inputs = 2;
215 node->inputs[0] = input_value_id;
216 node->inputs[1] = input_index_id;
217 node->num_outputs = 1;
218 node->outputs[0] = output_id;
219 node->flags = flags;
220
221 node->create = create_unpooling_operator;
222 node->setup = setup_unpooling_operator;
223
224 return xnn_status_success;
225 }
226