1 // Copyright 2019 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 <gtest/gtest.h>
7
8 #include <xnnpack/params.h>
9
10 #include "prelu-operator-tester.h"
11
12
TEST(PRELU_NC_F16,unit_batch)13 TEST(PRELU_NC_F16, unit_batch) {
14 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
15 PReLUOperatorTester()
16 .batch_size(1)
17 .channels(channels)
18 .iterations(3)
19 .TestF16();
20 }
21 }
22
TEST(PRELU_NC_F16,small_batch)23 TEST(PRELU_NC_F16, small_batch) {
24 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
25 PReLUOperatorTester()
26 .batch_size(xnn_params.f16.prelu.row_tile)
27 .channels(channels)
28 .iterations(3)
29 .TestF16();
30 }
31 }
32
TEST(PRELU_NC_F16,small_batch_with_x_stride)33 TEST(PRELU_NC_F16, small_batch_with_x_stride) {
34 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
35 PReLUOperatorTester()
36 .batch_size(xnn_params.f16.prelu.row_tile)
37 .channels(channels)
38 .x_stride(123)
39 .iterations(3)
40 .TestF16();
41 }
42 }
43
TEST(PRELU_NC_F16,small_batch_with_y_stride)44 TEST(PRELU_NC_F16, small_batch_with_y_stride) {
45 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
46 PReLUOperatorTester()
47 .batch_size(xnn_params.f16.prelu.row_tile)
48 .channels(channels)
49 .y_stride(117)
50 .iterations(3)
51 .TestF16();
52 }
53 }
54
TEST(PRELU_NC_F16,small_batch_with_x_stride_and_y_stride)55 TEST(PRELU_NC_F16, small_batch_with_x_stride_and_y_stride) {
56 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
57 PReLUOperatorTester()
58 .batch_size(xnn_params.f16.prelu.row_tile)
59 .channels(channels)
60 .x_stride(123)
61 .y_stride(117)
62 .iterations(3)
63 .TestF16();
64 }
65 }
66
TEST(PRELU_NC_F16,large_batch)67 TEST(PRELU_NC_F16, large_batch) {
68 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
69 PReLUOperatorTester()
70 .batch_size(3 * xnn_params.f16.prelu.row_tile + 1)
71 .channels(channels)
72 .iterations(1)
73 .TestF16();
74 }
75 }
76
TEST(PRELU_NC_F16,large_batch_with_x_stride)77 TEST(PRELU_NC_F16, large_batch_with_x_stride) {
78 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
79 PReLUOperatorTester()
80 .batch_size(3 * xnn_params.f16.prelu.row_tile + 1)
81 .channels(channels)
82 .x_stride(123)
83 .iterations(1)
84 .TestF16();
85 }
86 }
87
TEST(PRELU_NC_F16,large_batch_with_y_stride)88 TEST(PRELU_NC_F16, large_batch_with_y_stride) {
89 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
90 PReLUOperatorTester()
91 .batch_size(3 * xnn_params.f16.prelu.row_tile + 1)
92 .channels(channels)
93 .y_stride(117)
94 .iterations(1)
95 .TestF16();
96 }
97 }
98
TEST(PRELU_NC_F16,large_batch_with_x_stride_and_y_stride)99 TEST(PRELU_NC_F16, large_batch_with_x_stride_and_y_stride) {
100 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
101 PReLUOperatorTester()
102 .batch_size(3 * xnn_params.f16.prelu.row_tile + 1)
103 .channels(channels)
104 .x_stride(123)
105 .y_stride(117)
106 .iterations(1)
107 .TestF16();
108 }
109 }
110
TEST(PRELU_NC_F16,fp32_weights)111 TEST(PRELU_NC_F16, fp32_weights) {
112 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
113 PReLUOperatorTester()
114 .batch_size(3 * xnn_params.f16.prelu.row_tile + 1)
115 .channels(channels)
116 .x_stride(123)
117 .y_stride(117)
118 .weights_type(PReLUOperatorTester::WeightsType::FP32)
119 .iterations(1)
120 .TestF16();
121 }
122 }
123
124
TEST(PRELU_NC_F32,unit_batch)125 TEST(PRELU_NC_F32, unit_batch) {
126 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
127 PReLUOperatorTester()
128 .batch_size(1)
129 .channels(channels)
130 .iterations(3)
131 .TestF32();
132 }
133 }
134
TEST(PRELU_NC_F32,small_batch)135 TEST(PRELU_NC_F32, small_batch) {
136 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
137 PReLUOperatorTester()
138 .batch_size(xnn_params.f32.prelu.row_tile)
139 .channels(channels)
140 .iterations(3)
141 .TestF32();
142 }
143 }
144
TEST(PRELU_NC_F32,small_batch_with_x_stride)145 TEST(PRELU_NC_F32, small_batch_with_x_stride) {
146 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
147 PReLUOperatorTester()
148 .batch_size(xnn_params.f32.prelu.row_tile)
149 .channels(channels)
150 .x_stride(123)
151 .iterations(3)
152 .TestF32();
153 }
154 }
155
TEST(PRELU_NC_F32,small_batch_with_y_stride)156 TEST(PRELU_NC_F32, small_batch_with_y_stride) {
157 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
158 PReLUOperatorTester()
159 .batch_size(xnn_params.f32.prelu.row_tile)
160 .channels(channels)
161 .y_stride(117)
162 .iterations(3)
163 .TestF32();
164 }
165 }
166
TEST(PRELU_NC_F32,small_batch_with_x_stride_and_y_stride)167 TEST(PRELU_NC_F32, small_batch_with_x_stride_and_y_stride) {
168 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
169 PReLUOperatorTester()
170 .batch_size(xnn_params.f32.prelu.row_tile)
171 .channels(channels)
172 .x_stride(123)
173 .y_stride(117)
174 .iterations(3)
175 .TestF32();
176 }
177 }
178
TEST(PRELU_NC_F32,large_batch)179 TEST(PRELU_NC_F32, large_batch) {
180 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
181 PReLUOperatorTester()
182 .batch_size(3 * xnn_params.f32.prelu.row_tile + 1)
183 .channels(channels)
184 .iterations(1)
185 .TestF32();
186 }
187 }
188
TEST(PRELU_NC_F32,large_batch_with_x_stride)189 TEST(PRELU_NC_F32, large_batch_with_x_stride) {
190 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
191 PReLUOperatorTester()
192 .batch_size(3 * xnn_params.f32.prelu.row_tile + 1)
193 .channels(channels)
194 .x_stride(123)
195 .iterations(1)
196 .TestF32();
197 }
198 }
199
TEST(PRELU_NC_F32,large_batch_with_y_stride)200 TEST(PRELU_NC_F32, large_batch_with_y_stride) {
201 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
202 PReLUOperatorTester()
203 .batch_size(3 * xnn_params.f32.prelu.row_tile + 1)
204 .channels(channels)
205 .y_stride(117)
206 .iterations(1)
207 .TestF32();
208 }
209 }
210
TEST(PRELU_NC_F32,large_batch_with_x_stride_and_y_stride)211 TEST(PRELU_NC_F32, large_batch_with_x_stride_and_y_stride) {
212 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
213 PReLUOperatorTester()
214 .batch_size(3 * xnn_params.f32.prelu.row_tile + 1)
215 .channels(channels)
216 .x_stride(123)
217 .y_stride(117)
218 .iterations(1)
219 .TestF32();
220 }
221 }
222