1 /* ----------------------------------------------------------------------
2 * Project: CMSIS DSP Library
3 * Title: arm_absmax_f16.c
4 * Description: Maximum value of a absolute values of a floating-point vector
5 *
6 * $Date: 23 April 2021
7 * $Revision: V1.9.0
8 *
9 * Target Processor: Cortex-M and Cortex-A cores
10 * -------------------------------------------------------------------- */
11 /*
12 * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
13 *
14 * SPDX-License-Identifier: Apache-2.0
15 *
16 * Licensed under the Apache License, Version 2.0 (the License); you may
17 * not use this file except in compliance with the License.
18 * You may obtain a copy of the License at
19 *
20 * www.apache.org/licenses/LICENSE-2.0
21 *
22 * Unless required by applicable law or agreed to in writing, software
23 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
24 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
25 * See the License for the specific language governing permissions and
26 * limitations under the License.
27 */
28
29 #include "dsp/statistics_functions_f16.h"
30
31 #if defined(ARM_FLOAT16_SUPPORTED)
32
33 #if (defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF)) && !defined(ARM_MATH_AUTOVECTORIZE)
34 #include <limits.h>
35 #endif
36
37 /**
38 @ingroup groupStats
39 */
40
41
42 /**
43 @addtogroup AbsMax
44 @{
45 */
46
47 /**
48 @brief Maximum value of absolute values of a floating-point vector.
49 @param[in] pSrc points to the input vector
50 @param[in] blockSize number of samples in input vector
51 @param[out] pResult maximum value returned here
52 @param[out] pIndex index of maximum value returned here
53 @return none
54 */
55
56 #if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)
57
58 #include "arm_helium_utils.h"
arm_absmax_f16(const float16_t * pSrc,uint32_t blockSize,float16_t * pResult,uint32_t * pIndex)59 void arm_absmax_f16(
60 const float16_t * pSrc,
61 uint32_t blockSize,
62 float16_t * pResult,
63 uint32_t * pIndex)
64 {
65 uint16_t blkCnt; /* loop counters */
66 f16x8_t vecSrc;
67 float16_t const *pSrcVec;
68 f16x8_t curExtremValVec = vdupq_n_f16(F16_ABSMIN);
69 float16_t maxValue = F16_ABSMIN;
70 uint16_t idx = blockSize;
71 uint16x8_t indexVec;
72 uint16x8_t curExtremIdxVec;
73 mve_pred16_t p0;
74
75
76 indexVec = vidupq_u16((uint32_t)0, 1);
77 curExtremIdxVec = vdupq_n_u16(0);
78
79 pSrcVec = (float16_t const *) pSrc;
80 blkCnt = blockSize >> 3;
81 while (blkCnt > 0U)
82 {
83 vecSrc = vldrhq_f16(pSrcVec);
84 pSrcVec += 8;
85 vecSrc = vabsq(vecSrc);
86 /*
87 * Get current max per lane and current index per lane
88 * when a max is selected
89 */
90 p0 = vcmpgeq(vecSrc, curExtremValVec);
91 curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
92 curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
93
94 indexVec = indexVec + 8;
95 /*
96 * Decrement the blockSize loop counter
97 */
98 blkCnt--;
99 }
100 /*
101 * tail
102 * (will be merged thru tail predication)
103 */
104 blkCnt = blockSize & 7;
105 if (blkCnt > 0U)
106 {
107 vecSrc = vldrhq_f16(pSrcVec);
108 pSrcVec += 8;
109 vecSrc = vabsq(vecSrc);
110
111 p0 = vctp16q(blkCnt);
112 /*
113 * Get current max per lane and current index per lane
114 * when a max is selected
115 */
116 p0 = vcmpgeq_m(vecSrc, curExtremValVec, p0);
117 curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
118 curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
119 }
120 /*
121 * Get max value across the vector
122 */
123 maxValue = vmaxnmvq(maxValue, curExtremValVec);
124 /*
125 * set index for lower values to max possible index
126 */
127 p0 = vcmpgeq(curExtremValVec, maxValue);
128 indexVec = vpselq(curExtremIdxVec, vdupq_n_u16(blockSize), p0);
129 /*
130 * Get min index which is thus for a max value
131 */
132 idx = vminvq(idx, indexVec);
133 /*
134 * Save result
135 */
136 *pIndex = idx;
137 *pResult = maxValue;
138 }
139 #else
140 #if defined(ARM_MATH_LOOPUNROLL)
arm_absmax_f16(const float16_t * pSrc,uint32_t blockSize,float16_t * pResult,uint32_t * pIndex)141 void arm_absmax_f16(
142 const float16_t * pSrc,
143 uint32_t blockSize,
144 float16_t * pResult,
145 uint32_t * pIndex)
146 {
147 float16_t cur_absmax, out; /* Temporary variables to store the output value. */\
148 uint32_t blkCnt, outIndex; /* Loop counter */ \
149 uint32_t index; /* index of maximum value */ \
150 \
151 /* Initialize index value to zero. */ \
152 outIndex = 0U; \
153 /* Load first input value that act as reference value for comparision */ \
154 out = *pSrc++; \
155 out = (out > 0.0f16) ? out : -out; \
156 /* Initialize index of extrema value. */ \
157 index = 0U; \
158 \
159 /* Loop unrolling: Compute 4 outputs at a time */ \
160 blkCnt = (blockSize - 1U) >> 2U; \
161 \
162 while (blkCnt > 0U) \
163 { \
164 /* Initialize cur_absmax to next consecutive values one by one */ \
165 cur_absmax = *pSrc++; \
166 cur_absmax = (cur_absmax > 0.0f16) ? cur_absmax : -cur_absmax; \
167 /* compare for the extrema value */ \
168 if (cur_absmax > out) \
169 { \
170 /* Update the extrema value and it's index */ \
171 out = cur_absmax; \
172 outIndex = index + 1U; \
173 } \
174 \
175 cur_absmax = *pSrc++; \
176 cur_absmax = (cur_absmax > 0.0f16) ? cur_absmax : -cur_absmax; \
177 if (cur_absmax > out) \
178 { \
179 out = cur_absmax; \
180 outIndex = index + 2U; \
181 } \
182 \
183 cur_absmax = *pSrc++; \
184 cur_absmax = (cur_absmax > 0.0f16) ? cur_absmax : -cur_absmax; \
185 if (cur_absmax > out) \
186 { \
187 out = cur_absmax; \
188 outIndex = index + 3U; \
189 } \
190 \
191 cur_absmax = *pSrc++; \
192 cur_absmax = (cur_absmax > 0.0f16) ? cur_absmax : -cur_absmax; \
193 if (cur_absmax > out) \
194 { \
195 out = cur_absmax; \
196 outIndex = index + 4U; \
197 } \
198 \
199 index += 4U; \
200 \
201 /* Decrement loop counter */ \
202 blkCnt--; \
203 } \
204 \
205 /* Loop unrolling: Compute remaining outputs */ \
206 blkCnt = (blockSize - 1U) % 4U; \
207 \
208 \
209 while (blkCnt > 0U) \
210 { \
211 cur_absmax = *pSrc++; \
212 cur_absmax = (cur_absmax > 0.0f16) ? cur_absmax : -cur_absmax; \
213 if (cur_absmax > out) \
214 { \
215 out = cur_absmax; \
216 outIndex = blockSize - blkCnt; \
217 } \
218 \
219 /* Decrement loop counter */ \
220 blkCnt--; \
221 } \
222 \
223 /* Store the extrema value and it's index into destination pointers */ \
224 *pResult = out; \
225 *pIndex = outIndex;
226 }
227 #else
arm_absmax_f16(const float16_t * pSrc,uint32_t blockSize,float16_t * pResult,uint32_t * pIndex)228 void arm_absmax_f16(
229 const float16_t * pSrc,
230 uint32_t blockSize,
231 float16_t * pResult,
232 uint32_t * pIndex)
233 {
234 float16_t maxVal, out; /* Temporary variables to store the output value. */
235 uint32_t blkCnt, outIndex; /* Loop counter */
236
237 /* Initialise index value to zero. */
238 outIndex = 0U;
239
240 /* Load first input value that act as reference value for comparision */
241 out = fabsf(*pSrc++);
242
243 /* Initialize blkCnt with number of samples */
244 blkCnt = (blockSize - 1U);
245
246 while (blkCnt > 0U)
247 {
248 /* Initialize maxVal to the next consecutive values one by one */
249 maxVal = fabsf(*pSrc++);
250
251 /* compare for the maximum value */
252 if (out < maxVal)
253 {
254 /* Update the maximum value and it's index */
255 out = maxVal;
256 outIndex = blockSize - blkCnt;
257 }
258
259 /* Decrement loop counter */
260 blkCnt--;
261 }
262
263 /* Store the maximum value and it's index into destination pointers */
264 *pResult = out;
265 *pIndex = outIndex;
266 }
267 #endif /* defined(ARM_MATH_LOOPUNROLL) */
268 #endif /* defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE) */
269 /**
270 @} end of AbsMax group
271 */
272
273 #endif /* #if defined(ARM_FLOAT16_SUPPORTED) */
274
275
