Estoy tratando de crear un decodificador rápido para BPSK utilizando los intrínsecos AVX de Intel. Tengo un conjunto de números complejos que se representan como flotantes intercalados, pero debido a la modulación BPSK solo se necesita la parte real (o incluso los flotantes indexados). Cada float x se asigna a 0 , cuando x < 0 ya 1 si x >= 0 . Esto se logra usando la siguiente rutina:
static inline void normalize_bpsk_constellation_points(int32_t *out, const complex_t *in, size_t num) { static const __m256 _min_mask = _mm256_set1_ps(-1.0); static const __m256 _max_mask = _mm256_set1_ps(1.0); static const __m256 _mul_mask = _mm256_set1_ps(0.5); __m256 res; __m256i int_res; size_t i; gr_complex temp; float real; for(i = 0; i < num; i += COMPLEX_PER_AVX_REG){ res = _mm256_load_ps((float *)&in[i]); /* clamp them to avoid segmentation faults due to indexing */ res = _mm256_max_ps(_min_mask, _mm256_min_ps(_max_mask, res)); /* Scale accordingly for proper indexing -1->0, 1->1 */ res = _mm256_add_ps(res, _max_mask); res = _mm256_mul_ps(res, _mul_mask); /* And then round to the nearest integer */ res = _mm256_round_ps(res, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC); int_res = _mm256_cvtps_epi32(res); _mm256_store_si256((__m256i *) &out[2*i], int_res); } } En primer lugar, sujeto todos los flotantes recibidos en el rango [-1, 1] . Luego, después de una escala adecuada, el resultado se redondea al entero más cercano. Eso mapeará todos los flotantes por encima de 0.5 a 1 y todos los flotantes por debajo de 0.5 a 0 .
El procedimiento funciona bien si los flotantes de entrada son números normales. Sin embargo, debido a algunas situaciones en etapas anteriores, existe la posibilidad de que algunos flotantes de entrada sean NaN o -NaN . En este caso, los números 'NaN' se propagan a través de _mm256_max_ps() , _mm256_min_ps() y todas las demás funciones AVX que dan como resultado una asignación de enteros de -2147483648 que, por supuesto, hace que mi programa se bloquee debido a una indexación no válida.
¿Hay alguna solución para evitar este problema, o al menos establecer el NaN en 0 usando AVX ?
Para empezar, podría hacerlo de la manera más simple, comparar y enmascarar: (no probado)
res = _mm256_cmp_ps(res, _mm256_setzero_ps(), _CMP_NLT_US); ires = _mm256_srl_epi32(_mm256_castps_si256(res), 31);O shift y xor: (tampoco probado)
ires = _mm256_srl_epi32(_mm256_castps_si256(res), 31); ires = _mm256_xor_epi32(ires, _mm256_set1_epi32(1));Esta versión también se preocupará por el signo de NaN (e ignorará el NaN-ness).
Alternativa para no AVX2 (no probado)
res = _mm256_cmp_ps(res, _mm256_setzero_ps(), _CMP_NLT_US); res = _mm256_and_ps(res, _mm256_set1_ps(1.0f)); ires = _mm256_cvtps_epi32(res);Harold publicó una buena solución para la pregunta que realmente estaba haciendo, pero quiero dejar en claro que eliminar los valores de NaN mientras se sujeta es totalmente sencillo. Si alguno de los argumentos es NaN, MINPS y MAXPS simplemente devuelven el segundo argumento. Entonces, todo lo que necesita hacer es cambiar el orden de los argumentos y los NaN también se bloquearán. Por ejemplo, lo siguiente sujetaría NaNs a _min_mask:
res = _mm256_max_ps(_mm256_min_ps(_max_mask, res), _min_mask);