Vesta
Español
Código fuente

VPCMPW, VPCMPUW

Comparar Valores de Word empaquetados en Mask

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
EVEX.128.66.0F3A.W1 3F /r ibVPCMPW k1 {k2}, xmm2, xmm3/m128, imm8AValidoValidoCompare integers de palabras empaquetadas en AVX512BW) OR xmm3/m128 y xmm2 con bits 2:0 de imm8 como predicado de comparación AVX10.1 con máscara de escritura k2 y dejar el resultado en el registro de máscaras k1.
EVEX.256.66.0F3A.W1 3F /r ibVPCMPW k1 {k2}, ymm2, ymm3/m256, imm8AValidoValidoCompare integers de palabras empaquetadas en AVX512BW) OR ymm3/m256 y ymm2 con bits 2:0 de imm8 como predicado de comparación AVX10.1 con máscara de escritura k2 y dejar el resultado en el registro de máscaras k1.
EVEX.512.66.0F3A.W1 3F /r ibVPCMPW k1 {k2}, zmm2, zmm3/m512, imm8AValidoValidoCompara los enteros de palabras firmados empaquetados en OR AVX10.1 zmm3/m512 y zmm2 usando bits 2:0 de imm8 como predicado de comparación con máscara de escritura k2 y dejar el resultado en el registro de máscaras k1.
EVEX.128.66.0F3A.W1 3E /r ibVPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8AValidoValidoCompare integers de palabras empaquetadas en AVX512BW) OR xmm3/m128 y xmm2 utilizando bits 2:0 de imm8 como predicado de comparación AVX10.1 con máscara de escritura k2 y dejar el resultado en el registro de máscaras k1.
EVEX.256.66.0F3A.W1 3E /r ibVPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8AValidoValidoCompare integers de palabras empaquetadas en AVX512BW) OR ymm3/m256 y ymm2 utilizando bits 2:0 de imm8 como predicado de comparación AVX10.1 con máscara de escritura k2 y dejar el resultado en el registro de máscaras k1.
EVEX.512.66.0F3A.W1 3E /r ibVPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8AValidoValidoCompare integers de palabras empaquetadas en OR AVX10.1 zmm3/m512 y zmm2 usando bits 2:0 de imm8 como un predicado de comparación con máscara de escritura k2 y dejar el resultado en el registro de máscaras 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. evex.vvvv lecturaprefijo EVEX, campo vvvv (invertido)
  3. 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 Mem

Coste medido

Cargando las mediciones de arch-data...

Descripción

Realiza una comparación SIMD de la palabra entero empaquetado en el segundo operando de origen y el primer operando de origen y devuelve los resultados de la comparación con la máscara operando de destino. La comparación predicate operando (inmediate byte) especifica el tipo de comparación realizada en cada par de valores empaquetados en los dos operandos de origen. El resultado de cada comparación es un solo resultado de bit de máscara de 1 (comparison true) o 0 (comparison false).

VPCMPW realiza una comparación entre pares de valores de palabras firmados.

VPCMPUW realiza una comparación entre pares de valores de palabras no firmados.

El primer operando de origen (segundo operando) es un registro ZMM/YMM/XMM. El segundo operando de origen puede ser un registro ZMM/YMM/XMM o un 512/256/128-bit ubicación de memoria. El operando de destino (primer operando) es un registro de máscaras k1. Se realizan comparaciones de hasta 32/16/8 con los resultados escritos al operando de destino bajo la máscara de escritura k2.

El predicate de comparación operando es un 8-bit inmediato: bits 2:0 definen el tipo de comparación a realizar. Los bits 3 a 7 de los inmediatos están reservados. Compiler puede implementar la pseudo-op mnemónica lista en la tabla 5-19.

Operación

CASE (COMPARISON PREDICATE) OF
    0: OP := EQ;
    1: OP := LT;
    2: OP := LE;
    3: OP := FALSE;
    4: OP := NEQ;
    5: OP := NLT;
    6: OP := NLE;
    7: OP := TRUE;

ESAC;

VPCMPW (EVEX encoded versions)

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

FOR j := 0 TO KL-1

i := j * 16

IF k2[j] OR *no writemask*

     THEN

             ICMP := SRC1[i+15:i] OP SRC2[i+15:i];

             IF CMP = TRUE

             THEN DEST[j] := 1;

             ELSE DEST[j] := 0; FI;

     ELSE DEST[j] = 0                      ; zeroing-masking only

