SSE 字节和半字交换

Question

我想使用 SSE 内在函数翻译此代码。

for (uint32_t i = 0; i < length; i += 4, src += 4, dest += 4)
{
    uint32_t value = *(uint32_t*)src;
    *(uint32_t*)dest = ((value >> 16) & 0xFFFF) | (value << 16);
}

有人知道执行 16 位字交换的内在函数吗？

Answer 1

pshufb (SSSE3) 应该比 2 班次和 OR 更快。此外，对 shuffle 掩码稍作修改即可实现字节序转换，而不仅仅是单词交换。

窃取 Paul R 的函数结构，只是替换了向量内在函数：

void word_swapping_ssse3(uint32_t* dest, const uint32_t* src, size_t count)
{
    size_t i;
    __m128i shufmask =  _mm_set_epi8(13,12, 15,14,  9,8, 11,10,  5,4, 7,6,  1,0, 3,2);
    // _mm_set args go in big-endian order for some reason.                       

    for (i = 0; i + 4 <= count; i += 4)
    {
        __m128i s = _mm_loadu_si128((__m128i*)&src[i]);
        __m128i d = _mm_shuffle_epi8(s, shufmask);
        _mm_storeu_si128((__m128i*)&dest[i], d);
    }
    for ( ; i < count; ++i) // handle residual elements
    {
        uint32_t w = src[i];
        w = (w >> 16) | (w << 16);
        dest[i] = w;
    }
}

pshufb 可以有一个内存操作数，但它必须是洗牌掩码，而不是要洗牌的数据。因此，您不能将其用作混洗负载。 ：/

gcc 不会为循环生成出色的代码。主循环是

# src: r8.  dest: rcx.  count: rax.  shufmask: xmm1
.L16:
        movq    %r9, %rax
.L3:  # first-iteration entry point
        movdqu  (%r8), %xmm0
        leaq    4(%rax), %r9
        addq    $16, %r8
        addq    $16, %rcx
        pshufb  %xmm1, %xmm0
        movups  %xmm0, -16(%rcx)
        cmpq    %rdx, %r9
        jbe     .L16

有了所有循环开销，并且需要单独的加载和存储指令，吞吐量将仅为每 2 个周期 1 次随机播放。 （8 微指令，因为 cmp 与 jbe 宏融合）。

更快的循环是

  shl $2, %rax  # uint count  ->  byte count
  # check for %rax less than 16 and skip the vector loop
  # cmp / jsomething
  add %rax, %r8  # set up pointers to the end of the array
  add %rax, %rcx
  neg %rax       # and count upwards toward zero
.loop:
  movdqu (%r8, %rax), %xmm0
  pshufb  %xmm1, %xmm0
  movups  %xmm0, (%rcx, %rax)  # IDK why gcc chooses movups for stores.  Shorter encoding?
  add $16, %rax
  jl .loop
  # ...
  # scalar cleanup

movdqu 加载可以与复杂的寻址模式进行微融合，这与向量 ALU 操作不同，所以我相信所有这些指令都是单微指令，除了存储。

这应该在每次迭代中运行 1 个周期并进行一些展开，因为 add 可以与 jl 进行微融合。所以循环总共有 5 个微指令。其中 3 个是加载/存储操作，具有专用端口。瓶颈是：pshufb 只能在一个执行端口上运行（Haswell（SnB/IvB 可以pshufb 在端口 1 和 5 上））。每个周期一个商店（所有微拱门）。最后，英特尔 CPU 的每个时钟 4 个融合域 uops 限制，应该可以达到，除非 Nehalem 和更高版本的缓存未命中（uop 循环缓冲区）。

展开将使每 16B 的总融合域 uops 降至 4 以下。递增指针，而不是使用复杂的寻址模式，将使存储微融合。 （减少循环开销总是好的：让重新排序缓冲区充满未来的迭代意味着 CPU 在循环结束时遇到错误预测并返回其他代码时有一些事情要做。）

正如 Elalfer 正确建议的那样，这几乎就是展开内在循环所得到的结果。使用 gcc，如果代码不会过于臃肿，请尝试 -funroll-loops。

顺便说一句，在加载或存储时进行字节交换可能会更好，与其他代码混合，而不是将缓冲区转换为单独的操作。

Answer 2

您问题中的标量代码并不是真正的 byte 交换（至少在字节序转换的意义上） - 它只是交换 32 位字中的高 16 位和低 16 位。如果这是您想要的，那么只需重新使用the solution to your previous question，并进行适当的更改：

void byte_swapping(uint32_t* dest, const uint32_t* src, size_t count)
{
    size_t i;
    for (i = 0; i + 4 <= count; i += 4)
    {
        __m128i s = _mm_loadu_si128((__m128i*)&src[i]);
        __m128i d = _mm_or_si128(_mm_slli_epi32(s, 16), _mm_srli_epi32(s, 16));
        _mm_storeu_si128((__m128i*)&dest[i], d);
    }
    for ( ; i < count; ++i) // handle residual elements
    {
        uint32_t w = src[i];
        w = (w >> 16) | (w << 16);
        dest[i] = w;
    }
}