如何将两个 256 位向量的低 3 位元素连接到一个 512 位向量中，并插入一个标量？

Question

尽管它很奇怪且不规范，但我想在单个__m512d中连接两个__m256d和一个double 。 具体来说，我有

__m256d a = _mm256_set_pd(1, 2, 3, 0);
__m256d b = _mm256_set_pd(4, 5, 6, 0);
double c = 7;

最后，我想拥有

__m512d d {1, 2, 3, 4, 5, 6, 7, 0}

有没有一种快速的方法可以使用英特尔内在函数来做到这一点？

Answer 1

有关示例，请参见此链接： https://community.intel.com/t5/Intel-ISA-Extensions/How-to-convert-two-m256d-to-one-m512d-using-intrinsics/mp/1062934

__m256d a;
__m256d b;
__m512d c = _mm512_insertf64x4(_mm512_castpd256_pd512(a), b, 1);

Answer 2

这个怎么样：

// Note: _mm256_set_pd lists elements from top to bottom, meaning in this case
//       the lowest elements are zero.
__m256d a = _mm256_set_pd(1, 2, 3, 0);
__m256d b = _mm256_set_pd(4, 5, 6, 0);
double c = 7;

// Expected result is:
// __m512d d {1, 2, 3, 4, 5, 6, 7, 0}
// Note: Here the elements are listed from bottom to top, meaning that the
//       last (i.e. upper) element is zero.

// Insert c into the lower element of b.
// We rely on that c is already in an xmm register and all upper elements are
// likely zero, so _mm_set_sd and _mm256_zextpd128_pd256 are likely optimized
// away. We also rely on that the lowest element of b is zero.
// If the lowest element of b is not zero, use _mm256_blend_pd here instead.
// If the order of elements in b is different, use _mm256_permutex2var_pd or,
// as suggested by Peter Cordes in the comments, _mm512_insertf64x2
// or _mm256_mask_broadcastsd_pd.
__m256d bc = _mm256_or_pd(b, _mm256_zextpd128_pd256(_mm_set_sd(c)));

// Merge and reorder elements of a and bc.
// We rely on that the lowest element of a is zero, which we move to the top
// element of d. If that is not the case and you still want zero in the top
// element of d, you can use _mm512_maskz_permutex2var_pd here with a mask
// of 0b01111111.
const __m512i d_perm_idx = _mm512_setr_epi64(3, 2, 1, 11, 10, 9, 8, 0);
__m512d d = _mm512_permutex2var_pd(
    _mm512_castpd256_pd512(a), d_perm_idx, _mm512_castpd256_pd512(bc));

如果您的输入向量实际上与您的代码片段相反（即零实际上在顶部元素中），这里是更新的代码：

// Note the 'r' in _mm256_setr_pd
__m256d a = _mm256_setr_pd(1, 2, 3, 0);
__m256d b = _mm256_setr_pd(4, 5, 6, 0);
double c = 7;

// Insert c into the upper half of b.
__m512d bc = _mm512_insertf64x2(_mm512_castpd256_pd512(b), _mm_set_sd(c), 2);

// Merge and reorder elements of a and bc.
const __m512i d_perm_idx = _mm512_setr_epi64(0, 1, 2, 8, 9, 10, 12, 3);
__m512d d = _mm512_permutex2var_pd(_mm512_castpd256_pd512(a), d_perm_idx, bc);

Answer 3

我怀疑你的意思是你a和b向量有一个 0.0 作为高元素，而不是低元素。 所以可能你的意思是_mm256_setr_pd ，而不是set 。 我将假设问题的 rest。

---

您说您的数据来自外部库编写的 3 元素 arrays 负载。 （您实际上说的是“3 维”arrays，但这意味着arr[][][] 。）因此，也许您使用了掩码加载来将第 4 个元素清零，而没有读到最后。 理想情况下，您可以为您的外部库创建一个 output 缓冲区，例如alignas(64) double out[8]并将out+0和out+3作为指针传递，这样您想要的数据已经是连续的，不需要随机播放。 如果您在较窄的存储后很快重新加载它，最坏的情况是存储转发停顿（额外的延迟但吞吐量成本最小）。

但是，如果那行不通，您仍然可以进行屏蔽加载以使b元素在它们所属的位置排列，设置为混合或合并屏蔽，使用未对齐加载硬件将洗牌作为加载，如本答案中所述。 这必须是一个 64 字节的加载，所以它肯定是一个缓存行拆分，除非第一个元素恰好开始 3 个双倍进入缓存行。

由于您需要从实际数组b的开始之前加载，因此您可以使用掩码来确保它是安全的（故障抑制），尽管如果它在没有掩码的情况下会发生故障，它可能会非常慢。 它可以是合并屏蔽加载a .

__m512d merge_load(const double *array_A, const double *array_B, double c){
    //alignas(32) double arraya[3];
    //double arrayb[3];

   __m256d a = _mm256_maskz_loadu_pd(0b0111, array_A);    // zero masking load of 3 doubles at the bottom of a YMM.  If your array actually has a 0.0 after, you don't need a mask, that's better.

   // zero-extending to 512 is free because we just loaded, not like a function arg.
   __m512d ab = _mm512_mask_loadu_pd(_mm512_zextpd256_pd512(a), 0b00111000, array_B-3);

   // relies on the compiler to optimize away the useless zero-extension in _mm_set_sd
   // clang is fine, GCC isn't.  GCC insanely does vmovsd xmm1, xmm0,xmm0 merging into itself, not even a movq zero-extension
   __m512d d = _mm512_mask_broadcastsd_pd(ab, 0b01000000, _mm_set_sd(c));
   return d;
}

