Vesta
Español
Código fuente

SQRTPS

Root cuadrado de valores en coma flotante de precisión simple

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
NP 0F 51 /rSQRTPS xmm1, xmm2/m128AValidoValidoComputes Square Roots de los valores en coma flotante de precisión simple empaquetados en xmm2/m128 y almacena el resultado en xmm1.
VEX.128.0F.WIG 51 /rVSQRTPS xmm1, xmm2/m128AValidoValidoComputes Square Roots de los valores en coma flotante de precisión simple empaquetados en xmm2/m128 y almacena el resultado en xmm1.
VEX.256.0F.WIG 51/rVSQRTPS ymm1, ymm2/m256AValidoValidoComputes Square Roots de los valores en coma flotante de precisión simple empaquetados en ymm2/m256 y almacena el resultado en ymm1.
EVEX.128.0F.W0 51 /rVSQRTPS xmm1 {k1}{z}, xmm2/m128/m32bcstBValidoValidoCompute Roots cuadrados de la precisión única empaquetadaAVX512FOvalores en coma flotantedentroxmm2/m128/m32bcst y tiendasAVX10.1el resultado enxmm1sujeto amáscara de escritura k1.
EVEX.256.0F.W0 51 /rVSQRTPS ymm1 {k1}{z}, ymm2/m256/m32bcstBValidoValidoCompute Roots cuadrados de la precisión única empaquetadaAVX512FOvalores en coma flotantedentroymm2/m256/m32bcst y tiendasAVX10.1el resultado enymm1sujeto amáscara de escritura k1.
EVEX.512.0F.W0 51/rVSQRTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}BValidoValidoComputes Roots cuadrados de la única precisión oAVX10.1 valores en coma flotantedentrozmm2/m512/m32bcst y almacena el resultado enzmm1sujeto amáscara de escritura k1.

Codificacion de operandos

Cada modo es un valor de la columna Op/En de arriba. Dice en que campo de la instruccion codificada va cada operando, en el orden en que se escriben, y si la instruccion lo lee, lo escribe o ambas cosas.

A

  1. modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
  2. modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

B

  1. modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
  2. modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

Tupla: Full

Coste medido

Cargando las mediciones de arch-data...

Descripción

Realiza una computación SIMD de las raíces cuadradas de los cuatro, ocho o dieciséis valores en coma flotante de precisión simple empaquetados en el operando de origen (segundo operando) almacena los resultados de coma flotante de precisión simple empaquetados en el operando de destino.

EVEX.512 versiones codificadas: El operando de origen es un registro ZMM/YMM/XMM, un 512/256/128-bit ubicación de memoria o un vector 512/256/128-bit transmitido desde una ubicación de memoria de 32 bits. El operando de destino es un registro ZMM/YMM/XMM actualizado según la máscara de escritura.

VEX.256 versión codificada: El operando de origen es un registro YMM o una ubicación de memoria de 256 bits. El operando de destino es un registro YMM. Los bits superiores (MAXVL-1:256) del destino de registro ZMM correspondiente se ponen a cero.

VEX.128 versión codificada: el operando de origen segundo operando de origen o una ubicación de memoria de 128 bits. El operando de destino es un registro XMM. Los bits superiores (MAXVL-1:128) del destino de registro ZMM correspondiente se ponen a cero.

128-bit Legacy SSE versión: La segunda fuente puede ser un registro XMM o ubicación de memoria de 128 bits. El destino no es distinto del registro XMM de primera fuente y los bits superiores (MAXVL-1:128) del destino de registro ZMM correspondiente no son modificados.

Nota: VEX.vvvv y EVEX.vvvv están reservados y deben ser 1111b instrucciones de lo contrario #UD.

Operación

VSQRTPS (EVEX Encoded Versions)

(KL, VL) = (4, 128), (8, 256), (16, 512)

IF (VL = 512) AND (EVEX.b = 1) AND (SRC *is register*)

     THEN

          SET_ROUNDING_MODE_FOR_THIS_INSTRUCTION(EVEX.RC);

     ELSE

          SET_ROUNDING_MODE_FOR_THIS_INSTRUCTION(MXCSR.RC);

FI;

FOR j := 0 TO KL-1

     i := j * 32

     IF k1[j] OR *no writemask* THEN

                  IF (EVEX.b = 1) AND (SRC *is memory*)

                       THEN DEST[i+31:i] := SQRT(SRC[31:0])

                       ELSE DEST[i+31:i] := SQRT(SRC[i+31:i])

                  FI;

          ELSE

                  IF *merging-masking*    ; merging-masking

                       THEN *DEST[i+31:i] remains unchanged*

                       ELSE               ; zeroing-masking

                       DEST[i+31:i] := 0

                  FI

     FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VSQRTPS (VEX.256 Encoded Version)
DEST[31:0] := SQRT(SRC[31:0])
DEST[63:32] := SQRT(SRC[63:32])
DEST[95:64] := SQRT(SRC[95:64])
DEST[127:96] := SQRT(SRC[127:96])
DEST[159:128] := SQRT(SRC[159:128])
DEST[191:160] := SQRT(SRC[191:160])
DEST[223:192] := SQRT(SRC[223:192])
DEST[255:224] := SQRT(SRC[255:224])

VSQRTPS (VEX.128 Encoded Version)
DEST[31:0] := SQRT(SRC[31:0])
DEST[63:32] := SQRT(SRC[63:32])
DEST[95:64] := SQRT(SRC[95:64])
DEST[127:96] := SQRT(SRC[127:96])
DEST[MAXVL-1:128] := 0

SQRTPS (128-bit Legacy SSE Version)
DEST[31:0] := SQRT(SRC[31:0])
DEST[63:32] := SQRT(SRC[63:32])
DEST[95:64] := SQRT(SRC[95:64])
DEST[127:96] := SQRT(SRC[127:96])
DEST[MAXVL-1:128] (Unmodified)

Intel C/C++ compilador intrínseco

VSQRTPS __m512 _mm512_sqrt_round_ps(__m512 a, int r);
VSQRTPS __m512 _mm512_mask_sqrt_round_ps(__m512 s, __mmask16 k, __m512 a, int r);
VSQRTPS __m512 _mm512_maskz_sqrt_round_ps( __mmask16 k, __m512 a, int r);
VSQRTPS __m256 _mm256_sqrt_ps (__m256 a);
VSQRTPS __m256 _mm256_mask_sqrt_ps(__m256 s, __mmask8 k, __m256 a, int r);
VSQRTPS __m256 _mm256_maskz_sqrt_ps( __mmask8 k, __m256 a, int r);
SQRTPS __m128 _mm_sqrt_ps (__m128 a);
VSQRTPS __m128 _mm_mask_sqrt_ps(__m128 s, __mmask8 k, __m128 a, int r);
VSQRTPS __m128 _mm_maskz_sqrt_ps( __mmask8 k, __m128 a, int r);

SIMD coma flotante Excepciones

Invalid, Precision, Denormal.

Otras excepciones

Instrucciones no codificadas en EVEX, ver Tabla 2-19, "Tipo 2 Condiciones de Excepción," adicionalmente:

#UD               If VEX.vvvv != 1111B.

Instrucciones codificadas por EVEX, ver Tabla 2-48, "Tipo E2 Clase Condiciones de Excepción," adicionalmente:

#UD               If EVEX.vvvv != 1111B.

Fuentes