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_elu_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_elu_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_elu_nc_f32(
39 channel_dim /* channels */, channel_dim /* input stride */, channel_dim /* output stride */,
40 node->params.elu.alpha,
41 node->flags,
42 &opdata->operator_object);
43 break;
44 #ifndef XNN_NO_QS8_OPERATORS
45 case xnn_compute_type_qs8:
46 status = xnn_create_elu_nc_qs8(
47 channel_dim /* channels */, channel_dim /* input stride */, channel_dim /* output stride */,
48 node->params.elu.alpha,
49 (int8_t) values[input_id].quantization.zero_point,
50 values[input_id].quantization.scale,
51 (int8_t) values[output_id].quantization.zero_point,
52 values[output_id].quantization.scale,
53 INT8_MIN, INT8_MAX,
54 node->flags,
55 &opdata->operator_object);
56 break;
57 #endif // XNN_NO_QS8_OPERATORS
58 default:
59 XNN_UNREACHABLE;
60 }
61 if (status == xnn_status_success) {
62 opdata->batch_size = xnn_shape_multiply_non_channel_dims(&values[input_id].shape);
63 opdata->inputs[0] = input_id;
64 opdata->outputs[0] = output_id;
65 }
66 return status;
67 }
68
setup_elu_operator(const struct xnn_operator_data * opdata,const struct xnn_blob * blobs,size_t num_blobs,pthreadpool_t threadpool)69 static enum xnn_status setup_elu_operator(
70 const struct xnn_operator_data* opdata,
71 const struct xnn_blob* blobs,
72 size_t num_blobs,
73 pthreadpool_t threadpool)
74 {
75 const uint32_t input_id = opdata->inputs[0];
76 assert(input_id != XNN_INVALID_VALUE_ID);
77 assert(input_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_blob = blobs + input_id;
84 const void* input_data = input_blob->data;
85 assert(input_data != NULL);
86
87 const struct xnn_blob* output_blob = blobs + output_id;
88 void* output_data = output_blob->data;
89 assert(output_data != NULL);
90
91 switch (opdata->operator_object->type) {
92 case xnn_operator_type_elu_nc_f32:
93 return xnn_setup_elu_nc_f32(
94 opdata->operator_object,
95 opdata->batch_size,
96 input_data,
97 output_data,
98 threadpool);
99 #ifndef XNN_NO_QS8_OPERATORS
100 case xnn_operator_type_elu_nc_qs8:
101 return xnn_setup_elu_nc_qs8(
102 opdata->operator_object,
103 opdata->batch_size,
104 input_data,
105 output_data,
106 threadpool);
107 #endif // XNN_NO_QS8_OPERATORS
108 default:
109 XNN_UNREACHABLE;
110 }
111 }
112
xnn_define_elu(xnn_subgraph_t subgraph,float alpha,uint32_t input_id,uint32_t output_id,uint32_t flags)113 enum xnn_status xnn_define_elu(
114 xnn_subgraph_t subgraph,
115 float alpha,
116 uint32_t input_id,
117 uint32_t output_id,
118 uint32_t flags)
119 {
120 if ((xnn_params.init_flags & XNN_INIT_FLAG_XNNPACK) == 0) {
121 xnn_log_error("failed to define %s operator: XNNPACK is not initialized",
122 xnn_node_type_to_string(xnn_node_type_elu));
123 return xnn_status_uninitialized;
124 }
125
126 if (alpha <= 0.0f || !isnormal(alpha)) {
127 xnn_log_error(
128 "failed to define %s operator with %.7g alpha parameter: alpha must be finite, normalized, and positive",
129 xnn_node_type_to_string(xnn_node_type_elu), alpha);
130 return xnn_status_invalid_parameter;
131 }
132
133 if (input_id >= subgraph->num_values) {
134 xnn_log_error(
135 "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID",
136 xnn_node_type_to_string(xnn_node_type_elu), input_id);
137 return xnn_status_invalid_parameter;
138 }
139
140 const struct xnn_value* input_value = &subgraph->values[input_id];
141 if (input_value->type != xnn_value_type_dense_tensor) {
142 xnn_log_error(
143 "failed to define %s operator with input ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
144 xnn_node_type_to_string(xnn_node_type_elu), input_id, input_value->type);
145 return xnn_status_invalid_parameter;
146 }
147
148 switch (input_value->datatype) {
149 case xnn_datatype_fp32:
150 #ifndef XNN_NO_QS8_OPERATORS
151 case xnn_datatype_qint8:
152 #endif // !defined(XNN_NO_QS8_OPERATORS)
153 break;
154 default:
155 xnn_log_error(
156 "failed to define %s operator with input ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
157 xnn_node_type_to_string(xnn_node_type_elu), input_id,
158 xnn_datatype_to_string(input_value->datatype), input_value->datatype);
159 return xnn_status_invalid_parameter;
160 }
161
162 if (output_id >= subgraph->num_values) {
163 xnn_log_error(
164 "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID",
165 xnn_node_type_to_string(xnn_node_type_elu), output_id);
166 return xnn_status_invalid_parameter;
167 }
168
169 const struct xnn_value* output_value = &subgraph->values[output_id];
170 if (output_value->type != xnn_value_type_dense_tensor) {
171 xnn_log_error(
172 "failed to define %s operator with output ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)",
173 xnn_node_type_to_string(xnn_node_type_elu), output_id, output_value->type);
174 return xnn_status_invalid_parameter;
175 }
176
177 enum xnn_compute_type compute_type = xnn_compute_type_invalid;
178 switch (output_value->datatype) {
179 case xnn_datatype_fp32:
180 compute_type = xnn_compute_type_fp32;
181 break;
182 #ifndef XNN_NO_QS8_OPERATORS
183 case xnn_datatype_qint8:
184 compute_type = xnn_compute_type_qs8;
185 break;
186 #endif // !defined(XNN_NO_QS8_OPERATORS)
187 default:
188 xnn_log_error(
189 "failed to define %s operator with output ID #%" PRIu32 ": unsupported Value datatype %s (%d)",
190 xnn_node_type_to_string(xnn_node_type_elu), output_id,
191 xnn_datatype_to_string(output_value->datatype), output_value->datatype);
192 return xnn_status_invalid_parameter;
193 }
194
195 if (input_value->datatype != output_value->datatype) {
196 xnn_log_error(
197 "failed to define %s operator with input ID #%" PRIu32 " and output ID #%" PRIu32
198 ": mismatching datatypes across the input (%s) and output (%s)",
199 xnn_node_type_to_string(xnn_node_type_elu), input_id, output_id,
200 xnn_datatype_to_string(input_value->datatype),
201 xnn_datatype_to_string(output_value->datatype));
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_elu;
211 node->compute_type = compute_type;
212 node->params.elu.alpha = alpha;
213 node->num_inputs = 1;
214 node->inputs[0] = input_id;
215 node->num_outputs = 1;
216 node->outputs[0] = output_id;
217 node->flags = flags;
218
219 node->create = create_elu_operator;
220 node->setup = setup_elu_operator;
221
222 return xnn_status_success;
223 }
224