Vesta
Español
Código fuente

PAVGB, PAVGW

Media Packed Integers

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
NP 0F E0 /r1PAVGB mm1, mm2/m64AValidoValidoIntegers de byte no firmados promedio de mm2/m64 y mm1 con redondeo.
66 0F E0, /rPAVGB xmm1, xmm2/m128AValidoValidoIntegers de byte no firmados promedio de xmm2/m128 y xmm1 con redondeo.
NP 0F E3 /r1PAVGW mm1, mm2/m64AValidoValidoNúmero medio de enteros de palabras sin firmar de mm2/m64 y mm1 con redondeo.
66 0F E3 /rPAVGW xmm1, xmm2/m128AValidoValidoNúmero medio de enteros de palabras sin firmar de xmm2/m128 y xmm1 con redondeo.
VEX.128.66.0F.WIG E0 /rVPAVGB xmm1, xmm2, xmm3/m128BValidoValidoIntegers de byte no firmados promedio de xmm3/m128 y xmm2 con redondeo.
VEX.128.66.0F.WIG E3 /rVPAVGW xmm1, xmm2, xmm3/m128BValidoValidoNúmero medio de enteros de palabras sin firmar de xmm3/m128 y xmm2 con redondeo.
VEX.256.66.0F.WIG E0 /rVPAVGB ymm1, ymm2, ymm3/m256BValidoValidoIntegers de byte no firmados promedio de ymm2, y ymm3/m256 con redondeo y almacén a ymm1.
VEX.256.66.0F.WIG E3 /rVPAVGW ymm1, ymm2, ymm3/m256BValidoValidoNúmero medio de enteros de palabras sin firmar de ymm2, ymm3/m256 con redondeo a ymm1.
EVEX.128.66.0F.WIG E0 /rVPAVGB xmm1 {k1}{z}, xmm2, xmm3/m128CValidoValidoIntegers de byte envasados promedio de AVX512BW) OR AVX10.1 xmm2, y xmm3/m128 con redondeo y almacén a xmm1 bajo máscara de escritura k1.
EVEX.256.66.0F.WIG E0 /rVPAVGB ymm1 {k1}{z}, ymm2, ymm3/m256CValidoValidoIntegers de byte envasados promedio de AVX512BW) OR AVX10.1 ymm2, y ymm3/m256 con redondeo y almacén a ymm1 bajo máscara de escritura k1.
EVEX.512.66.0F.WIG E0 /rVPAVGB zmm1 {k1}{z}, zmm2, zmm3/m512CValidoValidoIntegers de byte envasados promedio de OR AVX10.1 zmm2, y zmm3/m512 con redondeo y almacén a zmm1 bajo máscara de escritura k1.
EVEX.128.66.0F.WIG E3 /rVPAVGW xmm1 {k1}{z}, xmm2, xmm3/m128CValidoValidoNúmero medio de enteros de palabras sin firmar de AVX512BW) OR AVX10.1 xmm2, xmm3/m128 con redondeo a xmm1 bajo máscara de escritura k1.
EVEX.256.66.0F.WIG E3 /rVPAVGW ymm1 {k1}{z}, ymm2, ymm3/m256CValidoValidoNúmero medio de enteros de palabras sin firmar de AVX512BW) OR AVX10.1 ymm2, ymm3/m256 con redondeo a ymm1 bajo máscara de escritura k1.
EVEX.512.66.0F.WIG E3 /rVPAVGW zmm1 {k1}{z}, zmm2, zmm3/m512CValidoValidoNúmero medio de enteros de palabras sin firmar de OR AVX10.1 zmm2, zmm3/m512 con redondeo a zmm1 bajo má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 lectura y 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. vex.vvvv lecturaprefijo VEX, 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

C

  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 un promedio SIMD del enteros sin signo empacado del operando de origen (segundo operando) y el operando de destino (primer operando), y almacena los resultados en el operando de destino. Para cada par de elementos de datos correspondientes en el primer y segundo operandos, los elementos se agregan juntos, un 1 se añade a la suma temporal, y ese resultado se desplaza a la derecha un poco de posición.

