使用 SSE 将 4 个浮点数乘以 4 个浮点数的最有效方法是啥？

Posted 2023-02-16

【中文标题】使用 SSE 将 4 个浮点数乘以 4 个浮点数的最有效方法是啥？

【英文标题】：What's the most efficient way to multiply 4 floats by 4 floats using SSE?使用 SSE 将 4 个浮点数乘以 4 个浮点数的最有效方法是什么？

【发布时间】：2009-08-04 12:34:17

【问题描述】：

我目前有以下代码：

float a[4] =  10, 20, 30, 40 ;
float b[4] =  0.1, 0.1, 0.1, 0.1 ;
asm volatile("movups (%0), %%xmm0\n\t"
             "mulps (%1), %%xmm0\n\t"             
             "movups %%xmm0, (%1)"             
             :: "r" (a), "r" (b));

首先我有几个问题：

(1) 如果我要在 16 字节边界上对齐数组，它甚至可以工作吗？由于数组是在堆栈上分配的，对齐它们是真的几乎不可能吗？

查看此帖子的选定答案：Are stack variables aligned by the GCC __attribute__((aligned(x)))?

(2) 可以重构代码以提高效率吗？如果我将两个浮点数组都放入寄存器而不是一个呢？

谢谢

【参考方案1】：

用C写，用

gcc -S -mssse3

如果你有一个相当新的 gcc 版本。

【讨论】：

哪些 C 代码可以编译成这些 sse 指令？你有例子吗？

float a[4] = 10, 20, 30, 40 ;浮动 b[4] = 0.1, 0.1, 0.1, 0.1 ; int foo(void) int i;对于 (i=0; i

【参考方案2】：

如果我要在 16 字节边界上对齐数组，它甚至可以工作吗？由于数组是在堆栈上分配的，对齐它们是真的几乎不可能吗？

要求堆栈上的对齐有效。否则内在函数将不起作用。我猜你引用的帖子与他为对齐值选择的过高值有关。

到2：

不，性能不应该有差异。多个处理器的指令时序见site。

---

堆栈变量的对齐方式是如何工作的：

push    ebp
mov ebp, esp
and esp, -16                ; fffffff0H
sub esp, 200                ; 000000c8H

and 将堆栈的开头对齐到 16 字节。

【参考方案3】：

(1) 如果我要在 16 字节边界上对齐数组，它甚至可以工作吗？由于数组是在堆栈上分配的，对齐它们是真的几乎不可能吗？

不，使用and对齐堆栈指针非常简单：

and esp, 0xFFFFFFF0 ; aligned on a 16-byte boundary

但您应该使用 GCC 提供的内容，例如 16 字节类型，或 __attribute__ 来自定义对齐方式。

【讨论】：

感谢您的回答，您能否向我解释一下如何使用“和”进行对齐？我不太“明白”它:)

回想一下 some_bit and 0 = 0 和 a/16 = a>>4 如果 a 未签名。像这样使用and 会将四个最低有效位设置为零，而其他位保持不变。实际上，如果将esp 除以 16 会发生什么？它被右移 4，四个“丢失”的位是余数。因此这四位应该是 0，所以esp 可以被 16 整除。真正发生的是它减去最多 15，所以esp % 16 == 0。（减去esp 表示在堆栈上分配更多空间）。

【参考方案4】：

GCC 是否支持__m128 数据类型？如果是这样，那是保证 16 字节对齐数据类型的最佳计划。尽管如此，还是有__attribute__((aligned(16))) 用于对齐事物。如下定义你的数组

float a[4] __attribute__((aligned(16))) =  10, 20, 30, 40 ;
float b[4] __attribute__((aligned(16))) =  0.1, 0.1, 0.1, 0.1 ;

然后改用 movaps :)

【讨论】：

谢谢；但正如本文***.com/questions/841433/… 中所述，似乎不可能对齐分配在堆栈上的数组？ （与 .data 中分配的全局数组相反）

感谢 Bastien 的修复 :) Banister ...你可以试试看会发生什么吗？如果与解释相关联的内容是正确的，那么就不可能正确对齐 double 之类的东西，但它们确实会对齐。

是的，我很快就会...我感觉链接的解释是错误的，因为这个问题中的每个人似乎都暗示。谢谢大家！ :)

【参考方案5】：

使用内在函数要快得多，尤其是在优化时。 我编写了简单的测试并比较了两个版本（asm 和内在）

unsigned long long time1;
__m128 a1,b1;


a1=_mm_set_ps(10, 20,30,40);
b1=_mm_set_ps(0.1, 0.1, 0.1, 0.1);
float a[4] =  10, 20, 30, 40 ;
float b[4] =  0.1, 0.1, 0.1, 0.1 ;

time1=__rdtsc();
a1=_mm_mul_ps(a1,b1);
time1=__rdtsc() - time1 ;
printf("Time: %llu\n",time1);


time1=__rdtsc();
asm volatile("movups (%0), %%xmm0\n\t"
                 "mulps (%1), %%xmm0\n\t"
                 "movups %%xmm0, (%1)"
                 :: "r" (a), "r" (b));
time1=__rdtsc() - time1 ;
printf("Time: %llu\n",time1);

内部版本 50-60 处理器时间戳 Asm 版本 ~1000 过程时间戳

你可以在你的机器上测试它

【参考方案6】：

关于重构。你可以使用内在的。 示例：

#include <emmintrin.h>

int main(void)

    __m128 a1,b1;

    a1=_mm_set_ps(10, 20,30,40);
    b1=_mm_set_ps(0.1, 0.1, 0.1, 0.1);

    a1=_mm_mul_ps(a1,b1);

    return 0;

使用优化 gcc (-O2, -O3) 它可能会比 asm 更快。

【讨论】：

你认为它会运行多快？你能做基准测试吗？

看下一篇，我正在测试它