首页
学习
活动
专区
圈层
工具
发布
社区首页 >问答首页 >是否有更有效的方法将4个连续的双打广播到4个YMM寄存器中?

问是否有更有效的方法将4个连续的双打广播到4个YMM寄存器中?
EN

Stack Overflow用户
提问于 2014-05-13 13:54:34
回答 3查看 2.3K关注 0票数 3

在执行类似于(但不完全)矩阵乘法的一段C++代码中,我将4个连续的双倍加载到4个YMM寄存器中,如下所示:

代码语言:javascript
复制
# a is a 64-byte aligned array of double
__m256d b0 = _mm256_broadcast_sd(&b[4*k+0]);
__m256d b1 = _mm256_broadcast_sd(&b[4*k+1]);
__m256d b2 = _mm256_broadcast_sd(&b[4*k+2]);
__m256d b3 = _mm256_broadcast_sd(&b[4*k+3]);

我在桑迪桥上用gcc-4.8.2编译了代码。硬件事件计数器(Intel )表明,CPU实际上从L1缓存中发出4种单独的负载。虽然在这一点上,我不受L1延迟或带宽的限制,但我很想知道是否有一种方法可以通过一个256位加载(或两个128位负载)加载4双,并将它们洗牌到4 YMM寄存器中。我浏览了一下英特尔Intrinsics指南,但没有找到完成所需的洗牌的方法。这有可能吗?

(如果CPU没有组合4个连续负载的前提实际上是错误的,请告诉我。)

EN

回答 3

Stack Overflow用户

回答已采纳

发布于 2014-05-13 14:38:46

在我的矩阵乘法码中,我只需要在每个内核代码中使用一次广播,但是如果您真的想在一条指令中加载四个双打,然后将它们广播到四个寄存器中,您可以这样做

代码语言:javascript
复制
#include <stdio.h>
#include <immintrin.h>

int main() {
    double in[] = {1,2,3,4};
    double out[4];
    __m256d x4 = _mm256_loadu_pd(in);
    __m256d t1 = _mm256_permute2f128_pd(x4, x4, 0x0);
    __m256d t2 = _mm256_permute2f128_pd(x4, x4, 0x11);
    __m256d broad1 = _mm256_permute_pd(t1,0);
    __m256d broad2 = _mm256_permute_pd(t1,0xf);
    __m256d broad3 = _mm256_permute_pd(t2,0);
    __m256d broad4 = _mm256_permute_pd(t2,0xf);

    _mm256_storeu_pd(out,broad1);   
    printf("%f %f %f %f\n", out[0], out[1], out[2], out[3]);
    _mm256_storeu_pd(out,broad2);   
    printf("%f %f %f %f\n", out[0], out[1], out[2], out[3]);
    _mm256_storeu_pd(out,broad3);   
    printf("%f %f %f %f\n", out[0], out[1], out[2], out[3]);
    _mm256_storeu_pd(out,broad4);   
    printf("%f %f %f %f\n", out[0], out[1], out[2], out[3]);
}

编辑:这是另一个基于Paul R的建议的解决方案。

代码语言:javascript
复制
__m256 t1 = _mm256_broadcast_pd((__m128d*)&b[4*k+0]);
__m256 t2 = _mm256_broadcast_pd((__m128d*)&b[4*k+2]);
__m256d broad1 = _mm256_permute_pd(t1,0);
__m256d broad2 = _mm256_permute_pd(t1,0xf);
__m256d broad3 = _mm256_permute_pd(t2,0);
__m256d broad4 = _mm256_permute_pd(t2,0xf);
票数 2
EN

Stack Overflow用户

发布于 2016-05-23 01:30:32

TL;DR:几乎总是最好使用_mm256_set1_pd()进行四次广播加载。vbroadcastsd ymm,[mem] 不需要ALU洗牌操作,而且通常也是沙桥/的最佳选择(其中是2 uop+洗牌指令)。

这也意味着,除了double的自然对齐之外,您根本不需要关心对齐问题。

第一个向量比执行两步加载+洗牌更快,因此,在第一个向量仍在加载时,无序执行可能会开始使用这些向量的代码。AVX512甚至可以将广播负载折叠到内存操作数中,以便进行ALU指令,因此这样做将允许重新编译以稍微利用256 b向量的AVX512。

