3

__m128i交换变量的最佳做法是什么？

背景是Sun Studio 12.2 下的编译错误，这是一个 C++03 编译器。__m128i是与 MMX 和 SSE 指令一起使用的不透明类型，它通常和unsigned long long[2]. C++03 不提供交换数组的支持，std:swap(__m128i a, __m128i b)在编译器下失败。

以下是一些不太符合要求的相关问题。它们不适用，因为std::vector不可用。

4

2 回答 2

2

通过交换memcpy？

#include <emmintrin.h>
#include <cstring>

template<class T>
void memswap(T& a, T& b)
{
    T t;
    std::memcpy(&t, &a, sizeof(t));
    std::memcpy(&a, &b, sizeof(t));
    std::memcpy(&b, &t, sizeof(t));
}

int main() {
    __m128i x;
    __m128i y;
    memswap(x, y);
    return 0;
}
于 2016-07-17T07:26:34.033 回答
2

这听起来不像是最佳实践问题。听起来您需要一种解决方法来解决严重损坏的内在函数。如果__m128i tmp = a;不编译，那就太糟糕了。

如果您要编写自定义交换函数，请保持简单。 __m128i是适合单个向量寄存器的 POD 类型。不要做任何会鼓励编译器将其溢出到内存的事情。一些编译器即使对于一个微不足道的测试用例也会生成非常糟糕的代码，甚至 gcc/clang 作为优化大型复杂函数的一部分可能会绊倒 memcpy。

由于编译器在构造函数上阻塞，只需使用普通初始化器声明一个 tmp 变量，并使用=赋值来进行复制。这在任何支持的编译器中总是有效的__m128i，并且是一种常见的模式。

对内存中的值的普通赋值类似于_mm_store_si128/ _mm_load_si128：即movdqa对齐的存储/加载，如果用于未对齐的地址，则会出错。（当然，优化可能导致加载被折叠到另一个向量指令的内存操作数中，或者根本不发生存储。）

// alternate names: assignment_swap
// or swap128, but then the name doesn't fit for __m256i...

// __m128i t(a) errors, so just use simple initializers / assignment
template<class T>
void vecswap(T& a, T& b) {
    // T t = a;     // Apparently SunCC even choked on this
    T t;
    t = a;
    a = b;
    b = t;
}

测试用例：即使使用像 ICC13 这样的硬编译器，在 memcpy 版本上做得很糟糕，也能优化代码。Godbolt 编译器资源管理器的 asm 输出，带有 icc13-O3

__m128i test_return2nd(__m128i x, __m128i y) {
    vecswap(x, y);
    return x;
}

    movdqa    xmm0, xmm1
    ret                    # returning the 2nd arg, which was in xmm1


__m128i test_return1st(__m128i x, __m128i y) {
    vecswap(x, y);
    return y;
}

    ret                   # returning the first arg, already in xmm0

使用 memswap，你会得到类似的东西

return1st_memcpy(__m128i, __m128i):        ## ICC13 -O3
    movdqa    XMMWORD PTR [-56+rsp], xmm0
    movdqa    XMMWORD PTR [-40+rsp], xmm1    # spill both
    movaps    xmm2, XMMWORD PTR [-56+rsp]    # reload x
    movaps    XMMWORD PTR [-24+rsp], xmm2    # copy x to tmp
    movaps    xmm0, XMMWORD PTR [-40+rsp]    # reload y
    movaps    XMMWORD PTR [-56+rsp], xmm0    # copy y to x
    movaps    xmm0, XMMWORD PTR [-24+rsp]    # reload tmp
    movaps    XMMWORD PTR [-40+rsp], xmm0    # copy tmp to y
    movdqa    xmm0, XMMWORD PTR [-40+rsp]    # reload y
    ret                                      # return y

这几乎是您可以想象交换两个寄存器的绝对最大溢出/重新加载量，因为 icc13 根本不会在内联memcpys 之间进行优化，甚至不会记住寄存器中剩下的内容。

交换内存中已有的值

甚至 gcc 使用 memcpy 版本也会使代码变得更糟。它使用 64 位整数加载/存储而不是 128 位向量加载/存储来进行复制。如果您要加载向量（存储转发停顿），这很糟糕，否则就很糟糕（更多的微指令来做同样的工作）。

// the memcpy version of this compiles badly
void test_mem(__m128i *x, __m128i *y) {
    vecswap(*x, *y);
}
    # gcc 5.3 and ICC13 make the same code here, since it's easy to optimize
    movdqa  xmm0, XMMWORD PTR [rdi]
    movdqa  xmm1, XMMWORD PTR [rsi]
    movaps  XMMWORD PTR [rdi], xmm1
    movaps  XMMWORD PTR [rsi], xmm0
    ret

// gcc 5.3 with memswap instead of vecswap.  ICC13 is similar
test_mem_memcpy(long long __vector(2)*, long long __vector(2)*):
    mov     rax, QWORD PTR [rdi]
    mov     rdx, QWORD PTR [rdi+8]
    mov     r9, QWORD PTR [rsi]
    mov     r10, QWORD PTR [rsi+8]
    mov     QWORD PTR [rdi], r9
    mov     QWORD PTR [rdi+8], r10
    mov     QWORD PTR [rsi], rax
    mov     QWORD PTR [rsi+8], rdx
    ret
于 2016-07-17T23:04:54.847 回答