1 // Copyright 2022 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 <algorithm>
7 #include <array>
8 #include <cstddef>
9 #include <cstdint>
10 #include <limits>
11 #include <memory>
12 #include <random>
13
14 #include <xnnpack.h>
15 #include <xnnpack/node-type.h>
16 #include <xnnpack/operator.h>
17 #include <xnnpack/subgraph.h>
18
19 #include "subgraph-unary-tester.h"
20 #include <gtest/gtest.h>
21
22 using EluTestQS8 = UnaryTest<int8_t>;
23 using EluTestF32 = UnaryTest<float>;
24
TEST_F(EluTestQS8,define)25 TEST_F(EluTestQS8, define)
26 {
27 const int32_t input_zero_point = i8dist(rng);
28 const float input_scale = scale_dist(rng);
29 const int32_t output_zero_point = input_zero_point;
30 const float output_scale = input_scale;
31 const float alpha = std::uniform_real_distribution<float>(1.0e-4f, 1.0f)(rng);
32
33 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
34
35 xnn_subgraph_t subgraph = nullptr;
36 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/2, /*flags=*/0, &subgraph));
37 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
38
39 input_id = XNN_INVALID_NODE_ID;
40 ASSERT_EQ(
41 xnn_status_success, xnn_define_quantized_tensor_value(
42 subgraph, xnn_datatype_qint8, input_zero_point, input_scale, dims.size(), dims.data(),
43 nullptr, 0, /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
44 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
45
46 output_id = XNN_INVALID_NODE_ID;
47 ASSERT_EQ(
48 xnn_status_success, xnn_define_quantized_tensor_value(
49 subgraph, xnn_datatype_qint8, output_zero_point, output_scale, dims.size(), dims.data(),
50 nullptr, 1, /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output_id));
51 ASSERT_NE(output_id, XNN_INVALID_NODE_ID);
52
53 ASSERT_EQ(xnn_status_success, xnn_define_elu(subgraph, alpha, input_id, output_id, /*flags=*/0));
54
55 ASSERT_EQ(subgraph->num_nodes, 1);
56 const struct xnn_node* node = &subgraph->nodes[0];
57 ASSERT_EQ(node->type, xnn_node_type_elu);
58 ASSERT_EQ(node->compute_type, xnn_compute_type_qs8);
59 ASSERT_EQ(node->params.elu.alpha, alpha);
60 ASSERT_EQ(node->num_inputs, 1);
61 ASSERT_EQ(node->inputs[0], input_id);
62 ASSERT_EQ(node->num_outputs, 1);
63 ASSERT_EQ(node->outputs[0], output_id);
64 ASSERT_EQ(node->flags, 0);
65 }
66
TEST_F(EluTestF32,define)67 TEST_F(EluTestF32, define)
68 {
69 const float alpha = std::uniform_real_distribution<float>(1.0e-4f, 1.0f)(rng);
70
71 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
72
73 xnn_subgraph_t subgraph = nullptr;
74 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/2, /*flags=*/0, &subgraph));
75 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
76
77 input_id = XNN_INVALID_NODE_ID;
78 ASSERT_EQ(
79 xnn_status_success, xnn_define_tensor_value(
80 subgraph, xnn_datatype_fp32, dims.size(), dims.data(), nullptr, 0,
81 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
82 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
83
84 output_id = XNN_INVALID_NODE_ID;
85 ASSERT_EQ(
86 xnn_status_success, xnn_define_tensor_value(
87 subgraph, xnn_datatype_fp32, dims.size(), dims.data(), nullptr, 1,
88 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output_id));
89 ASSERT_NE(output_id, XNN_INVALID_NODE_ID);
90
91 ASSERT_EQ(xnn_status_success, xnn_define_elu(subgraph, alpha, input_id, output_id, /*flags=*/0));
92
93 ASSERT_EQ(subgraph->num_nodes, 1);
94 const struct xnn_node* node = &subgraph->nodes[0];
95 ASSERT_EQ(node->type, xnn_node_type_elu);
96 ASSERT_EQ(node->compute_type, xnn_compute_type_fp32);
97 ASSERT_EQ(node->params.elu.alpha, alpha);
98 ASSERT_EQ(node->num_inputs, 1);
99 ASSERT_EQ(node->inputs[0], input_id);
100 ASSERT_EQ(node->num_outputs, 1);
101 ASSERT_EQ(node->outputs[0], output_id);
102 ASSERT_EQ(node->flags, 0);
103 }
104
TEST_F(EluTestQS8,matches_operator_api)105 TEST_F(EluTestQS8, matches_operator_api)
106 {
107 const int32_t input_zero_point = i8dist(rng);
108 const float input_scale = scale_dist(rng);
109 const int32_t output_zero_point = input_zero_point;
110 const float output_scale = input_scale;
111 const float alpha = std::uniform_real_distribution<float>(1.0e-4f, 1.0f)(rng);
112 std::generate(input.begin(), input.end(), [&]() { return i8dist(rng); });
113 std::fill(operator_output.begin(), operator_output.end(), INT8_C(0xA5));
114 std::fill(subgraph_output.begin(), subgraph_output.end(), INT8_C(0xA5));
115
116 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
117
118 // Call operator API.
119 xnn_operator_t op = nullptr;
120 const xnn_status status = xnn_create_elu_nc_qs8(
121 channels, channels, channels, alpha, input_zero_point, input_scale, output_zero_point, output_scale, INT8_MIN,
122 INT8_MAX, /*flags=*/0, &op);
123 if (status == xnn_status_unsupported_hardware) {
124 GTEST_SKIP();
125 }
126 ASSERT_EQ(xnn_status_success, status);
127 ASSERT_NE(nullptr, op);
128 std::unique_ptr<xnn_operator, decltype(&xnn_delete_operator)> auto_op(op, xnn_delete_operator);
129
130 ASSERT_EQ(
131 xnn_status_success,
132 xnn_setup_elu_nc_qs8(op, batch_size, input.data(), operator_output.data(), /*threadpool=*/nullptr));
133 ASSERT_EQ(xnn_status_success, xnn_run_operator(op, /*threadpool=*/nullptr));
134
135 // Call subgraph API.
136 xnn_subgraph_t subgraph = nullptr;
137 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/2, /*flags=*/0, &subgraph));
138 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
139 input_id = XNN_INVALID_NODE_ID;
140 ASSERT_EQ(
141 xnn_status_success, xnn_define_quantized_tensor_value(
142 subgraph, xnn_datatype_qint8, input_zero_point, input_scale, dims.size(), dims.data(),
143 nullptr, /*external_id=*/0, /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
144 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
145
146 output_id = XNN_INVALID_NODE_ID;
147 ASSERT_EQ(
148 xnn_status_success, xnn_define_quantized_tensor_value(
149 subgraph, xnn_datatype_qint8, output_zero_point, output_scale, dims.size(), dims.data(),
150 nullptr, /*external_id=*/1, /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output_id));
151 ASSERT_NE(output_id, XNN_INVALID_NODE_ID);
152
153 ASSERT_EQ(xnn_status_success, xnn_define_elu(subgraph, alpha, input_id, output_id, /*flags=*/0));
154
155 xnn_runtime_t runtime = nullptr;
156 ASSERT_EQ(xnn_status_success, xnn_create_runtime_v3(subgraph, nullptr, nullptr, /*flags=*/0, &runtime));
157 ASSERT_NE(nullptr, runtime);
158 std::unique_ptr<xnn_runtime, decltype(&xnn_delete_runtime)> auto_runtime(runtime, xnn_delete_runtime);
159
160 std::array<xnn_external_value, 2> external = {
161 xnn_external_value{input_id, input.data()}, xnn_external_value{output_id, subgraph_output.data()}};
162 ASSERT_EQ(xnn_status_success, xnn_setup_runtime(runtime, external.size(), external.data()));
163 ASSERT_EQ(xnn_status_success, xnn_invoke_runtime(runtime));
164
165 ASSERT_EQ(subgraph_output, operator_output);
166 }
167
TEST_F(EluTestF32,matches_operator_api)168 TEST_F(EluTestF32, matches_operator_api)
169 {
170 const float alpha = std::uniform_real_distribution<float>(1.0e-4f, 1.0f)(rng);
171 std::uniform_real_distribution<float> f32dist(-255.0f, 255.0f);
172 std::generate(input.begin(), input.end(), [&]() { return f32dist(rng); });
173 std::fill(operator_output.begin(), operator_output.end(), nanf(""));
174 std::fill(subgraph_output.begin(), subgraph_output.end(), nanf(""));
175
176 ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
177
178 // Call operator API.
179 xnn_operator_t op = nullptr;
180 const xnn_status status = xnn_create_elu_nc_f32(channels, channels, channels, alpha, /*flags=*/0, &op);
181 if (status == xnn_status_unsupported_hardware) {
182 GTEST_SKIP();
183 }
184
185 ASSERT_EQ(xnn_status_success, status);
186 ASSERT_NE(nullptr, op);
187 std::unique_ptr<xnn_operator, decltype(&xnn_delete_operator)> auto_op(op, xnn_delete_operator);
188
189 ASSERT_EQ(
190 xnn_status_success,
191 xnn_setup_elu_nc_f32(op, batch_size, input.data(), operator_output.data(), /*threadpool=*/nullptr));
192
193 ASSERT_EQ(xnn_status_success, xnn_run_operator(op, /*threadpool=*/nullptr));
194
195 // Call subgraph API.
196 xnn_subgraph_t subgraph = nullptr;
197 ASSERT_EQ(xnn_status_success, xnn_create_subgraph(/*external_value_ids=*/2, /*flags=*/0, &subgraph));
198 std::unique_ptr<xnn_subgraph, decltype(&xnn_delete_subgraph)> auto_subgraph(subgraph, xnn_delete_subgraph);
199 input_id = XNN_INVALID_NODE_ID;
200 ASSERT_EQ(
201 xnn_status_success, xnn_define_tensor_value(
202 subgraph, xnn_datatype_fp32, dims.size(), dims.data(), nullptr, /*external_id=*/0,
203 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_INPUT, &input_id));
204 ASSERT_NE(input_id, XNN_INVALID_NODE_ID);
205
206 output_id = XNN_INVALID_NODE_ID;
207 ASSERT_EQ(
208 xnn_status_success, xnn_define_tensor_value(
209 subgraph, xnn_datatype_fp32, dims.size(), dims.data(), nullptr, /*external_id=*/1,
210 /*flags=*/XNN_VALUE_FLAG_EXTERNAL_OUTPUT, &output_id));
211 ASSERT_NE(output_id, XNN_INVALID_NODE_ID);
212
213 xnn_runtime_t runtime = nullptr;
214 ASSERT_EQ(xnn_status_success, xnn_define_elu(subgraph, alpha, input_id, output_id, /*flags=*/0));
215 ASSERT_EQ(xnn_status_success, xnn_create_runtime_v3(subgraph, nullptr, nullptr, /*flags=*/0, &runtime));
216 ASSERT_NE(nullptr, runtime);
217 std::unique_ptr<xnn_runtime, decltype(&xnn_delete_runtime)> auto_runtime(runtime, xnn_delete_runtime);
218 std::array<xnn_external_value, 2> external = {
219 xnn_external_value{input_id, input.data()}, xnn_external_value{output_id, subgraph_output.data()}};
220 ASSERT_EQ(xnn_status_success, xnn_setup_runtime(runtime, external.size(), external.data()));
221 ASSERT_EQ(xnn_status_success, xnn_invoke_runtime(runtime));
222
223 ASSERT_EQ(subgraph_output, operator_output);
224 }
225