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_sigmoid_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_sigmoid_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->num_inputs == 1);
23 const uint32_t input_id = node->inputs[0];
24 assert(input_id != XNN_INVALID_VALUE_ID);
25 assert(input_id < num_values);
26
27 assert(node->num_outputs == 1);
28 const uint32_t output_id = node->outputs[0];
29 assert(output_id != XNN_INVALID_VALUE_ID);
30 assert(output_id < num_values);
31
32 const size_t num_input_dims = values[input_id].shape.num_dims;
33 const size_t channel_dim = num_input_dims == 0 ? 1 : values[input_id].shape.dim[num_input_dims - 1];
34
35 enum xnn_status status;
36 switch (node->compute_type) {
37 case xnn_compute_type_fp32:
38 status = xnn_create_sigmoid_nc_f32(
39 channel_dim /* channels */, channel_dim /* input stride */, channel_dim /* output stride */,
40 node->flags,
41 &opdata->operator_object);
42 break;
43 #ifndef XNN_NO_QS8_OPERATORS
44 case xnn_compute_type_qs8:
45 {
46 status = xnn_create_sigmoid_nc_qs8(
47 channel_dim /* channels */, channel_dim /* input stride */, channel_dim /* output stride */,
48 (int8_t) values[input_id].quantization.zero_point,
49 values[input_id].quantization.scale,
50 (int8_t) values[output_id].quantization.zero_point,
51 values[output_id].quantization.scale,
52 INT8_MIN, INT8_MAX,
53 node->flags,
54 &opdata->operator_object);
55 break;
56 }
57 #endif // !defined(XNN_NO_QS8_OPERATORS)
58 #ifndef XNN_NO_QU8_OPERATORS
59 case xnn_compute_type_qu8:
60 {
61 status = xnn_create_sigmoid_nc_qu8(
62 channel_dim /* channels */, channel_dim /* input stride */, channel_dim /* output stride */,
63 (uint8_t) values[input_id].quantization.zero_point,
64 values[input_id].quantization.scale,
65 (uint8_t) values[output_id].quantization.zero_point,
66 values[output_id].quantization.scale,
67 0, UINT8_MAX,
68 node->flags,
69 &opdata->operator_object);
70 break;
71 }
72 #endif // !defined(XNN_NO_QU8_OPERATORS)
73 default:
74 XNN_UNREACHABLE;
75 }
76 if (status == xnn_status_success) {
77 opdata->batch_size = xnn_shape_multiply_non_channel_dims(&values[input_id].shape);
78 opdata->inputs[0] = input_id;
79 opdata->outputs[0] = output_id;
80 }
81 return status;
82 }
83
setup_sigmoid_operator(const struct xnn_operator_data * opdata,const struct xnn_blob * blobs,size_t num_blobs,pthreadpool_t threadpool)84 static enum xnn_status setup_sigmoid_operator(
85 const struct xnn_operator_data* opdata,
86 const struct xnn_blob* blobs,
87 size_t num_blobs,
88 pthreadpool_t threadpool)
89 {
90 const uint32_t input_id = opdata->inputs[0];
91 assert(input_id != XNN_INVALID_VALUE_ID);
92 assert(input_id < num_blobs);
93
94 const uint32_t output_id = opdata->outputs[0];
95 assert(output_id != XNN_INVALID_VALUE_ID);
96 assert(output_id < num_blobs);
97
98 const struct xnn_blob* input_blob = blobs + input_id;
99 const void* input_data = input_blob->data;
100 assert(input_data != NULL);
101
102 const struct xnn_blob* output_blob = blobs + output_id;
103 void* output_data = output_blob->data;
104 assert(output_data != NULL);
105
106 switch (opdata->operator_object->type) {
107 case xnn_operator_type_sigmoid_nc_f32:
108 return xnn_setup_sigmoid_nc_f32(
109 opdata->operator_object,
110 opdata->batch_size,
111 input_data,
112 output_data,
113 threadpool);
114 #ifndef XNN_NO_QS8_OPERATORS
115 case xnn_operator_type_sigmoid_nc_qs8:
116 return xnn_setup_sigmoid_nc_qs8(
117 opdata->operator_object,
118 opdata->batch_size,
119 input_data,
120 output_data,
121 threadpool);
122 #endif // !defined(XNN_NO_QS8_OPERATORS)
123 #ifndef XNN_NO_QU8_OPERATORS
124 case xnn_operator_type_sigmoid_nc_qu8:
125 return xnn_setup_sigmoid_nc_qu8(
126 opdata->operator_object,
127 opdata->batch_size,
128 input_data,
129 output_data,
130 threadpool);
131 break;
132 #endif // !defined(XNN_NO_QU8_OPERATORS)
133 default:
134 XNN_UNREACHABLE;
135 }
136 }
137
xnn_define_sigmoid(xnn_subgraph_t subgraph,uint32_t input_id,uint32_t output_id,uint32_t flags)138 enum xnn_status xnn_define_sigmoid(
139 xnn_subgraph_t subgraph,
140 uint32_t input_id,
141 uint32_t output_id,
142 uint32_t flags)
143 {
144 if ((xnn_params.init_flags & XNN_INIT_FLAG_XNNPACK) == 0) {
145 xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
146 xnn_node_type_to_string(xnn_node_type_sigmoid));
147 return xnn_status_uninitialized;
148 }
149
150 if (input_id >= subgraph->num_values) {
151 xnn_log_error(
152 "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
153 xnn_node_type_to_string(xnn_node_type_sigmoid), input_id);
154 return xnn_status_invalid_parameter;
155 }
156
157 const struct xnn_value* input_value = &subgraph->values[input_id];
158 if (input_value->type != xnn_value_type_dense_tensor) {
159 xnn_log_error(
160 "failed to define %s operator with input ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
161 xnn_node_type_to_string(xnn_node_type_sigmoid), input_id, input_value->type);
162 return xnn_status_invalid_parameter;
163 }
164
165 switch (input_value->datatype) {
166 case xnn_datatype_fp32:
167 #ifndef XNN_NO_QS8_OPERATORS
168 case xnn_datatype_qint8:
169 #endif // !defined(XNN_NO_QS8_OPERATORS)
170 #ifndef XNN_NO_QU8_OPERATORS
171 case xnn_datatype_quint8:
172 #endif // !defined(XNN_NO_QU8_OPERATORS)
173 break;
174 default:
175 xnn_log_error(
176 "failed to define %s operator with input ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
177 xnn_node_type_to_string(xnn_node_type_sigmoid), input_id,
178 xnn_datatype_to_string(input_value->datatype), input_value->datatype);
179 return xnn_status_invalid_parameter;
180 }
181
182 if (output_id >= subgraph->num_values) {
183 xnn_log_error(
184 "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
185 xnn_node_type_to_string(xnn_node_type_sigmoid), output_id);
186 return xnn_status_invalid_parameter;
187 }
188
189 const struct xnn_value* output_value = &subgraph->values[output_id];
190 if (output_value->type != xnn_value_type_dense_tensor) {
191 xnn_log_error(
192 "failed to define %s operator with output ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
193 xnn_node_type_to_string(xnn_node_type_sigmoid), output_id, output_value->type);
194 return xnn_status_invalid_parameter;
195 }
196
197 enum xnn_compute_type compute_type = xnn_compute_type_invalid;
198 switch (output_value->datatype) {
199 case xnn_datatype_fp32:
200 compute_type = xnn_compute_type_fp32;
201 break;
202 #ifndef XNN_NO_QS8_OPERATORS
203 case xnn_datatype_qint8:
204 compute_type = xnn_compute_type_qs8;
205 break;
206 #endif // !defined(XNN_NO_QS8_OPERATORS)
207 #ifndef XNN_NO_QU8_OPERATORS
208 case xnn_datatype_quint8:
209 compute_type = xnn_compute_type_qu8;
210 break;
211 #endif // !defined(XNN_NO_QU8_OPERATORS)
212 default:
213 xnn_log_error(
214 "failed to define %s operator with output ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
215 xnn_node_type_to_string(xnn_node_type_sigmoid), output_id,
216 xnn_datatype_to_string(output_value->datatype), output_value->datatype);
217 return xnn_status_invalid_parameter;
218 }
219
220 if (input_value->datatype != output_value->datatype) {
221 xnn_log_error(
222 "failed to define %s operator with input ID #%" PRIu32 " and output ID #%" PRIu32
223 ": mismatching datatypes across the input (%s) and output (%s)",
224 xnn_node_type_to_string(xnn_node_type_subtract), input_id, output_id,
225 xnn_datatype_to_string(input_value->datatype),
226 xnn_datatype_to_string(output_value->datatype));
227 return xnn_status_invalid_parameter;
228 }
229
230 struct xnn_node* node = xnn_subgraph_new_node(subgraph);
231 if (node == NULL) {
232 return xnn_status_out_of_memory;
233 }
234
235 node->type = xnn_node_type_sigmoid;
236 node->compute_type = compute_type;
237 node->num_inputs = 1;
238 node->inputs[0] = input_id;
239 node->num_outputs = 1;
240 node->outputs[0] = output_id;
241 node->flags = flags;
242
243 node->create = create_sigmoid_operator;
244 node->setup = setup_sigmoid_operator;
245
246 return xnn_status_success;
247 }
248