C++ 在SSE寄存器中存储常量（GCC、C+；+；）

你好，StackOverflow社区

我遇到了一个挑战：在我的C++应用程序中，我有一个非常复杂的（三次）循环，在所有的深度，我执行以下操作：

计算4个浮点值

将所有4个值乘以一个常数

将浮点数转换为整数

这段代码将在每个循环中运行数千次迭代（导致数十亿次操作），我想让它尽可能快，所以我尝试利用SSE处理器指令

在尝试手动优化代码时，我遇到了以下障碍：每次我将所有值乘以一个常量，该常量必须加载到XMM寄存器。我的想法是保留一个寄存器（并且禁止编译器使用它），加载一次值，然后用一个特定的寄存器硬编码乘法，但是我找不到正确的方法

顺便问一下，有人能给我解释一下，为什么这个代码：

    vmovaps .LC0(%rip), %xmm1
    movl    $1000000000, %eax
    vmovaps .LC1(%rip), %xmm0
    .p2align 4,,10
    .p2align 3
.L2:
#APP
# 26 "sse.cpp" 1
    .intel_syntax noprefix;
    mulps %xmm1,%xmm0;
    .att_syntax prefix;

# 0 "" 2
#NO_APP
    subl    $1, %eax
    jne     .L2

性能比以下各项更差（实际0m1.656s与实际0m1.618s）：

    vmovaps .LC0(%rip), %xmm1
    movl    $1000000000, %eax
    vmovaps .LC1(%rip), %xmm0
    .p2align 4,,10
    .p2align 3
.L2:
    vmulps  %xmm0, %xmm1, %xmm1
    subl    $1, %eax
    jne     .L2

---

（不同之处在于，我在gcc[first snippet]中的内联asm和旧版SSE指令中使用intel语法以实现兼容性，而gcc使用AVX vectors[second snippet]自动生成版本。）

注意，您需要更具体地说明如何编译，并可能提供最少的示例。我知道这可能不是最好的答案，但我认为这已经足够好了。它变长了，但这是因为代码

下面的工作的底线是，留给编译器使用适当的编译器标志应该是安全的。在底部，我给出了一个如何使用局部寄存器变量的示例，但它可能不是很有用（很容易被忽略）。您可以使用全局寄存器变量，但它不会产生任何好的结果，因此不鼓励使用

我的设置是

Intel（R）Core（TM）i7-4770cpu

，

gcc版本4.9.2

和

clang版本3.5.0

。下面的代码将

avx_scalar

存储在

xmm

寄存器的

-O1

及更高版本中。没有或

-O0

他们没有。生成程序集的代码为：

[clang++|g++]-march=native-S-Ox./sse.cpp

,

其中，

x

是优化级别

有趣的是，在我测试的任何情况下，使用

-march=archive

时，两个编译器都决定使用SSE4.1版本而不是遗留SSE，尽管我在代码本身中使用了遗留SSE内部函数。这很好

我还使用SSE4.1头文件

smmintrin.h

进行了测试。没有标志gcc使用传统SSE，clang无法编译，出现

错误：“SSE4.1指令集未启用”

。使用

xmmintrin.h

这一遗留SSE头，两个编译器都在有标志的情况下生成AVX版本，在没有标志的情况下生成遗留版本

测试代码

avx.cpp

：

extern "C" 
{
#include <smmintrin.h>
}

const float scalar = 3.14;
const __m128 avx_scalar = _mm_set1_ps(scalar);
__m128 vector;

__m128 its_me(){
    __m128 ret;
    __m128 result;
    for(int i = 0; i < 1000; ++i)
    {
        vector = _mm_set_ps(i*1,i*2,i*3,i*4);
        result = _mm_mul_ps(vector, avx_scalar);
        ret = _mm_add_ps(ret, result);
    }
    return ret;
}

.LFB639:
        .cfi_startproc
        vmovaps _ZL10avx_scalar(%rip), %xmm5
        xorl    %edx, %edx
        .p2align 4,,10
        .p2align 3
