Vesta
Español
Código fuente

VDBPSADBW

Double Block Packed Sum-Absolute-Differences (SAD) on Unsigned Bytes

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
EVEX.128.66.0F3A.W0 42 /r ibVDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8AValidoValidoCompute packedSADresultados de bytes no firmados enAVX512BW) O bloque de palabras desdexmm2con bytes sin firma de dwordAVX10.1bloques transformadosxmm3/m128usando los controles del shuffleimm8. Los resultados están escritosxmm1por debajola máscara de escritura k1.
EVEX.256.66.0F3A.W0 42 /r ibVDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8AValidoValidoCompute packedSADresultados de bytes no firmados enAVX512BW) O bloque de palabras desdeymm2con bytes sin firma de dwordAVX10.1bloques transformadosymm3/m256usando los controles del shuffleimm8. Los resultados están escritosymm1por debajola máscara de escritura k1.
EVEX.512.66.0F3A.W0 42 /r ibVDBPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8AValidoValidoCompute packedSADpalabra resultados de bytes no firmados en ORAVX10.1bloque de palabraszmm2con bytes sin firma de bloques dword transformadoszmm3/m512usando los controles del shuffleimm8. Los resultados están escritoszmm1por debajola 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 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
  4. imm8byte inmediato que sigue a la instruccion

Tupla: Full Mem

Coste medido

Cargando las mediciones de arch-data...

Descripción

Compute packed SAD (sumo de diferencias absolutas) resultados de palabras de bytes no firmados de dos elementos dword de 32 bits. Los resultados de la palabra SAD empaquetados se calculan en múltiples superblocks de qword, produciendo 4 resultados de la palabra SAD en cada superbloque de 64 bits del registro de destino.

Dentro de cada super bloque de resultados de palabras empaquetadas, los resultados de SAD de dos elementos dword de 32 bits se calculan de la siguiente manera:

a qword superblock de un vector intermedio con un elemento de dword estacionario en la superbloque de qword correspondiente del primer operando de origen. El vector intermedio, véase "Tmp1" en la Figura 5-8, se construye a partir del segundo operando de origen el byte imm8 como control de shuffle para seleccionar elementos dword dentro de un carril de 128 bits del segundo operando de origen. Los dos elementos de dword deslizante en una superbloque de qword de Tmp1 se encuentran en byte offset 0 y 1 dentro del superbloque, respectivamente. El elemento dword estacionario en el superbloque qword del primer operando de origen se encuentra en offset 0.

un superbloque de qword del vector intermedio Tmp1 con un segundo elemento de dword estacionario en el superbloque de qword correspondiente del primer operando de origen. Los dos elementos de dword deslizante en una superbloque de qword de Tmp1 se encuentran en byte offset 2and 3 dentro del superblock, respectivamente. El elemento dword estacionario en el superbloque qword del primer operando de origen se encuentra en offset 4.

vector intermedio es seleccionado por un campo de dos bits dentro del byte imm8 en los 128-bits correspondientes del segundo operando de origen. El byte imm8 sirve como control dword shuffle dentro de cada vía de 128 bits del vector intermedio y el segundo operando de origen, de forma similar a PSHUFD.

El primer operando de origen es un registro ZMM/YMM/XMM. El segundo operando de origen es un registro ZMM/YMM/XMM, o un 512/256/128-bit ubicación de memoria. El operando de destino es actualizado condicionalmente basado en máscara de escritura k1 a 16-bit palabra granularidad.

                            127+128*n                   95+128*n                    63+128*n                               31+128*n                 128*n
                                               DW3                    DW2                        DW1                                 DW0

128-bit Lane of Src2

                                                    imm8 shuffle control                                                                  00B: DW0

01B: DW1

                                                                             7      5            3                 10                     10B: DW2

11B: DW3

                                127+128*n               95+128*n                    63+128*n                               31+128*n                 128*n

128-bit Lane of Tmp1

Tmp1 qword superblock

55 47 39 31 24 39 31 23 15 8

                                      Tmp1 sliding dword                                                                                 Tmp1 sliding dword

63 55 47 39 32 31 23 15 7 0

                                                    Src1 stationary dword 1                       ____                                    Src1 stationary dword 0

_ _ _ _ abs abs abs abs

abs abs abs abs

                         +                          47 39 31 23 16                                                 +
                                                                             Tmp1 sliding dword                              31 23 15 7 0