FI;

ENDFOR

DEST[MAX_KL-1:KL] := 0

VPCMPUW (EVEX encoded versions)

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

FOR j := 0 TO KL-1

i := j * 16

IF k2[j] OR *no writemask*

     THEN

             CMP := SRC1[i+15:i] OP SRC2[i+15:i];

             IF CMP = TRUE

             THEN DEST[j] := 1;

             ELSE DEST[j] := 0; FI;

     ELSE DEST[j] = 0                      ; zeroing-masking only

FI;

ENDFOR

DEST[MAX_KL-1:KL] := 0

Intel C/C++ compilador intrínseco

VPCMPW __mmask32 _mm512_cmp_epi16_mask( __m512i a, __m512i b, int cmp);
VPCMPW __mmask32 _mm512_mask_cmp_epi16_mask( __mmask32 m, __m512i a, __m512i b, int cmp);
VPCMPW __mmask16 _mm256_cmp_epi16_mask( __m256i a, __m256i b, int cmp);
VPCMPW __mmask16 _mm256_mask_cmp_epi16_mask( __mmask16 m, __m256i a, __m256i b, int cmp);
VPCMPW __mmask8 _mm_cmp_epi16_mask( __m128i a, __m128i b, int cmp);
VPCMPW __mmask8 _mm_mask_cmp_epi16_mask( __mmask8 m, __m128i a, __m128i b, int cmp);
VPCMPW __mmask32 _mm512_cmp[eq|ge|gt|le|lt|neq]_epi16_mask( __m512i a, __m512i b);
VPCMPW __mmask32 _mm512_mask_cmp[eq|ge|gt|le|lt|neq]_epi16_mask( __mmask32 m, __m512i a, __m512i b);
VPCMPW __mmask16 _mm256_cmp[eq|ge|gt|le|lt|neq]_epi16_mask( __m256i a, __m256i b);
VPCMPW __mmask16 _mm256_mask_cmp[eq|ge|gt|le|lt|neq]_epi16_mask( __mmask16 m, __m256i a, __m256i b);
VPCMPW __mmask8 _mm_cmp[eq|ge|gt|le|lt|neq]_epi16_mask( __m128i a, __m128i b);
VPCMPW __mmask8 _mm_mask_cmp[eq|ge|gt|le|lt|neq]_epi16_mask( __mmask8 m, __m128i a, __m128i b);
VPCMPUW __mmask32 _mm512_cmp_epu16_mask( __m512i a, __m512i b, int cmp);
VPCMPUW __mmask32 _mm512_mask_cmp_epu16_mask( __mmask32 m, __m512i a, __m512i b, int cmp);
VPCMPUW __mmask16 _mm256_cmp_epu16_mask( __m256i a, __m256i b, int cmp);
VPCMPUW __mmask16 _mm256_mask_cmp_epu16_mask( __mmask16 m, __m256i a, __m256i b, int cmp);
VPCMPUW __mmask8 _mm_cmp_epu16_mask( __m128i a, __m128i b, int cmp);
VPCMPUW __mmask8 _mm_mask_cmp_epu16_mask( __mmask8 m, __m128i a, __m128i b, int cmp);
VPCMPUW __mmask32 _mm512_cmp[eq|ge|gt|le|lt|neq]_epu16_mask( __m512i a, __m512i b, int cmp);
VPCMPUW __mmask32 _mm512_mask_cmp[eq|ge|gt|le|lt|neq]_epu16_mask( __mmask32 m, __m512i a, __m512i b, int cmp);
VPCMPUW __mmask16 _mm256_cmp[eq|ge|gt|le|lt|neq]_epu16_mask( __m256i a, __m256i b, int cmp);
VPCMPUW __mmask16 _mm256_mask_cmp[eq|ge|gt|le|lt|neq]_epu16_mask( __mmask16 m, __m256i a, __m256i b, int cmp);
VPCMPUW __mmask8 _mm_cmp[eq|ge|gt|le|lt|neq]_epu16_mask( __m128i a, __m128i b, int cmp);
VPCMPUW __mmask8 _mm_mask_cmp[eq|ge|gt|le|lt|neq]_epu16_mask( __mmask8 m, __m128i a, __m128i b, int cmp);

SIMD coma flotante Excepciones

None

Otras excepciones

Instrucciones de código EVEX, ver Excepciones Tipo E4.nb en la tabla 2-51, "Tipo E4 Clase Condiciones de Excepción".

Fuentes