.L2:
        leal    (%rdx,%rdx), %ecx
        vxorps  %xmm2, %xmm2, %xmm2
        vxorps  %xmm1, %xmm1, %xmm1
        vxorps  %xmm3, %xmm3, %xmm3
        leal    0(,%rdx,4), %eax
        vcvtsi2ss       %ecx, %xmm3, %xmm3
        vxorps  %xmm4, %xmm4, %xmm4
        vcvtsi2ss       %eax, %xmm2, %xmm2
        leal    (%rcx,%rdx), %eax
        vcvtsi2ss       %edx, %xmm4, %xmm4
        addl    $1, %edx
        vcvtsi2ss       %eax, %xmm1, %xmm1
        vunpcklps       %xmm4, %xmm3, %xmm3
        vunpcklps       %xmm1, %xmm2, %xmm1
        vmovlhps        %xmm3, %xmm1, %xmm1
        vmulps  %xmm5, %xmm1, %xmm2
        vaddps  %xmm2, %xmm0, %xmm0
        cmpl    $1000, %edx
        jne     .L2
        vmovaps %xmm1, vector(%rip)
        ret
        .cfi_endproc

# BB#0:
        xorl    %eax, %eax
        movl    $4, %ecx
        movl    $2, %edx
        vmovaps _ZL10avx_scalar(%rip), %xmm1
        xorl    %esi, %esi
                                        # implicit-def: XMM0
        .align  16, 0x90
.LBB0_1:                                # =>This Inner Loop Header: Depth=1
        leal    -2(%rdx), %r8d
        leal    -4(%rcx), %edi
        vmovd   %edi, %xmm2
        vpinsrd $1, %eax, %xmm2, %xmm2
        vpinsrd $2, %r8d, %xmm2, %xmm2
        vpinsrd $3, %esi, %xmm2, %xmm2
        vcvtdq2ps       %xmm2, %xmm2
        vmulps  %xmm1, %xmm2, %xmm2
        vaddps  %xmm2, %xmm0, %xmm0
        leal    1(%rsi), %r8d
        leal    3(%rax), %edi
        vmovd   %ecx, %xmm2
        vpinsrd $1, %edi, %xmm2, %xmm2
        vpinsrd $2, %edx, %xmm2, %xmm2
        vpinsrd $3, %r8d, %xmm2, %xmm2
        vcvtdq2ps       %xmm2, %xmm2
        vmulps  %xmm1, %xmm2, %xmm3
        vaddps  %xmm3, %xmm0, %xmm0
        addl    $2, %esi
        addl    $6, %eax
        addl    $8, %ecx
        addl    $4, %edx
        cmpl    $1000, %esi             # imm = 0x3E8
        jne     .LBB0_1
# BB#2:
        vmovaps %xmm2, vector(%rip)
        retq

和

clang++-march=native-S-O2./avx.cpp

：

extern "C" 
{
#include <smmintrin.h>
}

const float scalar = 3.14;
const __m128 avx_scalar = _mm_set1_ps(scalar);
__m128 vector;

__m128 its_me(){
    __m128 ret;
    __m128 result;
    for(int i = 0; i < 1000; ++i)
    {
        vector = _mm_set_ps(i*1,i*2,i*3,i*4);
        result = _mm_mul_ps(vector, avx_scalar);
        ret = _mm_add_ps(ret, result);
    }
    return ret;
}

.LFB639:
        .cfi_startproc
        vmovaps _ZL10avx_scalar(%rip), %xmm5
        xorl    %edx, %edx
        .p2align 4,,10
        .p2align 3
.L2:
        leal    (%rdx,%rdx), %ecx
        vxorps  %xmm2, %xmm2, %xmm2
        vxorps  %xmm1, %xmm1, %xmm1
        vxorps  %xmm3, %xmm3, %xmm3
        leal    0(,%rdx,4), %eax
        vcvtsi2ss       %ecx, %xmm3, %xmm3
        vxorps  %xmm4, %xmm4, %xmm4
        vcvtsi2ss       %eax, %xmm2, %xmm2
        leal    (%rcx,%rdx), %eax
        vcvtsi2ss       %edx, %xmm4, %xmm4
        addl    $1, %edx
        vcvtsi2ss       %eax, %xmm1, %xmm1
        vunpcklps       %xmm4, %xmm3, %xmm3
        vunpcklps       %xmm1, %xmm2, %xmm1
        vmovlhps        %xmm3, %xmm1, %xmm1
        vmulps  %xmm5, %xmm1, %xmm2
        vaddps  %xmm2, %xmm0, %xmm0
        cmpl    $1000, %edx
        jne     .L2
        vmovaps %xmm1, vector(%rip)
        ret
        .cfi_endproc