(通常最好使用set1(x),而不是_mm256_broadcast_sd(&x);如果只有AVX2 2的注册源形式的vbroadcastsd不可用,编译器可以选择存储->广播加载或进行两次洗牌。您永远不知道内联什么时候意味着您的代码将在已经在寄存器中的输入上运行。)

如果您在负载端口资源冲突或吞吐量方面遇到了瓶颈,而不是完全uops或ALU /洗牌资源,那么将一对64->256 b广播替换为16B->32B广播负载(vbroadcastf128/_mm256_broadcast_pd)和两个内车道洗牌(vpermilpd或vunpckl/hpd (_mm256_shuffle_pd))可能会有帮助。

或AVX2:load 32B并使用4 _mm256_permute4x64_pd改组将每个元素广播到一个单独的向量中。

源Agner Fog's insn表(和microarch )

英特尔哈斯韦尔及其后:

vbroadcastsd ymm,[mem]和其他广播加载输入是完全由加载端口处理的1uop指令(广播是“免费的”)。

这样做四个广播负载的总成本是4条指令.融合域:4 4uops。未融合域: p2/p3的4个uop。吞吐量:每个周期有两个向量。

哈斯韦尔只有一个洗牌单位,在port5上。使用load+shuffle执行所有的广播加载都会在p5上造成瓶颈。

最大广播吞吐量可能是混合了vbroadcastsd ymm,m64和杂乱:

代码语言:javascript
复制
## Haswell maximum broadcast throughput with AVX1
vbroadcastsd    ymm0, [rsi]
vbroadcastsd    ymm1, [rsi+8]
vbroadcastf128  ymm2, [rsi+16]     # p23 only on Haswell, also p5 on SnB/IvB
vunpckhpd       ymm3, ymm2,ymm2
vunpcklpd       ymm2, ymm2,ymm2
vbroadcastsd    ymm4, [rsi+32]     # or vaddpd ymm0, [rdx+something]
#add             rsi, 40

这些寻址模式中的任何一个都可以是两个寄存器索引的寻址模式,因为他们不需要微型保险丝就能变成一个超级机器人。

AVX1: 5次/2周期,饱和p2/p3和p5。(忽略16B负载上的缓存行拆分)。6个融合域uops,每2个循环只留下2个uop来使用这5个向量.真正的代码可能会使用一些负载吞吐量来加载其他的东西(例如,来自另一个数组的非广播32B负载,可能作为内存操作数到ALU指令),或者给存储库留下空间来窃取p23而不是使用p7。

代码语言:javascript
复制
## Haswell maximum broadcast throughput with AVX2
vmovups         ymm3, [rsi]
vbroadcastsd    ymm0, xmm3         # special-case for the low element; compilers should generate this from _mm256_permute4x64_pd(v, 0)
vpermpd         ymm1, ymm3, 0b01_01_01_01   # NASM syntax for 0x99
vpermpd         ymm2, ymm3, 0b10_10_10_10
vpermpd         ymm3, ymm3, 0b11_11_11_11
vbroadcastsd    ymm4, [rsi+32]
vbroadcastsd    ymm5, [rsi+40]
vbroadcastsd    ymm6, [rsi+48]
vbroadcastsd    ymm7, [rsi+56]
vbroadcastsd    ymm8, [rsi+64]
vbroadcastsd    ymm9, [rsi+72]
vbroadcastsd    ymm10,[rsi+80]    # or vaddpd ymm0, [rdx + whatever]
#add             rsi, 88

AVX2:每4周11个载体,饱和p23和p5。(忽略32B负载的缓存行拆分.)。融合域:12个uop,在此之后每4个周期留下2个uop。

我认为32B的非对齐负载在性能上比像vbroadcastf128这样的未对齐16B负载更加脆弱。

英特尔SnB/IvB:

vbroadcastsd ymm, m64是两个融合域的uop: p5 (洗牌)和p23 (load).