Tmp1 dword deslizante

                                                    63 55 47 39 32                                                     31 23 15 7 0                          Src1 stationary dword 0

Dword estacionaria Src1 abdominales abdominales abdominales abdominales abdominales

                                                    +                                                                                     +
                                             63     47                          31                                     15                    0

Destino qword superblock

Figure 5-8. 64-bit Super Block of SAD Operation in VDBPSADBW

Operación

VDBPSADBW (EVEX Encoded Versions)
(KL, VL) = (8, 128), (16, 256), (32, 512)
Selection of quadruplets:
FOR I = 0 to VL step 128

    TMP1[I+31:I] := select (SRC2[I+127: I], imm8[1:0])
    TMP1[I+63: I+32] := select (SRC2[I+127: I], imm8[3:2])
    TMP1[I+95: I+64] := select (SRC2[I+127: I], imm8[5:4])
    TMP1[I+127: I+96] := select (SRC2[I+127: I], imm8[7:6])
END FOR

SAD of quadruplets:

FOR I =0 to VL step 64
    TMP_DEST[I+15:I] := ABS(SRC1[I+7: I] - TMP1[I+7: I]) +
          ABS(SRC1[I+15: I+8]- TMP1[I+15: I+8]) +


     ABS(SRC1[I+23: I+16]- TMP1[I+23: I+16]) +
     ABS(SRC1[I+31: I+24]- TMP1[I+31: I+24])

TMP_DEST[I+31: I+16] := ABS(SRC1[I+7: I] - TMP1[I+15: I+8]) +
      ABS(SRC1[I+15: I+8]- TMP1[I+23: I+16]) +
      ABS(SRC1[I+23: I+16]- TMP1[I+31: I+24]) +
      ABS(SRC1[I+31: I+24]- TMP1[I+39: I+32])

TMP_DEST[I+47: I+32] := ABS(SRC1[I+39: I+32] - TMP1[I+23: I+16]) +
      ABS(SRC1[I+47: I+40]- TMP1[I+31: I+24]) +
      ABS(SRC1[I+55: I+48]- TMP1[I+39: I+32]) +
      ABS(SRC1[I+63: I+56]- TMP1[I+47: I+40])

    TMP_DEST[I+63: I+48] := ABS(SRC1[I+39: I+32] - TMP1[I+31: I+24]) +
          ABS(SRC1[I+47: I+40] - TMP1[I+39: I+32]) +
          ABS(SRC1[I+55: I+48] - TMP1[I+47: I+40]) +
          ABS(SRC1[I+63: I+56] - TMP1[I+55: I+48])

ENDFOR

FOR j := 0 TO KL-1

i := j * 16

IF k1[j] OR *no writemask*

     THEN DEST[i+15:i] := TMP_DEST[i+15:i]

     ELSE

        IF *merging-masking*                ; merging-masking

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

             ELSE                           ; zeroing-masking

                    DEST[i+15:i] := 0

        FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

Intel C/C++ compilador intrínseco

VDBPSADBW __m512i _mm512_dbsad_epu8(__m512i a, __m512i b int imm8);
VDBPSADBW __m512i _mm512_mask_dbsad_epu8(__m512i s, __mmask32 m, __m512i a, __m512i b int imm8);
VDBPSADBW __m512i _mm512_maskz_dbsad_epu8(__mmask32 m, __m512i a, __m512i b int imm8);
VDBPSADBW __m256i _mm256_dbsad_epu8(__m256i a, __m256i b int imm8);
VDBPSADBW __m256i _mm256_mask_dbsad_epu8(__m256i s, __mmask16 m, __m256i a, __m256i b int imm8);
VDBPSADBW __m256i _mm256_maskz_dbsad_epu8(__mmask16 m, __m256i a, __m256i b int imm8);
VDBPSADBW __m128i _mm_dbsad_epu8(__m128i a, __m128i b int imm8);
VDBPSADBW __m128i _mm_mask_dbsad_epu8(__m128i s, __mmask8 m, __m128i a, __m128i b int imm8);
VDBPSADBW __m128i _mm_maskz_dbsad_epu8(__mmask8 m, __m128i a, __m128i b int imm8);

SIMD coma flotante Excepciones

None.

Otras excepciones

Ver Excepciones Tipo E4NF.nb en la tabla 2-52, "Tipo E4NF Clase Condiciones de Excepción."

Fuentes