1 /*
2  * SPDX-FileCopyrightText: Copyright 2010-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
3  *
4  * SPDX-License-Identifier: Apache-2.0
5  *
6  * Licensed under the Apache License, Version 2.0 (the License); you may
7  * not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  * www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
14  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 
19 #include "arm_nnfunctions.h"
20 #include "unity.h"
21 
22 #include "../TestData/avgpooling/test_data.h"
23 #include "../TestData/avgpooling_1/test_data.h"
24 #include "../TestData/avgpooling_2/test_data.h"
25 #include "../TestData/avgpooling_3/test_data.h"
26 #include "../TestData/avgpooling_4/test_data.h"
27 #include "../TestData/avgpooling_5/test_data.h"
28 #include "../Utils/validate.h"
29 
avgpooling_arm_avgpool_s8(void)30 void avgpooling_arm_avgpool_s8(void)
31 {
32     const arm_cmsis_nn_status expected = ARM_CMSIS_NN_SUCCESS;
33     int8_t output[AVGPOOLING_DST_SIZE] = {0};
34 
35     cmsis_nn_context ctx;
36     cmsis_nn_pool_params pool_params;
37     cmsis_nn_dims input_dims;
38     cmsis_nn_dims filter_dims;
39     cmsis_nn_dims output_dims;
40 
41     const int8_t *input_data = avgpooling_input;
42 
43     input_dims.n = AVGPOOLING_INPUT_BATCHES;
44     input_dims.w = AVGPOOLING_INPUT_W;
45     input_dims.h = AVGPOOLING_INPUT_H;
46     input_dims.c = AVGPOOLING_IN_CH;
47     filter_dims.w = AVGPOOLING_FILTER_X;
48     filter_dims.h = AVGPOOLING_FILTER_Y;
49     output_dims.w = AVGPOOLING_OUTPUT_W;
50     output_dims.h = AVGPOOLING_OUTPUT_H;
51     output_dims.c = AVGPOOLING_OUT_CH;
52 
53     pool_params.padding.w = AVGPOOLING_PAD_X;
54     pool_params.padding.h = AVGPOOLING_PAD_Y;
55     pool_params.stride.w = AVGPOOLING_STRIDE_X;
56     pool_params.stride.h = AVGPOOLING_STRIDE_Y;
57 
58     pool_params.activation.min = AVGPOOLING_OUT_ACTIVATION_MIN;
59     pool_params.activation.max = AVGPOOLING_OUT_ACTIVATION_MAX;
60 
61     ctx.size = arm_avgpool_s8_get_buffer_size(AVGPOOLING_OUTPUT_W, AVGPOOLING_IN_CH);
62     ctx.buf = malloc(ctx.size);
63 
64     arm_cmsis_nn_status result =
65         arm_avgpool_s8(&ctx, &pool_params, &input_dims, input_data, &filter_dims, &output_dims, output);
66 
67     if (ctx.buf)
68     {
69         // The caller is responsible to clear the scratch buffers for security reasons if applicable.
70         memset(ctx.buf, 0, ctx.size);
71         free(ctx.buf);
72     }
73     TEST_ASSERT_EQUAL(expected, result);
74     TEST_ASSERT_TRUE(validate(output, avgpooling_output_ref, AVGPOOLING_DST_SIZE));
75 }
76 
avgpooling_1_arm_avgpool_s8(void)77 void avgpooling_1_arm_avgpool_s8(void)
78 {
79     const arm_cmsis_nn_status expected = ARM_CMSIS_NN_SUCCESS;
80     int8_t output[AVGPOOLING_1_DST_SIZE] = {0};
81 
82     cmsis_nn_context ctx;
83     cmsis_nn_pool_params pool_params;
84     cmsis_nn_dims input_dims;
85     cmsis_nn_dims filter_dims;
86     cmsis_nn_dims output_dims;
87 
88     const int8_t *input_data = avgpooling_1_input;
89 
90     input_dims.n = AVGPOOLING_1_INPUT_BATCHES;
91     input_dims.w = AVGPOOLING_1_INPUT_W;
92     input_dims.h = AVGPOOLING_1_INPUT_H;
93     input_dims.c = AVGPOOLING_1_IN_CH;
94     filter_dims.w = AVGPOOLING_1_FILTER_X;
95     filter_dims.h = AVGPOOLING_1_FILTER_Y;
96     output_dims.w = AVGPOOLING_1_OUTPUT_W;
97     output_dims.h = AVGPOOLING_1_OUTPUT_H;
98     output_dims.c = AVGPOOLING_1_OUT_CH;
99 
100     pool_params.padding.w = AVGPOOLING_1_PAD_X;
101     pool_params.padding.h = AVGPOOLING_1_PAD_Y;
102     pool_params.stride.w = AVGPOOLING_1_STRIDE_X;
103     pool_params.stride.h = AVGPOOLING_1_STRIDE_Y;
104 
105     pool_params.activation.min = AVGPOOLING_1_OUT_ACTIVATION_MIN;
106     pool_params.activation.max = AVGPOOLING_1_OUT_ACTIVATION_MAX;
107 
108     ctx.size = arm_avgpool_s8_get_buffer_size(AVGPOOLING_1_OUTPUT_W, AVGPOOLING_1_IN_CH);
109     ctx.buf = malloc(ctx.size);
110 
111     arm_cmsis_nn_status result =
112         arm_avgpool_s8(&ctx, &pool_params, &input_dims, input_data, &filter_dims, &output_dims, output);
113 
114     if (ctx.buf)
115     {
116         memset(ctx.buf, 0, ctx.size);
117         free(ctx.buf);
118     }
119     TEST_ASSERT_EQUAL(expected, result);
120     TEST_ASSERT_TRUE(validate(output, avgpooling_1_output_ref, AVGPOOLING_1_DST_SIZE));
121 }
122 
avgpooling_2_arm_avgpool_s8(void)123 void avgpooling_2_arm_avgpool_s8(void)
124 {
125     const arm_cmsis_nn_status expected = ARM_CMSIS_NN_SUCCESS;
126     int8_t output[AVGPOOLING_2_DST_SIZE] = {0};
127 
128     cmsis_nn_context ctx;
129     cmsis_nn_pool_params pool_params;
130     cmsis_nn_dims input_dims;
131     cmsis_nn_dims filter_dims;
132     cmsis_nn_dims output_dims;
133 
134     const int8_t *input_data = avgpooling_2_input;
135 
136     input_dims.n = AVGPOOLING_2_INPUT_BATCHES;
137     input_dims.w = AVGPOOLING_2_INPUT_W;
138     input_dims.h = AVGPOOLING_2_INPUT_H;
139     input_dims.c = AVGPOOLING_2_IN_CH;
140     filter_dims.w = AVGPOOLING_2_FILTER_X;
141     filter_dims.h = AVGPOOLING_2_FILTER_Y;
142     output_dims.w = AVGPOOLING_2_OUTPUT_W;
143     output_dims.h = AVGPOOLING_2_OUTPUT_H;
144     output_dims.c = AVGPOOLING_2_OUT_CH;
145 
146     pool_params.padding.w = AVGPOOLING_2_PAD_X;
147     pool_params.padding.h = AVGPOOLING_2_PAD_Y;
148     pool_params.stride.w = AVGPOOLING_2_STRIDE_X;
149     pool_params.stride.h = AVGPOOLING_2_STRIDE_Y;
150 
151     pool_params.activation.min = AVGPOOLING_2_OUT_ACTIVATION_MIN;
152     pool_params.activation.max = AVGPOOLING_2_OUT_ACTIVATION_MAX;
153 
154     ctx.size = arm_avgpool_s8_get_buffer_size(AVGPOOLING_2_OUTPUT_W, AVGPOOLING_2_IN_CH);
155     ctx.buf = malloc(ctx.size);
156 
157     arm_cmsis_nn_status result =
158         arm_avgpool_s8(&ctx, &pool_params, &input_dims, input_data, &filter_dims, &output_dims, output);
159 
160     if (ctx.buf)
161     {
162         memset(ctx.buf, 0, ctx.size);
163         free(ctx.buf);
164     }
165     TEST_ASSERT_EQUAL(expected, result);
166     TEST_ASSERT_TRUE(validate(output, avgpooling_2_output_ref, AVGPOOLING_2_DST_SIZE));
167 }
168 
avgpooling_3_arm_avgpool_s8(void)169 void avgpooling_3_arm_avgpool_s8(void)
170 {
171     const arm_cmsis_nn_status expected = ARM_CMSIS_NN_SUCCESS;
172     int8_t output[AVGPOOLING_3_DST_SIZE] = {0};
173 
174     cmsis_nn_context ctx;
175     cmsis_nn_pool_params pool_params;
176     cmsis_nn_dims input_dims;
177     cmsis_nn_dims filter_dims;
178     cmsis_nn_dims output_dims;
179 
180     const int8_t *input_data = avgpooling_3_input;
181 
182     input_dims.n = AVGPOOLING_3_INPUT_BATCHES;
183     input_dims.w = AVGPOOLING_3_INPUT_W;
184     input_dims.h = AVGPOOLING_3_INPUT_H;
185     input_dims.c = AVGPOOLING_3_IN_CH;
186     filter_dims.w = AVGPOOLING_3_FILTER_X;
187     filter_dims.h = AVGPOOLING_3_FILTER_Y;
188     output_dims.w = AVGPOOLING_3_OUTPUT_W;
189     output_dims.h = AVGPOOLING_3_OUTPUT_H;
190     output_dims.c = AVGPOOLING_3_OUT_CH;
191 
192     pool_params.padding.w = AVGPOOLING_3_PAD_X;
193     pool_params.padding.h = AVGPOOLING_3_PAD_Y;
194     pool_params.stride.w = AVGPOOLING_3_STRIDE_X;
195     pool_params.stride.h = AVGPOOLING_3_STRIDE_Y;
196 
197     pool_params.activation.min = AVGPOOLING_3_OUT_ACTIVATION_MIN;
198     pool_params.activation.max = AVGPOOLING_3_OUT_ACTIVATION_MAX;
199 
200     ctx.size = arm_avgpool_s8_get_buffer_size(AVGPOOLING_3_OUTPUT_W, AVGPOOLING_3_IN_CH);
201     ctx.buf = malloc(ctx.size);
202 
203     arm_cmsis_nn_status result =
204         arm_avgpool_s8(&ctx, &pool_params, &input_dims, input_data, &filter_dims, &output_dims, output);
205 
206     if (ctx.buf)
207     {
208         memset(ctx.buf, 0, ctx.size);
209         free(ctx.buf);
210     }
211     TEST_ASSERT_EQUAL(expected, result);
212     TEST_ASSERT_TRUE(validate(output, avgpooling_3_output_ref, AVGPOOLING_3_DST_SIZE));
213 }
214 
avgpooling_4_arm_avgpool_s8(void)215 void avgpooling_4_arm_avgpool_s8(void)
216 {
217     const arm_cmsis_nn_status expected = ARM_CMSIS_NN_SUCCESS;
218     int8_t output[AVGPOOLING_4_DST_SIZE] = {0};
219 
220     cmsis_nn_context ctx;
221     cmsis_nn_pool_params pool_params;
222     cmsis_nn_dims input_dims;
223     cmsis_nn_dims filter_dims;
224     cmsis_nn_dims output_dims;
225 
226     const int8_t *input_data = avgpooling_4_input;
227 
228     input_dims.n = AVGPOOLING_4_INPUT_BATCHES;
229     input_dims.w = AVGPOOLING_4_INPUT_W;
230     input_dims.h = AVGPOOLING_4_INPUT_H;
231     input_dims.c = AVGPOOLING_4_IN_CH;
232     filter_dims.w = AVGPOOLING_4_FILTER_X;
233     filter_dims.h = AVGPOOLING_4_FILTER_Y;
234     output_dims.w = AVGPOOLING_4_OUTPUT_W;
235     output_dims.h = AVGPOOLING_4_OUTPUT_H;
236     output_dims.c = AVGPOOLING_4_OUT_CH;
237 
238     pool_params.padding.w = AVGPOOLING_4_PAD_X;
239     pool_params.padding.h = AVGPOOLING_4_PAD_Y;
240     pool_params.stride.w = AVGPOOLING_4_STRIDE_X;
241     pool_params.stride.h = AVGPOOLING_4_STRIDE_Y;
242 
243     pool_params.activation.min = AVGPOOLING_4_OUT_ACTIVATION_MIN;
244     pool_params.activation.max = AVGPOOLING_4_OUT_ACTIVATION_MAX;
245 
246     ctx.size = arm_avgpool_s8_get_buffer_size(AVGPOOLING_4_OUTPUT_W, AVGPOOLING_4_IN_CH);
247     ctx.buf = malloc(ctx.size);
248 
249     arm_cmsis_nn_status result =
250         arm_avgpool_s8(&ctx, &pool_params, &input_dims, input_data, &filter_dims, &output_dims, output);
251 
252     if (ctx.buf)
253     {
254         memset(ctx.buf, 0, ctx.size);
255         free(ctx.buf);
256     }
257     TEST_ASSERT_EQUAL(expected, result);
258     TEST_ASSERT_TRUE(validate(output, avgpooling_4_output_ref, AVGPOOLING_4_DST_SIZE));
259 }
260 
avgpooling_5_arm_avgpool_s8(void)261 void avgpooling_5_arm_avgpool_s8(void)
262 {
263     const arm_cmsis_nn_status expected = ARM_CMSIS_NN_SUCCESS;
264     int8_t output[AVGPOOLING_5_DST_SIZE] = {0};
265 
266     cmsis_nn_context ctx;
267     cmsis_nn_pool_params pool_params;
268     cmsis_nn_dims input_dims;
269     cmsis_nn_dims filter_dims;
270     cmsis_nn_dims output_dims;
271 
272     const int8_t *input_data = avgpooling_5_input;
273 
274     input_dims.n = AVGPOOLING_5_INPUT_BATCHES;
275     input_dims.w = AVGPOOLING_5_INPUT_W;
276     input_dims.h = AVGPOOLING_5_INPUT_H;
277     input_dims.c = AVGPOOLING_5_IN_CH;
278     filter_dims.w = AVGPOOLING_5_FILTER_X;
279     filter_dims.h = AVGPOOLING_5_FILTER_Y;
280     output_dims.w = AVGPOOLING_5_OUTPUT_W;
281     output_dims.h = AVGPOOLING_5_OUTPUT_H;
282     output_dims.c = AVGPOOLING_5_OUT_CH;
283 
284     pool_params.padding.w = AVGPOOLING_5_PAD_X;
285     pool_params.padding.h = AVGPOOLING_5_PAD_Y;
286     pool_params.stride.w = AVGPOOLING_5_STRIDE_X;
287     pool_params.stride.h = AVGPOOLING_5_STRIDE_Y;
288 
289     pool_params.activation.min = AVGPOOLING_5_OUT_ACTIVATION_MIN;
290     pool_params.activation.max = AVGPOOLING_5_OUT_ACTIVATION_MAX;
291 
292     ctx.size = arm_avgpool_s8_get_buffer_size(AVGPOOLING_5_OUTPUT_W, AVGPOOLING_5_IN_CH);
293     ctx.buf = malloc(ctx.size);
294 
295     arm_cmsis_nn_status result =
296         arm_avgpool_s8(&ctx, &pool_params, &input_dims, input_data, &filter_dims, &output_dims, output);
297 
298     if (ctx.buf)
299     {
300         memset(ctx.buf, 0, ctx.size);
301         free(ctx.buf);
302     }
303     TEST_ASSERT_EQUAL(expected, result);
304     TEST_ASSERT_TRUE(validate(output, avgpooling_5_output_ref, AVGPOOLING_5_DST_SIZE));
305 }
306 
buffer_size_mve_arm_avgpool_s8(void)307 void buffer_size_mve_arm_avgpool_s8(void)
308 {
309 #if defined(ARM_MATH_MVEI)
310     const int32_t buf_size = arm_avgpool_s8_get_buffer_size(AVGPOOLING_5_OUTPUT_W, AVGPOOLING_5_IN_CH);
311     const int32_t mve_buf_size = arm_avgpool_s8_get_buffer_size_mve(AVGPOOLING_5_OUTPUT_W, AVGPOOLING_5_IN_CH);
312 
313     TEST_ASSERT_EQUAL(buf_size, mve_buf_size);
314 #endif
315 }
316 
buffer_size_dsp_arm_avgpool_s8(void)317 void buffer_size_dsp_arm_avgpool_s8(void)
318 {
319 #if defined(ARM_MATH_DSP) && !defined(ARM_MATH_MVEI)
320     const int32_t buf_size = arm_avgpool_s8_get_buffer_size(AVGPOOLING_5_OUTPUT_W, AVGPOOLING_5_IN_CH);
321     const int32_t dsp_buf_size = arm_avgpool_s8_get_buffer_size_dsp(AVGPOOLING_5_OUTPUT_W, AVGPOOLING_5_IN_CH);
322 
323     TEST_ASSERT_EQUAL(buf_size, dsp_buf_size);
324 #endif
325 }
326 
avgpooling_param_fail_arm_avgpool_s8(void)327 void avgpooling_param_fail_arm_avgpool_s8(void)
328 {
329     const arm_cmsis_nn_status expected = ARM_CMSIS_NN_ARG_ERROR;
330     int8_t output[AVGPOOLING_5_DST_SIZE] = {0};
331 
332     cmsis_nn_context ctx;
333     cmsis_nn_pool_params pool_params;
334     cmsis_nn_dims input_dims;
335     cmsis_nn_dims filter_dims;
336     cmsis_nn_dims output_dims;
337 
338     const int8_t *input_data = avgpooling_5_input;
339 
340     input_dims.n = -AVGPOOLING_5_INPUT_BATCHES;
341     input_dims.w = AVGPOOLING_5_INPUT_W;
342     input_dims.h = AVGPOOLING_5_INPUT_H;
343     input_dims.c = AVGPOOLING_5_IN_CH;
344     filter_dims.w = AVGPOOLING_5_FILTER_X;
345     filter_dims.h = AVGPOOLING_5_FILTER_Y;
346     output_dims.w = AVGPOOLING_5_OUTPUT_W;
347     output_dims.h = AVGPOOLING_5_OUTPUT_H;
348     output_dims.c = AVGPOOLING_5_OUT_CH;
349 
350     pool_params.padding.w = AVGPOOLING_5_PAD_X;
351     pool_params.padding.h = AVGPOOLING_5_PAD_Y;
352     pool_params.stride.w = AVGPOOLING_5_STRIDE_X;
353     pool_params.stride.h = AVGPOOLING_5_STRIDE_Y;
354 
355     pool_params.activation.min = AVGPOOLING_5_OUT_ACTIVATION_MIN;
356     pool_params.activation.max = AVGPOOLING_5_OUT_ACTIVATION_MAX;
357 
358     ctx.size = arm_avgpool_s8_get_buffer_size(AVGPOOLING_5_OUTPUT_W, AVGPOOLING_5_IN_CH);
359     ctx.buf = malloc(ctx.size);
360 
361     arm_cmsis_nn_status result =
362         arm_avgpool_s8(&ctx, &pool_params, &input_dims, input_data, &filter_dims, &output_dims, output);
363 
364     if (ctx.buf)
365     {
366         memset(ctx.buf, 0, ctx.size);
367         free(ctx.buf);
368     }
369     TEST_ASSERT_EQUAL(expected, result);
370 }
371