vbroadcastss xmm, m32和movddup xmm, m64是单uop负载端口。有趣的是,vmovddup ymm, m256也是一个单uop端口指令,但与所有256 b负载一样,它占用一个加载端口2个周期。它仍然可以在第二个周期生成一个存储地址。尽管如此,对于未对齐的32B负载,这个uarch并不能很好地处理缓存行分割。gcc默认使用movups / vinsertf128处理-mtune=sandybridge / -mtune=ivybridge未对齐的32B负载。

4x广播负载:8个融合域uop:4 p5和4 p23.吞吐量:每4个周期有4个向量,端口5上有瓶颈。同一周期中来自同一缓存行的多个负载不会导致缓存库冲突,因此这远远不能满足负载端口(也需要存储地址生成)。这种情况只发生在同一周期的两条不同缓存行的同一银行上。

如果uop-缓存是冷的,那么多个2-uop指令之间没有其他指令是解码器的最坏情况,但是一个好的编译器会在它们之间混合单个uop指令。

SnB有两个洗牌单元,但只有p5上的一个能处理在AVX中有256 b版本的洗牌。使用p1整型洗牌uop向xmm寄存器的两个元素广播双元素并不能使我们得到任何结果,因为vinsertf128 ymm,ymm,xmm,i采用p5洗牌uop。

代码语言:javascript
复制
## Sandybridge maximum broadcast throughput: AVX1
vbroadcastsd    ymm0, [rsi]
add             rsi, 8

一个时钟,饱和的p5,但只使用一半的p23容量。

我们可以节省一个负载uop,而代价是再进行2次洗牌,吞吐量=每3个时钟有两个结果:

代码语言:javascript
复制
vbroadcastf128  ymm2, [rsi+16]     # 2 uops: p23 + p5 on SnB/IvB
vunpckhpd       ymm3, ymm2,ymm2    # 1 uop: p5
vunpcklpd       ymm2, ymm2,ymm2    # 1 uop: p5

如果商店是竞争对手vperm2f128 -> 4x vunpckh/lpd的一部分,那么进行32B加载并使用2x p23 4xvunpckh/lpd解压可能会有所帮助。

票数 3
EN

Stack Overflow用户

发布于 2014-05-13 15:51:38

这里有一个基于Z Boson最初答案的变体(在编辑之前),使用两个128位的加载而不是一个256位的加载。

代码语言:javascript
复制
__m256d b01 = _mm256_castpd128_pd256(_mm_load_pd(&b[4*k+0]));
__m256d b23 = _mm256_castpd128_pd256(_mm_load_pd(&b[4*k+2]));
__m256d b0101 = _mm256_permute2f128_pd(b01, b01, 0);
__m256d b2323 = _mm256_permute2f128_pd(b23, b23, 0);
__m256d b0000 = _mm256_permute_pd(b0101, 0);
__m256d b1111 = _mm256_permute_pd(b0101, 0xf);
__m256d b2222 = _mm256_permute_pd(b2323, 0);
__m256d b3333 = _mm256_permute_pd(b2323, 0xf);

在我的例子中,这比使用一个256位负载稍微快一些,可能是因为第一个置换可以在第二个128位负载完成之前启动。

编辑: gcc将两个负载和前两个置换编译成

代码语言:javascript
复制
vmovapd (%rdi),%xmm8
vmovapd 0x10(%rdi),%xmm4
vperm2f128 $0x0,%ymm8,%ymm8,%ymm1
vperm2f128 $0x0,%ymm4,%ymm4,%ymm2

Paul关于使用_mm256_broadcast_pd()的建议可以写成:

代码语言:javascript
复制
__m256d b0101 = _mm256_broadcast_pd((__m128d*)&b[4*k+0]);
__m256d b2323 = _mm256_broadcast_pd((__m128d*)&b[4*k+2]);

它会编译成

代码语言:javascript
复制
vbroadcastf128 (%rdi),%ymm6
vbroadcastf128 0x10(%rdi),%ymm11

并且比做两个vmovapd+vperm2f128 (测试)更快。

在我的代码中,它是由向量执行端口而不是L1缓存访问绑定的,它仍然比4 _mm256_broadcast_sd()慢一点,但我认为L1带宽受限的代码会从中受益很大。

票数 1
EN
页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接:

https://stackoverflow.com/questions/23633241

复制
相关文章

相似问题

领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档