# BB#0:
        xorl    %eax, %eax
        movl    $4, %ecx
        movl    $2, %edx
        vmovaps _ZL10avx_scalar(%rip), %xmm1
        xorl    %esi, %esi
                                        # implicit-def: XMM0
        .align  16, 0x90
.LBB0_1:                                # =>This Inner Loop Header: Depth=1
        leal    -2(%rdx), %r8d
        leal    -4(%rcx), %edi
        vmovd   %edi, %xmm2
        vpinsrd $1, %eax, %xmm2, %xmm2
        vpinsrd $2, %r8d, %xmm2, %xmm2
        vpinsrd $3, %esi, %xmm2, %xmm2
        vcvtdq2ps       %xmm2, %xmm2
        vmulps  %xmm1, %xmm2, %xmm2
        vaddps  %xmm2, %xmm0, %xmm0
        leal    1(%rsi), %r8d
        leal    3(%rax), %edi
        vmovd   %ecx, %xmm2
        vpinsrd $1, %edi, %xmm2, %xmm2
        vpinsrd $2, %edx, %xmm2, %xmm2
        vpinsrd $3, %r8d, %xmm2, %xmm2
        vcvtdq2ps       %xmm2, %xmm2
        vmulps  %xmm1, %xmm2, %xmm3
        vaddps  %xmm3, %xmm0, %xmm0
        addl    $2, %esi
        addl    $6, %eax
        addl    $8, %ecx
        addl    $4, %edx
        cmpl    $1000, %esi             # imm = 0x3E8
        jne     .LBB0_1
# BB#2:
        vmovaps %xmm2, vector(%rip)
        retq

仅针对记录，您可以手动将一个局部变量放入寄存器，但clang会完全忽略带有

-01

及更高版本的gcc。我鼓励您在

g++-march=native-S-Ox./avx.cpp

的输出中查找

xmm13

，以下代码使用不同的

x

值（假设cpu上至少有13个xmm寄存器）：

extern“C”
{
#包括
}
常量浮点标量=3.14；
__m128它的_me（）{
__m128矢量；
寄存器uum128 avx_scalarasm（“xmm13”）=\umm_set1_ps（scalar）；//在gcc中就是这样做的。
//常量m128 avx_标量=_mm_set1_ps（标量）；
__m128-ret；
__m128结果；
对于（int i=0；i<1000；++i）
{
向量=_mm_集_ps（i*1，i*2，i*3，i*4）；
结果=_mm_mul_ps（向量，avx_标量）；
ret=_mm_add_ps（ret，结果）；
}
返回ret；
}

您应该使用内置向量支持和/或内部函数。此外，如果您想使用英特尔语法，请使用-masm=intel进行编译，不要试图绕过编译器的背面。至于保留寄存器，这可能也是个坏主意，但gcc允许全局寄存器变量。Umm不会将

常量mm128

变量声明为de在帮助中描述？@Jester-masm=intel打破了一些boost依赖关系，以前尝试过。如果可以避免的话，不要在内部循环中使用

\u mm\u set\u ps

。设置

{0.0,0.0,0.0,0.0}

一次，然后

\u mm\u add\u ps

一个

{1.0,2.0,3.0,4.0}的向量

生成

向量

。这将用循环中的

vaddps

替换4个整数相加、

vmovd

、3x

vpinsrd

、和

vcdq2ps

。或者如果您确实需要避免任何可能的舍入误差累积，请添加到整数向量，这样您就有了

vpaddd

和

vcdq2ps

在内部循环中。这是一个很好的分析，尽管对于答案来说非常无用。

设置ps

只是为了模拟“计算4个浮点值”它可能很慢，而且不是一个真正的实现。我真的看不出优化编造出来的东西有什么意义。但是我发现从微观优化的角度来看，这是一个有趣的观察和建议。它当然有它的价值。我想我没有足够仔细地阅读代码之外的文本，以至于没有在lo上理解

mm\u ps

op计数器是一个占位符。事实上，我似乎记得对此感到疑惑，但它对生成的代码有很大影响，所以我还是发布了。