¿Cuál es la forma más eficiente de manejar el desbordamiento de multiplicación entera con saturación utilizando las instrucciones intrínsecas de ARM Neon?
Tengo la siguiente multiplicación entre 2 vectores de 16 bits:
int16x8_t dx;
int16x8_t dy;
int16x8_t dxdy = vmulq_s16(dx, dy);
En caso de que dx y dy sean lo suficientemente grandes, el resultado puede desbordarse.
Me gustaría limitar la multiplicación resultante entre los valores MININT16 y MAXINT16.
Hasta ahora no he encontrado una forma de hacerlo sin convertir primero los valores a int32. Esto es lo que hago actualmente:
int32x4_t dx_low4 = vmovl_s16(simde_vget_low_s16(dx)); // obtener los 4 elementos inferiores y ampliar
int32x4_t dx_high4 = vmovl_high_s16(dx); // ampliar los 4 elementos superiores
int32x4_t dy_low4 = vmovl_s16(simde_vget_low_s16(dy)); // obtener los 4 elementos inferiores y ampliar
int32x4_t dy_high4 = vmovl_high_s16(dy); // ampliar los 4 elementos superiores
int32x4_t dxdy_low = vmulq_s32(dx_low4, dy_low4);
int32x4_t dxdy_high = vmulq_s32(dx_high4, dy_high4);
// combinar y manejar la saturación:
int16x8_t dxdy = vcombine_s16(vqmovn_s32(dxdy_low), vqmovn_s32(dxdy_high));
¿Existe una forma de lograr esto de manera más eficiente?
davy.ai
Desafortunadamente, no hay una forma de lograr cálculos aritméticos de saturación directamente con vectores de 16 bits en NEON. El enfoque que estás utilizando, convirtiendo a vectores de 32 bits y luego volviendo a 16 bits, es la forma más eficiente de lograr cálculos aritméticos de saturación en este caso.
Sin embargo, si tienes restricciones en la velocidad de tu código y la magnitud de los valores en “dx” y “dy”, es posible que puedas lograr el resultado deseado utilizando otros métodos, como escalar las entradas o utilizar aritmética de punto fijo. Estos métodos pueden requerir mayor complejidad de código pero pueden ser más eficientes en algunos casos.