| // Copyright 2020 Google LLC |
| // |
| // This source code is licensed under the BSD-style license found in the |
| // LICENSE file in the root directory of this source tree. |
| |
| #include <math.h> |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include <xnnpack.h> |
| #include <xnnpack/log.h> |
| #include <xnnpack/params.h> |
| #include <xnnpack/subgraph.h> |
| |
| |
| static enum xnn_status create_elu_operator( |
| const struct xnn_node* node, |
| const struct xnn_value* values, |
| size_t num_values, |
| struct xnn_operator_data* opdata) |
| { |
| assert(node->num_inputs == 1); |
| const uint32_t input_id = node->inputs[0]; |
| assert(input_id != XNN_INVALID_VALUE_ID); |
| assert(input_id < num_values); |
| |
| assert(node->num_outputs == 1); |
| const uint32_t output_id = node->outputs[0]; |
| assert(output_id != XNN_INVALID_VALUE_ID); |
| assert(output_id < num_values); |
| |
| const size_t num_input_dims = values[input_id].shape.num_dims; |
| const size_t channel_dim = num_input_dims == 0 ? 1 : values[input_id].shape.dim[num_input_dims - 1]; |
| |
| enum xnn_status status; |
| switch (node->compute_type) { |
| case xnn_compute_type_fp32: |
| status = xnn_create_elu_nc_f32( |
| channel_dim /* channels */, channel_dim /* input stride */, channel_dim /* output stride */, |
| node->params.elu.alpha, |
| node->flags, |
| &opdata->operator_object); |
| break; |
| #ifndef XNN_NO_QS8_OPERATORS |
| case xnn_compute_type_qs8: |
| status = xnn_create_elu_nc_qs8( |
| channel_dim /* channels */, channel_dim /* input stride */, channel_dim /* output stride */, |
| node->params.elu.alpha, |
| (int8_t) values[input_id].quantization.zero_point, |
| values[input_id].quantization.scale, |
| (int8_t) values[output_id].quantization.zero_point, |
| values[output_id].quantization.scale, |
| INT8_MIN, INT8_MAX, |
| node->flags, |
| &opdata->operator_object); |
| break; |
| #endif // XNN_NO_QS8_OPERATORS |
| default: |
| XNN_UNREACHABLE; |
| } |
| if (status == xnn_status_success) { |
| opdata->batch_size = xnn_shape_multiply_non_channel_dims(&values[input_id].shape); |
| opdata->inputs[0] = input_id; |
| opdata->outputs[0] = output_id; |
| } |
| return status; |
| } |
| |
| static enum xnn_status setup_elu_operator( |
| const struct xnn_operator_data* opdata, |
| const struct xnn_blob* blobs, |
| size_t num_blobs, |
| pthreadpool_t threadpool) |
| { |
| const uint32_t input_id = opdata->inputs[0]; |
| assert(input_id != XNN_INVALID_VALUE_ID); |
| assert(input_id < num_blobs); |
| |
| const uint32_t output_id = opdata->outputs[0]; |
| assert(output_id != XNN_INVALID_VALUE_ID); |
| assert(output_id < num_blobs); |
| |
| const struct xnn_blob* input_blob = blobs + input_id; |
| const void* input_data = input_blob->data; |
| assert(input_data != NULL); |
| |
| const struct xnn_blob* output_blob = blobs + output_id; |
| void* output_data = output_blob->data; |
| assert(output_data != NULL); |
| |
| switch (opdata->operator_object->type) { |
| case xnn_operator_type_elu_nc_f32: |
| return xnn_setup_elu_nc_f32( |
| opdata->operator_object, |
| opdata->batch_size, |
| input_data, |
| output_data, |
| threadpool); |
| #ifndef XNN_NO_QS8_OPERATORS |
| case xnn_operator_type_elu_nc_qs8: |
| return xnn_setup_elu_nc_qs8( |
| opdata->operator_object, |
| opdata->batch_size, |
| input_data, |
| output_data, |
| threadpool); |
| #endif // XNN_NO_QS8_OPERATORS |
| default: |
| XNN_UNREACHABLE; |
| } |
| } |
| |
| enum xnn_status xnn_define_elu( |
| xnn_subgraph_t subgraph, |
| float alpha, |
| uint32_t input_id, |
| uint32_t output_id, |
| uint32_t flags) |
| { |
| if ((xnn_params.init_flags & XNN_INIT_FLAG_XNNPACK) == 0) { |
| xnn_log_error("failed to define %s operator: XNNPACK is not initialized", |
| xnn_node_type_to_string(xnn_node_type_elu)); |
| return xnn_status_uninitialized; |
| } |
| |
| if (alpha <= 0.0f || !isnormal(alpha)) { |
| xnn_log_error( |
| "failed to define %s operator with %.7g alpha parameter: alpha must be finite, normalized, and positive", |
| xnn_node_type_to_string(xnn_node_type_elu), alpha); |
| return xnn_status_invalid_parameter; |
| } |
| |
| if (input_id >= subgraph->num_values) { |
| xnn_log_error( |
| "failed to define %s operator with input ID #%" PRIu32 ": invalid Value ID", |
| xnn_node_type_to_string(xnn_node_type_elu), input_id); |
| return xnn_status_invalid_parameter; |
| } |
| |
| const struct xnn_value* input_value = &subgraph->values[input_id]; |
| if (input_value->type != xnn_value_type_dense_tensor) { |
| xnn_log_error( |
| "failed to define %s operator with input ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)", |
| xnn_node_type_to_string(xnn_node_type_elu), input_id, input_value->type); |
| return xnn_status_invalid_parameter; |
| } |
| |
| switch (input_value->datatype) { |
| case xnn_datatype_fp32: |
| #ifndef XNN_NO_QS8_OPERATORS |
| case xnn_datatype_qint8: |
| #endif // !defined(XNN_NO_QS8_OPERATORS) |
| break; |
| default: |
| xnn_log_error( |
| "failed to define %s operator with input ID #%" PRIu32 ": unsupported Value datatype %s (%d)", |
| xnn_node_type_to_string(xnn_node_type_elu), input_id, |
| xnn_datatype_to_string(input_value->datatype), input_value->datatype); |
| return xnn_status_invalid_parameter; |
| } |
| |
| if (output_id >= subgraph->num_values) { |
| xnn_log_error( |
| "failed to define %s operator with output ID #%" PRIu32 ": invalid Value ID", |
| xnn_node_type_to_string(xnn_node_type_elu), output_id); |
| return xnn_status_invalid_parameter; |
| } |
| |
| const struct xnn_value* output_value = &subgraph->values[output_id]; |
| if (output_value->type != xnn_value_type_dense_tensor) { |
| xnn_log_error( |
| "failed to define %s operator with output ID #%" PRIu32 ": unsupported Value type %d (expected dense tensor)", |
| xnn_node_type_to_string(xnn_node_type_elu), output_id, output_value->type); |
| return xnn_status_invalid_parameter; |
| } |
| |
| enum xnn_compute_type compute_type = xnn_compute_type_invalid; |
| switch (output_value->datatype) { |
| case xnn_datatype_fp32: |
| compute_type = xnn_compute_type_fp32; |
| break; |
| #ifndef XNN_NO_QS8_OPERATORS |
| case xnn_datatype_qint8: |
| compute_type = xnn_compute_type_qs8; |
| break; |
| #endif // !defined(XNN_NO_QS8_OPERATORS) |
| default: |
| xnn_log_error( |
| "failed to define %s operator with output ID #%" PRIu32 ": unsupported Value datatype %s (%d)", |
| xnn_node_type_to_string(xnn_node_type_elu), output_id, |
| xnn_datatype_to_string(output_value->datatype), output_value->datatype); |
| return xnn_status_invalid_parameter; |
| } |
| |
| if (input_value->datatype != output_value->datatype) { |
| xnn_log_error( |
| "failed to define %s operator with input ID #%" PRIu32 " and output ID #%" PRIu32 |
| ": mismatching datatypes across the input (%s) and output (%s)", |
| xnn_node_type_to_string(xnn_node_type_elu), input_id, output_id, |
| xnn_datatype_to_string(input_value->datatype), |
| xnn_datatype_to_string(output_value->datatype)); |
| return xnn_status_invalid_parameter; |
| } |
| |
| struct xnn_node* node = xnn_subgraph_new_node(subgraph); |
| if (node == NULL) { |
| return xnn_status_out_of_memory; |
| } |
| |
| node->type = xnn_node_type_elu; |
| node->compute_type = compute_type; |
| node->params.elu.alpha = alpha; |
| node->num_inputs = 1; |
| node->inputs[0] = input_id; |
| node->num_outputs = 1; |
| node->outputs[0] = output_id; |
| node->flags = flags; |
| |
| node->create = create_elu_operator; |
| node->setup = setup_elu_operator; |
| |
| return xnn_status_success; |
| } |