La instrucción (V)PAVGB funciona en los bytes sin firmar empaquetados y la instrucción (V)PAVGW funciona en las palabras no firmadas.

En modo de 64 bits y no codificado con VEX/EVEX, utilizando un prefijo REX en forma de REX.R permite esta instrucción para acceder a registros adicionales (XMM8-XMM15).

Legacy SSE instrucciones: El operando de origen puede ser un registro de tecnología MMX o una ubicación de memoria de 64 bits. El operando de destino puede ser un registro de tecnología MMX.

128-bit Legacy SSE versión: El primer operando de origen es un registro XMM. El segundo operando puede ser un registro XMM o una 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 correspondiente son sin modificar.

EVEX.512 versión codificada: El primer operando de origen es un registro ZMM. El segundo operando de origen es un registro ZMM o una ubicación de memoria de 512 bits. El operando de destino es un registro ZMM.

VEX.256 y EVEX.256 versiones codificadas: El primer operando de origen es un registro YMM. El segundo operando de origen es un registro YMM o una ubicación de memoria de 256 bits. El operando de destino es un registro YMM.

VEX.128 y EVEX.128 versiones codificadas: El primer operando de origen es un registro XMM. El segundo operando de origen es un registro XMM o 128 bits ubicación de memoria. El operando de destino es un registro XMM. Los bits superiores (MAXVL- 1:128) del destino de registro correspondiente se ponen a cero.

Operación

PAVGB (With 64-bit Operands)
    DEST[7:0] := (SRC[7:0] + DEST[7:0] + 1) >> 1; (* Temp sum before shifting is 9 bits *)
    (* Repeat operation performed for bytes 2 through 6 *)
    DEST[63:56] := (SRC[63:56] + DEST[63:56] + 1) >> 1;

PAVGW (With 64-bit Operands)
    DEST[15:0] := (SRC[15:0] + DEST[15:0] + 1) >> 1; (* Temp sum before shifting is 17 bits *)
    (* Repeat operation performed for words 2 and 3 *)
    DEST[63:48] := (SRC[63:48] + DEST[63:48] + 1) >> 1;

PAVGB (With 128-bit Operands)
    DEST[7:0] := (SRC[7:0] + DEST[7:0] + 1) >> 1; (* Temp sum before shifting is 9 bits *)
    (* Repeat operation performed for bytes 2 through 14 *)
    DEST[127:120] := (SRC[127:120] + DEST[127:120] + 1) >> 1;

PAVGW (With 128-bit Operands)
    DEST[15:0] := (SRC[15:0] + DEST[15:0] + 1) >> 1; (* Temp sum before shifting is 17 bits *)
    (* Repeat operation performed for words 2 through 6 *)
    DEST[127:112] := (SRC[127:112] + DEST[127:112] + 1) >> 1;


VPAVGB (VEX.128 Encoded Version)
    DEST[7:0] := (SRC1[7:0] + SRC2[7:0] + 1) >> 1;
    (* Repeat operation performed for bytes 2 through 15 *)
    DEST[127:120] := (SRC1[127:120] + SRC2[127:120] + 1) >> 1
    DEST[MAXVL-1:128] := 0

VPAVGW (VEX.128 Encoded Version)
    DEST[15:0] := (SRC1[15:0] + SRC2[15:0] + 1) >> 1;
    (* Repeat operation performed for 16-bit words 2 through 7 *)
    DEST[127:112] := (SRC1[127:112] + SRC2[127:112] + 1) >> 1
    DEST[MAXVL-1:128] := 0

VPAVGB (VEX.256 Encoded Instruction)
    DEST[7:0] := (SRC1[7:0] + SRC2[7:0] + 1) >> 1; (* Temp sum before shifting is 9 bits *)
    (* Repeat operation performed for bytes 2 through 31)
    DEST[255:248] := (SRC1[255:248] + SRC2[255:248] + 1) >> 1;

