I understand that operations across SIMD lanes should generally be avoided. However, sometimes it has to be done.
I am using AVX2 intrinsics, and have 8 floating point values in an __m256.
I want to know the lowest value in this vector, and to complicate matters: also in which slot this was.
My current solution makes a round trip to memory, which I don't like:
float closestvals[8]; _mm256_store_ps( closestvals, closest8 ); float closest = closestvals[0]; int closestidx = 0; for ( int k=1; k<8; ++k ) { if ( closestvals[k] < closest ) { closest = closestvals[ k ]; closestidx = k; } }
What would be a good way to do this without going to/from memory?
You can try this:
#include <stdio.h> #include <x86intrin.h> #include <math.h> /* gcc -O3 -Wall -m64 -march=haswell hor_min.c */ int print_vec_ps(__m256 x); int main() { float x[8]={1.2f, 3.6f, 2.1f, 9.4f, 4.0f, 0.1f, 8.9f, 3.3f}; /* Note that the results are not useful if one of the inputs is a 'not a number'. The input below leads to indx = 32 (!) */ // float x[8]={1.2f, 3.6f, 2.1f, NAN, 4.0f, 2.0f , 8.9f, 3.3f}; __m256 v0 = _mm256_load_ps(x); /* _mm256_shuffle_ps instead of _mm256_permute_ps is also possible, see Peter Cordes' comments */ __m256 v1 = _mm256_permute_ps(v0,0b10110001); /* swap floats: 0<->1, 2<->3, 4<->5, 6<->7 */ __m256 v2 = _mm256_min_ps(v0,v1); __m256 v3 = _mm256_permute_ps(v2,0b01001110); /* swap floats */ __m256 v4 = _mm256_min_ps(v2,v3); __m256 v5 = _mm256_castpd_ps(_mm256_permute4x64_pd(_mm256_castps_pd(v4),0b01001110)); /* swap 128-bit lanes */ __m256 v_min = _mm256_min_ps(v4,v5); __m256 mask = _mm256_cmp_ps(v0,v_min,0); int indx = _tzcnt_u32(_mm256_movemask_ps(mask)); printf(" 7 6 5 4 3 2 1 0\n"); printf("v0 = ");print_vec_ps(v0 ); printf("v1 = ");print_vec_ps(v1 ); printf("v2 = ");print_vec_ps(v2 ); printf("\nv3 = ");print_vec_ps(v3 ); printf("v4 = ");print_vec_ps(v4 ); printf("\nv5 = ");print_vec_ps(v5 ); printf("v_min = ");print_vec_ps(v_min ); printf("mask = ");print_vec_ps(mask ); printf("indx = ");printf("%d\n",indx); return 0; } int print_vec_ps(__m256 x){ float v[8]; _mm256_storeu_ps(v,x); printf("%5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f\n", v[7],v[6],v[5],v[4],v[3],v[2],v[1],v[0]); return 0; }
Output:
./a.out 7 6 5 4 3 2 1 0 v0 = 3.30 8.90 0.10 4.00 9.40 2.10 3.60 1.20 v1 = 8.90 3.30 4.00 0.10 2.10 9.40 1.20 3.60 v2 = 3.30 3.30 0.10 0.10 2.10 2.10 1.20 1.20 v3 = 0.10 0.10 3.30 3.30 1.20 1.20 2.10 2.10 v4 = 0.10 0.10 0.10 0.10 1.20 1.20 1.20 1.20 v5 = 1.20 1.20 1.20 1.20 0.10 0.10 0.10 0.10 v_min = 0.10 0.10 0.10 0.10 0.10 0.10 0.10 0.10 mask = 0.00 0.00 -nan 0.00 0.00 0.00 0.00 0.00 indx = 5
In the previous version of this answer, the 128-bit lanes were swapped with _mm256_permute2f128_ps. In this updated answer _mm256_permute2f128_ps is replaced by _mm256_permute4x64_pd, which is faster on AMD CPUs and on Intel KNL, see @Peter Cordes' comments. But note that _mm256_permute4x64_pd requires AVX2, while AVX is sufficient for _mm256_permute2f128_ps.
Also note that the results of this code are useless if one of the input values is a 'not a number' (NAN).
