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 #include <string.h>
10
11 #include <xnnpack.h>
12 #include <xnnpack/log.h>
13 #include <xnnpack/params.h>
14 #include <xnnpack/subgraph.h>
15
16
create_squared_difference_operator(const struct xnn_node * node,const struct xnn_value * values,size_t num_values,struct xnn_operator_data * opdata)17 static enum xnn_status create_squared_difference_operator(
18 const struct xnn_node* node,
19 const struct xnn_value* values,
20 size_t num_values,
21 struct xnn_operator_data* opdata)
22 {
23 assert(node->compute_type == xnn_compute_type_fp32);
24
25 assert(node->num_inputs == 2);
26 const uint32_t input1_id = node->inputs[0];
27 assert(input1_id != XNN_INVALID_VALUE_ID);
28 assert(input1_id < num_values);
29 const uint32_t input2_id = node->inputs[1];
30 assert(input2_id != XNN_INVALID_VALUE_ID);
31 assert(input2_id < num_values);
32
33 assert(node->num_outputs == 1);
34 const uint32_t output_id = node->outputs[0];
35 assert(output_id != XNN_INVALID_VALUE_ID);
36 assert(output_id < num_values);
37
38 const enum xnn_status status = xnn_create_squared_difference_nd_f32(
39 node->flags,
40 &opdata->operator_object);
41 if (status == xnn_status_success) {
42 opdata->shape1.num_dims = values[input1_id].shape.num_dims;
43 opdata->shape2.num_dims = values[input2_id].shape.num_dims;
44 if (values[output_id].layout == xnn_layout_type_nchw) {
45 assert(values[input1_id].layout == xnn_layout_type_nchw);
46 assert(values[input2_id].layout == xnn_layout_type_nchw);
47 opdata->shape1.dim[0] = values[input1_id].shape.dim[0];
48 opdata->shape1.dim[1] = values[input1_id].shape.dim[values[input1_id].shape.num_dims - 1];
49 if (values[input1_id].shape.num_dims > 2) {
50 memcpy(&opdata->shape1.dim[2], &values[input1_id].shape.dim[1], (values[input1_id].shape.num_dims - 2) * sizeof(size_t));
51 }
52 opdata->shape2.dim[0] = values[input2_id].shape.dim[0];
53 opdata->shape2.dim[1] = values[input2_id].shape.dim[values[input2_id].shape.num_dims - 1];
54 if (values[input1_id].shape.num_dims > 2) {
55 memcpy(&opdata->shape2.dim[2], &values[input2_id].shape.dim[1], (values[input2_id].shape.num_dims - 2) * sizeof(size_t));
56 }
57 } else {
58 assert(values[output_id].layout == xnn_layout_type_nhwc);
59 assert(values[input1_id].layout == xnn_layout_type_nhwc);
60 assert(values[input2_id].layout == xnn_layout_type_nhwc);
61 memcpy(opdata->shape1.dim, values[input1_id].shape.dim, values[input1_id].shape.num_dims * sizeof(size_t));
62 memcpy(opdata->shape2.dim, values[input2_id].shape.dim, values[input2_id].shape.num_dims * sizeof(size_t));
63 }
64 opdata->inputs[0] = input1_id;
65 opdata->inputs[1] = input2_id;
66 opdata->outputs[0] = output_id;
67 }
68 return status;
69 }
70
setup_squared_difference_operator(const struct xnn_operator_data * opdata,const struct xnn_blob * blobs,size_t num_blobs,pthreadpool_t threadpool)71 static enum xnn_status setup_squared_difference_operator(
72 const struct xnn_operator_data* opdata,
73 const struct xnn_blob* blobs,
74 size_t num_blobs,
75 pthreadpool_t threadpool)
76 {
77 const uint32_t input1_id = opdata->inputs[0];
78 assert(input1_id != XNN_INVALID_VALUE_ID);
79 assert(input1_id < num_blobs);
80
81 const uint32_t input2_id = opdata->inputs[1];
82 assert(input2_id != XNN_INVALID_VALUE_ID);
83 assert(input2_id < num_blobs);
84
85 const uint32_t output_id = opdata->outputs[0];
86 assert(output_id != XNN_INVALID_VALUE_ID);
87 assert(output_id < num_blobs);
88
89 const struct xnn_blob* input1_blob = blobs + input1_id;
90 const void* input1_data = input1_blob->data;
91 assert(input1_data != NULL);
92
93 const struct xnn_blob* input2_blob = blobs + input2_id;
94 const void* input2_data = input2_blob->data;
95 assert(input2_data != NULL);
96
97 const struct xnn_blob* output_blob = blobs + output_id;
98 void* output_data = output_blob->data;
99 assert(output_data != NULL);
100
101 return xnn_setup_squared_difference_nd_f32(
102 opdata->operator_object,
103 opdata->shape1.num_dims,
104 opdata->shape1.dim,
105 opdata->shape2.num_dims,
106 opdata->shape2.dim,
107 input1_data, input2_data, output_data,
108 threadpool);
109 }
110
xnn_define_squared_difference(xnn_subgraph_t subgraph,uint32_t input1_id,uint32_t input2_id,uint32_t output_id,uint32_t flags)111 enum xnn_status xnn_define_squared_difference(
112 xnn_subgraph_t subgraph,
113 uint32_t input1_id,
114 uint32_t input2_id,
115 uint32_t output_id,
116 uint32_t flags)
117 {
118 if ((xnn_params.init_flags & XNN_INIT_FLAG_XNNPACK) == 0) {
119 xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
120 xnn_node_type_to_string(xnn_node_type_squared_difference));
121 return xnn_status_uninitialized;
122 }
123
124 if (input1_id >= subgraph->num_values) {
125 xnn_log_error(
126 "failed to define %s operator with the first input ID #%" PRIu32 ": invalid Value ID",
127 xnn_node_type_to_string(xnn_node_type_squared_difference), input1_id);
128 return xnn_status_invalid_parameter;
129 }
130
131 const struct xnn_value* input1_value = &subgraph->values[input1_id];
132 if (input1_value->type != xnn_value_type_dense_tensor) {
133 xnn_log_error(
134 "failed to define %s operator with the first input ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
135 xnn_node_type_to_string(xnn_node_type_squared_difference), input1_id, input1_value->type);
136 return xnn_status_invalid_parameter;
137 }
138
139 switch (input1_value->datatype) {
140 case xnn_datatype_fp32:
141 break;
142 default:
143 xnn_log_error(
144 "failed to define %s operator with first input ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
145 xnn_node_type_to_string(xnn_node_type_squared_difference), input1_id,
146 xnn_datatype_to_string(input1_value->datatype), input1_value->datatype);
147 return xnn_status_invalid_parameter;
148 }
149
150 if (input2_id >= subgraph->num_values) {
151 xnn_log_error(
152 "failed to define %s operator with the second input ID #%" PRIu32 ": invalid Value ID",
153 xnn_node_type_to_string(xnn_node_type_squared_difference), input2_id);
154 return xnn_status_invalid_parameter;
155 }
156
157 const struct xnn_value* input2_value = &subgraph->values[input2_id];
158 if (input2_value->type != xnn_value_type_dense_tensor) {
159 xnn_log_error(
160 "failed to define %s operator with the second input ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
161 xnn_node_type_to_string(xnn_node_type_squared_difference), input2_id, input2_value->type);
162 return xnn_status_invalid_parameter;
163 }
164
165 switch (input2_value->datatype) {
166 case xnn_datatype_fp32:
167 break;
168 default:
169 xnn_log_error(
170 "failed to define %s operator with second input ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
171 xnn_node_type_to_string(xnn_node_type_squared_difference), input2_id,
172 xnn_datatype_to_string(input2_value->datatype), input2_value->datatype);
173 return xnn_status_invalid_parameter;
174 }
175
176 if (output_id >= subgraph->num_values) {
177 xnn_log_error(
178 "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
179 xnn_node_type_to_string(xnn_node_type_squared_difference), output_id);
180 return xnn_status_invalid_parameter;
181 }
182
183 const struct xnn_value* output_value = &subgraph->values[output_id];
184 if (output_value->type != xnn_value_type_dense_tensor) {
185 xnn_log_error(
186 "failed to define %s operator with output ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
187 xnn_node_type_to_string(xnn_node_type_squared_difference), output_id, output_value->type);
188 return xnn_status_invalid_parameter;
189 }
190
191 switch (output_value->datatype) {
192 case xnn_datatype_fp32:
193 break;
194 default:
195 xnn_log_error(
196 "failed to define %s operator with output ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
197 xnn_node_type_to_string(xnn_node_type_squared_difference), output_id,
198 xnn_datatype_to_string(output_value->datatype), output_value->datatype);
199 return xnn_status_invalid_parameter;
200 }
201
202 struct xnn_node* node = xnn_subgraph_new_node(subgraph);
203 if (node == NULL) {
204 return xnn_status_out_of_memory;
205 }
206
207 node->type = xnn_node_type_squared_difference;
208 node->compute_type = xnn_compute_type_fp32;
209 node->num_inputs = 2;
210 node->inputs[0] = input1_id;
211 node->inputs[1] = input2_id;
212 node->num_outputs = 1;
213 node->outputs[0] = output_id;
214 node->flags = flags;
215
216 node->create = create_squared_difference_operator;
217 node->setup = setup_squared_difference_operator;
218
219 return xnn_status_success;
220 }
221