VPAVGW (VEX.256 Encoded Instruction)

DEST[15:0] := (SRC1[15:0] + SRC2[15:0] + 1) >> 1; (* Temp sum before shifting is 17 bits *)

(* Repeat operation performed for words 2 through 15)

DEST[255:14]) := (SRC1[255:240] + SRC2[255:240] + 1) >> 1;

VPAVGB (EVEX encoded versions)

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

FOR j := 0 TO KL-1

i := j * 8

IF k1[j] OR *no writemask*

     THEN DEST[i+7:i] := (SRC1[i+7:i] + SRC2[i+7:i] + 1) >> 1; (* Temp sum before shifting is 9 bits *)

     ELSE

             IF *merging-masking*           ; merging-masking

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

                 ELSE *zeroing-masking*     ; zeroing-masking

                    DEST[i+7:i] = 0

             FI

FI;

ENDFOR;

DEST[MAXVL-1:VL] := 0

VPAVGW (EVEX Encoded Versions)

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

FOR j := 0 TO KL-1

i := j * 16

IF k1[j] OR *no writemask*

     THEN DEST[i+15:i] := (SRC1[i+15:i] + SRC2[i+15:i] + 1) >> 1

                                            ; (* Temp sum before shifting is 17 bits *)

     ELSE

             IF *merging-masking*           ; merging-masking

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

                 ELSE *zeroing-masking*     ; zeroing-masking

                    DEST[i+15:i] = 0

             FI

FI;

ENDFOR;

DEST[MAXVL-1:VL] := 0

Intel C/C++ compilador intrínseco

VPAVGB __m512i _mm512_avg_epu8( __m512i a, __m512i b);
VPAVGW __m512i _mm512_avg_epu16( __m512i a, __m512i b);
VPAVGB __m512i _mm512_mask_avg_epu8(__m512i s, __mmask64 m, __m512i a, __m512i b);
VPAVGW __m512i _mm512_mask_avg_epu16(__m512i s, __mmask32 m, __m512i a, __m512i b);
VPAVGB __m512i _mm512_maskz_avg_epu8( __mmask64 m, __m512i a, __m512i b);
VPAVGW __m512i _mm512_maskz_avg_epu16( __mmask32 m, __m512i a, __m512i b);
VPAVGB __m256i _mm256_mask_avg_epu8(__m256i s, __mmask32 m, __m256i a, __m256i b);
VPAVGW __m256i _mm256_mask_avg_epu16(__m256i s, __mmask16 m, __m256i a, __m256i b);
VPAVGB __m256i _mm256_maskz_avg_epu8( __mmask32 m, __m256i a, __m256i b);
VPAVGW __m256i _mm256_maskz_avg_epu16( __mmask16 m, __m256i a, __m256i b);
VPAVGB __m128i _mm_mask_avg_epu8(__m128i s, __mmask16 m, __m128i a, __m128i b);
VPAVGW __m128i _mm_mask_avg_epu16(__m128i s, __mmask8 m, __m128i a, __m128i b);
VPAVGB __m128i _mm_maskz_avg_epu8( __mmask16 m, __m128i a, __m128i b);
VPAVGW __m128i _mm_maskz_avg_epu16( __mmask8 m, __m128i a, __m128i b);
PAVGB __m64 _mm_avg_pu8 (__m64 a, __m64 b) PAVGW __m64 _mm_avg_pu16 (__m64 a, __m64 b) (V)PAVGB __m128i _mm_avg_epu8 ( __m128i a, __m128i b) (V)PAVGW __m128i _mm_avg_epu16 ( __m128i a, __m128i b) VPAVGB __m256i _mm256_avg_epu8 ( __m256i a, __m256i b) VPAVGW __m256i _mm256_avg_epu16 ( __m256i a, __m256i b);

Banderas afectadas

None.

Excepciones numéricas

None.

Otras excepciones

Instrucciones no codificadas por EVEX, ver Tabla 2-21, "Tipo 4 Condiciones de Excepción de Clase".

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

Fuentes