这可能比不会停顿的较窄负载慢，然后进行几次洗牌。 如果数据是最近存储的，则高速缓存行拆分和存储转发停顿可能会造成无序执行程序无法隐藏的过多延迟，具体取决于周围的代码。 存储转发停顿不会与 Intel 上的其他 SF 停顿流水线化，尽管它们与其他负载（包括快速路径存储转发）一起使用。 缓存行拆分加载在加载端口周期和拆分缓冲区方面也有一些吞吐量成本。

另一种选择是屏蔽 256 位加载以合并bc并设置vpermt2pd洗牌。 或者 AVX2 vblendpd ，如果你可以从array_B - 1加载而不屏蔽故障抑制。

Clang 按原样编译，没有对_mm_set_sd的说明：只读取__m128d的低位元素，因此实际零扩展毫无意义。 （与 GCC 不同，它浪费了一条无用的指令，实际上什至没有零扩展，只是将相同的值与vmovsd xmm1, xmm0, xmm0合并到垃圾中。与movq和加载形式不同，reg-reg movsd是一个合并。）

这需要 3 个单独的掩码常量，每个都需要多个微指令来设置。 （例如mov -immediate + kmov 。或者在 Zen4 上，GCC 选择从 memory 加载。在 Intel CPU 上， kmov k, mem仍然是 2 uops，就像加载到 integer 寄存器一样。希望它在 AMD 上更便宜。） vpermt2pd将使用向量常量而不是最后一步的掩码。

# clang15 -O3 -march=skylake-avx512
merge_load(double const*, double const*, double):
        mov     al, 7
        kmovd   k1, eax
    vmovupd ymm1 {k1} {z}, ymmword ptr [rdi]     # maskz_loadu
        mov     al, 56
        kmovd   k1, eax
    vmovupd zmm1 {k1}, zmmword ptr [rsi - 24]    # mask_loadu (merge-masking)
        mov     al, 64
        kmovd   k1, eax
    vbroadcastsd    zmm1 {k1}, xmm0              # mask_broadcastsd merge
        vmovapd zmm0, zmm1
        ret

如果它选择了 3 个单独的k1..7寄存器，则掩码可能会保留下来，除非跨过 function 调用不内联。 我单独缩进了这项工作。 但是如果你调用外部 function，没有调用保留的k掩码或 YMM 或 ZMM regs，所以如果你每次都必须重新加载，64 字节的向量常量可能是最好的； 它可以在缓存中保持热状态，所以只有 uop 计数和端口压力很重要。

---

如果您a和b向量零扩展到 512 位，则另一种策略是一个 shuffle 和一个可以在任何端口上运行的廉价vorpd 。 不幸的是，没有vblendpd z,z,z, imm ，这将是理想的，使用直接控制而不是掩码寄存器。 但是 XMM 和 YMM 只有 AVX1 forms。 （和旧版 SSE4.1）

完全避免向量和掩码常量会更昂贵。 您可以vbroadcastsd y,x on c + AVX1 vblendpd ymm..., imm来创建bc = {b0, b1, b2, c} ，但是然后呢？ vinsertf64x4可以将所有内容放入一个寄存器，但是vpermpd zmm, zmm, imm8在两个 256 位的一半内进行相同的洗牌。 imm8 中没有足够的立即位来进行 8 元素随机播放。 因此，也许valignq （与其自身）将 bc 旋转到位，然后vorpd而不是混合进行组合。

但一个好的权衡似乎是：

// Efficient if  a  is already zero-extended to 512
__m512d merge_low3_manual(__m256d a, __m256d b, double c)
{
    const __m512i d_perm_idx = _mm512_setr_epi64(3, 3, 3, 0, 1, 2, 8, 3);
    // 0 0 0 b0   b1 b2 c 0    (low element on the left)
    __m512d bc = _mm512_permutex2var_pd(_mm512_castpd256_pd512(b), d_perm_idx, _mm512_castpd128_pd512(_mm_set_sd(c)));
    //return _mm512_blend_pd(_mm512_castpd256_pd512(a), bc, 0b11111000);  // there is no vblendpd z,z,z, imm8
    return _mm512_or_pd(_mm512_zextpd256_pd512(a), bc);  // a zero-extends for free if the compiler can see where it was created.
}

愚蠢的 clang，通过为vmovapd ymm0, ymm0选择相同的寄存器来击败 mov-elimination，因为它不能优化零扩展。

merge_low3_manual(double __vector(4), double __vector(4), double):
        vmovapd zmm3, zmmword ptr [rip + .LCPI0_0] # zmm3 = [3,3,3,0,1,2,8,3]
     vpermi2pd       zmm3, zmm1, zmm2    # produce bc
        vmovapd ymm0, ymm0               # zero extension hopefully goes away on inlining
     vorpd   zmm0, zmm3, zmm0
        ret

因此，实际上，这可能只是 2 条指令（假设您的矢量输入已经作为__m256d加载，而无需为此进行任何组合。这可能是公平的，合并掩码需要额外的指令来设置掩码。但是，如果您需要用于故障抑制的掩码，请使用合并掩码。）

这些都是未经测试的，所以我可能有错误的洗牌常量。