52#ifndef INCLUDED_volk_32f_index_min_32u_a_H
53#define INCLUDED_volk_32f_index_min_32u_a_H
62static inline void volk_32f_index_min_32u_a_sse4_1(uint32_t* target,
66 const uint32_t quarterPoints = num_points / 4;
68 float* inputPtr = (
float*)source;
70 __m128 indexIncrementValues = _mm_set1_ps(4);
71 __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
73 float min = source[0];
75 __m128 minValues = _mm_set1_ps(min);
76 __m128 minValuesIndex = _mm_setzero_ps();
77 __m128 compareResults;
83 for (uint32_t number = 0; number < quarterPoints; number++) {
85 currentValues = _mm_load_ps(inputPtr);
87 currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
89 compareResults = _mm_cmplt_ps(currentValues, minValues);
91 minValuesIndex = _mm_blendv_ps(minValuesIndex, currentIndexes, compareResults);
92 minValues = _mm_blendv_ps(minValues, currentValues, compareResults);
96 _mm_store_ps(minValuesBuffer, minValues);
97 _mm_store_ps(minIndexesBuffer, minValuesIndex);
99 for (uint32_t number = 0; number < 4; number++) {
100 if (minValuesBuffer[number] < min) {
101 index = minIndexesBuffer[number];
102 min = minValuesBuffer[number];
103 }
else if (minValuesBuffer[number] == min) {
104 if (index > minIndexesBuffer[number])
105 index = minIndexesBuffer[number];
109 for (uint32_t number = quarterPoints * 4; number < num_points; number++) {
110 if (source[number] < min) {
112 min = source[number];
115 target[0] = (uint32_t)index;
123#include <xmmintrin.h>
128 const uint32_t quarterPoints = num_points / 4;
130 float* inputPtr = (
float*)source;
132 __m128 indexIncrementValues = _mm_set1_ps(4);
133 __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
135 float min = source[0];
137 __m128 minValues = _mm_set1_ps(min);
138 __m128 minValuesIndex = _mm_setzero_ps();
139 __m128 compareResults;
140 __m128 currentValues;
145 for (uint32_t number = 0; number < quarterPoints; number++) {
147 currentValues = _mm_load_ps(inputPtr);
149 currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
151 compareResults = _mm_cmplt_ps(currentValues, minValues);
153 minValuesIndex = _mm_or_ps(_mm_and_ps(compareResults, currentIndexes),
154 _mm_andnot_ps(compareResults, minValuesIndex));
156 minValues = _mm_or_ps(_mm_and_ps(compareResults, currentValues),
157 _mm_andnot_ps(compareResults, minValues));
161 _mm_store_ps(minValuesBuffer, minValues);
162 _mm_store_ps(minIndexesBuffer, minValuesIndex);
164 for (uint32_t number = 0; number < 4; number++) {
165 if (minValuesBuffer[number] < min) {
166 index = minIndexesBuffer[number];
167 min = minValuesBuffer[number];
168 }
else if (minValuesBuffer[number] == min) {
169 if (index > minIndexesBuffer[number])
170 index = minIndexesBuffer[number];
174 for (uint32_t number = quarterPoints * 4; number < num_points; number++) {
175 if (source[number] < min) {
177 min = source[number];
180 target[0] = (uint32_t)index;
187#include <immintrin.h>
192 const uint32_t quarterPoints = num_points / 8;
194 float* inputPtr = (
float*)source;
196 __m256 indexIncrementValues = _mm256_set1_ps(8);
197 __m256 currentIndexes = _mm256_set_ps(-1, -2, -3, -4, -5, -6, -7, -8);
199 float min = source[0];
201 __m256 minValues = _mm256_set1_ps(min);
202 __m256 minValuesIndex = _mm256_setzero_ps();
203 __m256 compareResults;
204 __m256 currentValues;
209 for (uint32_t number = 0; number < quarterPoints; number++) {
210 currentValues = _mm256_load_ps(inputPtr);
212 currentIndexes = _mm256_add_ps(currentIndexes, indexIncrementValues);
213 compareResults = _mm256_cmp_ps(currentValues, minValues, _CMP_LT_OS);
214 minValuesIndex = _mm256_blendv_ps(minValuesIndex, currentIndexes, compareResults);
215 minValues = _mm256_blendv_ps(minValues, currentValues, compareResults);
219 _mm256_store_ps(minValuesBuffer, minValues);
220 _mm256_store_ps(minIndexesBuffer, minValuesIndex);
222 for (uint32_t number = 0; number < 8; number++) {
223 if (minValuesBuffer[number] < min) {
224 index = minIndexesBuffer[number];
225 min = minValuesBuffer[number];
226 }
else if (minValuesBuffer[number] == min) {
227 if (index > minIndexesBuffer[number])
228 index = minIndexesBuffer[number];
232 for (uint32_t number = quarterPoints * 8; number < num_points; number++) {
233 if (source[number] < min) {
235 min = source[number];
238 target[0] = (uint32_t)index;
250 const uint32_t quarterPoints = num_points / 4;
252 float* inputPtr = (
float*)source;
253 float32x4_t indexIncrementValues = vdupq_n_f32(4);
255 float currentIndexes_float[4] = { -4.0f, -3.0f, -2.0f, -1.0f };
256 float32x4_t currentIndexes = vld1q_f32(currentIndexes_float);
258 float min = source[0];
260 float32x4_t minValues = vdupq_n_f32(min);
261 uint32x4_t minValuesIndex = vmovq_n_u32(0);
262 uint32x4_t compareResults;
263 uint32x4_t currentIndexes_u;
264 float32x4_t currentValues;
269 for (uint32_t number = 0; number < quarterPoints; number++) {
270 currentValues = vld1q_f32(inputPtr);
272 currentIndexes = vaddq_f32(currentIndexes, indexIncrementValues);
273 currentIndexes_u = vcvtq_u32_f32(currentIndexes);
274 compareResults = vcgeq_f32(currentValues, minValues);
275 minValuesIndex = vorrq_u32(vandq_u32(compareResults, minValuesIndex),
276 vbicq_u32(currentIndexes_u, compareResults));
277 minValues = vminq_f32(currentValues, minValues);
281 vst1q_f32(minValuesBuffer, minValues);
282 vst1q_f32(minIndexesBuffer, vcvtq_f32_u32(minValuesIndex));
283 for (uint32_t number = 0; number < 4; number++) {
284 if (minValuesBuffer[number] < min) {
285 index = minIndexesBuffer[number];
286 min = minValuesBuffer[number];
287 }
else if (minValues[number] == min) {
288 if (index > minIndexesBuffer[number])
289 index = minIndexesBuffer[number];
293 for (uint32_t number = quarterPoints * 4; number < num_points; number++) {
294 if (source[number] < min) {
296 min = source[number];
299 target[0] = (uint32_t)index;
305#ifdef LV_HAVE_GENERIC
310 float min = source[0];
313 for (uint32_t
i = 1;
i < num_points; ++
i) {
314 if (source[
i] < min) {
328#ifndef INCLUDED_volk_32f_index_min_32u_u_H
329#define INCLUDED_volk_32f_index_min_32u_u_H
337#include <immintrin.h>
342 const uint32_t quarterPoints = num_points / 8;
344 float* inputPtr = (
float*)source;
346 __m256 indexIncrementValues = _mm256_set1_ps(8);
347 __m256 currentIndexes = _mm256_set_ps(-1, -2, -3, -4, -5, -6, -7, -8);
349 float min = source[0];
351 __m256 minValues = _mm256_set1_ps(min);
352 __m256 minValuesIndex = _mm256_setzero_ps();
353 __m256 compareResults;
354 __m256 currentValues;
359 for (uint32_t number = 0; number < quarterPoints; number++) {
360 currentValues = _mm256_loadu_ps(inputPtr);
362 currentIndexes = _mm256_add_ps(currentIndexes, indexIncrementValues);
363 compareResults = _mm256_cmp_ps(currentValues, minValues, _CMP_LT_OS);
364 minValuesIndex = _mm256_blendv_ps(minValuesIndex, currentIndexes, compareResults);
365 minValues = _mm256_blendv_ps(minValues, currentValues, compareResults);
369 _mm256_store_ps(minValuesBuffer, minValues);
370 _mm256_store_ps(minIndexesBuffer, minValuesIndex);
372 for (uint32_t number = 0; number < 8; number++) {
373 if (minValuesBuffer[number] < min) {
374 index = minIndexesBuffer[number];
375 min = minValuesBuffer[number];
376 }
else if (minValuesBuffer[number] == min) {
377 if (index > minIndexesBuffer[number])
378 index = minIndexesBuffer[number];
382 for (uint32_t number = quarterPoints * 8; number < num_points; number++) {
383 if (source[number] < min) {
385 min = source[number];
388 target[0] = (uint32_t)index;
395#include <smmintrin.h>
397static inline void volk_32f_index_min_32u_u_sse4_1(uint32_t* target,
401 const uint32_t quarterPoints = num_points / 4;
403 float* inputPtr = (
float*)source;
405 __m128 indexIncrementValues = _mm_set1_ps(4);
406 __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
408 float min = source[0];
410 __m128 minValues = _mm_set1_ps(min);
411 __m128 minValuesIndex = _mm_setzero_ps();
412 __m128 compareResults;
413 __m128 currentValues;
418 for (uint32_t number = 0; number < quarterPoints; number++) {
419 currentValues = _mm_loadu_ps(inputPtr);
421 currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
422 compareResults = _mm_cmplt_ps(currentValues, minValues);
423 minValuesIndex = _mm_blendv_ps(minValuesIndex, currentIndexes, compareResults);
424 minValues = _mm_blendv_ps(minValues, currentValues, compareResults);
428 _mm_store_ps(minValuesBuffer, minValues);
429 _mm_store_ps(minIndexesBuffer, minValuesIndex);
431 for (uint32_t number = 0; number < 4; number++) {
432 if (minValuesBuffer[number] < min) {
433 index = minIndexesBuffer[number];
434 min = minValuesBuffer[number];
435 }
else if (minValuesBuffer[number] == min) {
436 if (index > minIndexesBuffer[number])
437 index = minIndexesBuffer[number];
441 for (uint32_t number = quarterPoints * 4; number < num_points; number++) {
442 if (source[number] < min) {
444 min = source[number];
447 target[0] = (uint32_t)index;
453#include <xmmintrin.h>
458 const uint32_t quarterPoints = num_points / 4;
460 float* inputPtr = (
float*)source;
462 __m128 indexIncrementValues = _mm_set1_ps(4);
463 __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
465 float min = source[0];
467 __m128 minValues = _mm_set1_ps(min);
468 __m128 minValuesIndex = _mm_setzero_ps();
469 __m128 compareResults;
470 __m128 currentValues;
475 for (uint32_t number = 0; number < quarterPoints; number++) {
476 currentValues = _mm_loadu_ps(inputPtr);
478 currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
479 compareResults = _mm_cmplt_ps(currentValues, minValues);
480 minValuesIndex = _mm_or_ps(_mm_and_ps(compareResults, currentIndexes),
481 _mm_andnot_ps(compareResults, minValuesIndex));
482 minValues = _mm_or_ps(_mm_and_ps(compareResults, currentValues),
483 _mm_andnot_ps(compareResults, minValues));
487 _mm_store_ps(minValuesBuffer, minValues);
488 _mm_store_ps(minIndexesBuffer, minValuesIndex);
490 for (uint32_t number = 0; number < 4; number++) {
491 if (minValuesBuffer[number] < min) {
492 index = minIndexesBuffer[number];
493 min = minValuesBuffer[number];
494 }
else if (minValuesBuffer[number] == min) {
495 if (index > minIndexesBuffer[number])
496 index = minIndexesBuffer[number];
500 for (uint32_t number = quarterPoints * 4; number < num_points; number++) {
501 if (source[number] < min) {
503 min = source[number];
506 target[0] = (uint32_t)index;
513#include <riscv_vector.h>
516volk_32f_index_min_32u_rvv(uint32_t* target,
const float* src0, uint32_t num_points)
518 vfloat32m4_t vmin = __riscv_vfmv_v_f_f32m4(FLT_MAX, __riscv_vsetvlmax_e32m4());
519 vuint32m4_t vmini = __riscv_vmv_v_x_u32m4(0, __riscv_vsetvlmax_e32m4());
520 vuint32m4_t vidx = __riscv_vid_v_u32m4(__riscv_vsetvlmax_e32m4());
521 size_t n = num_points;
522 for (
size_t vl; n > 0; n -= vl, src0 += vl) {
523 vl = __riscv_vsetvl_e32m4(n);
524 vfloat32m4_t v = __riscv_vle32_v_f32m4(src0, vl);
525 vbool8_t m = __riscv_vmflt(v, vmin, vl);
526 vmin = __riscv_vfmin_tu(vmin, vmin, v, vl);
527 vmini = __riscv_vmerge_tu(vmini, vmini, vidx, m, vl);
528 vidx = __riscv_vadd(vidx, vl, __riscv_vsetvlmax_e32m4());
530 size_t vl = __riscv_vsetvlmax_e32m4();
531 float min = __riscv_vfmv_f(__riscv_vfredmin(
RISCV_SHRINK4(vfmin, f, 32, vmin),
532 __riscv_vfmv_v_f_f32m1(FLT_MAX, 1),
533 __riscv_vsetvlmax_e32m1()));
534 vbool8_t m = __riscv_vmfeq(vmin, min, vl);
535 *target = __riscv_vmv_x(__riscv_vslidedown(vmini, __riscv_vfirst(m, vl), vl));
static void volk_32f_index_min_32u_neon(uint32_t *target, const float *source, uint32_t num_points)
Definition volk_32f_index_min_32u.h:248
static void volk_32f_index_min_32u_a_sse(uint32_t *target, const float *source, uint32_t num_points)
Definition volk_32f_index_min_32u.h:126
static void volk_32f_index_min_32u_u_sse(uint32_t *target, const float *source, uint32_t num_points)
Definition volk_32f_index_min_32u.h:456
static void volk_32f_index_min_32u_generic(uint32_t *target, const float *source, uint32_t num_points)
Definition volk_32f_index_min_32u.h:308
static void volk_32f_index_min_32u_a_avx(uint32_t *target, const float *source, uint32_t num_points)
Definition volk_32f_index_min_32u.h:190
static void volk_32f_index_min_32u_u_avx(uint32_t *target, const float *source, uint32_t num_points)
Definition volk_32f_index_min_32u.h:340
#define __VOLK_ATTR_ALIGNED(x)
Definition volk_common.h:62
for i
Definition volk_config_fixed.tmpl.h:13
#define RISCV_SHRINK4(op, T, S, v)
Definition volk_rvv_intrinsics.h:24