我已经完成了相当多的线程级和进程级并行性,现在我正尝试使用英特尔 C++ 编译器进入指令级并行性,这是一个相当大的挑战。
在对循环进行一些自动矢量化和分析编译器日志时,我发现了一些我不太明白的“估计循环的最大行程数”。
例子:
double a[100],x[100],y[100]
...
for (i=0; i< 100; i++) {
a[i] = x[i] + y[i];
}
此循环输出 12 次行程的最大行程计数的估计值。 我在某处读到,矢量化过程每次旅行总共可以处理 8 个元素,只要每个循环过程的成本少于 6 个 u 操作,据我所知,这个示例循环的成本为 1存储,2 次读取和 1 次算术运算。
所以理论上,我的行程数应该是 100/8 = 12.5 次,因此是 13 次。
这是编译器做的汇总吗?或者是否有任何其他优化在后台进行,使流程的行程少于 13 次?
还有一个问题,我的每个周期 6 个 u 操作假设是否正确?有没有不适用的情况?
提前致谢
最佳答案
与其纠结于英特尔如何实现每个循环,不如尝试回答您有关指令级并行性的问题。
您的操作受读写限制,因此您可以忽略确定循环数的算术。这是通过 Broadwell 的 Core2 可以做的事情:
Core2: two 16 byte reads one 16 byte write per 2 clock cycles -> 24 bytes/clock cycle
SB/IB: two 32 byte reads and one 32 byte write per 2 clock cycles -> 48 bytes/clock cycle
HSW/BDW: two 32 byte reads and one 32 byte write per clock cycle -> 96 bytes/clock cycle
读取和写入的总字节数为sizeof(double)*100*3=2400
。所以快速估计需要的时间是
Core2: 2400/24 = 100 clock cycles
SB/IB: 2400/48 = 50 clock cycles
HSW/BDW: 2400/96 = 25 clock cycles
现在的问题是如何实现全带宽。
对于通过 Ivy Bridge 的 Core2,可以将负载之一与附加负载之一融合,以花费一个微融合微操作。另一个加载花费一个微操作,加载一个微操作。如果你想每次迭代都这样做,你 need to decrease a pointer and do a conditional jump as well .自 Nehalem 以来,这些可以进行宏融合,因此每次迭代的微融合/宏融合操作总数为:
Core2 Nehalem through Broadwell
vector add + load 1 1
vector load 1 1
vector store 1 1
scalar add 1 ½
conditional jump 1 ½
--------------------------------------------
total 5 4
对于通过 Ivy Bridge 的 Core2,要么两个负载需要相同的端口,要么负载和存储需要相同的端口。这需要两个时钟周期。对于 Haswell/Broadwell,可以在每个时钟周期执行此操作。然而,due to limitations on port 7 only statically allocated arrays can achieve this使用绝对 32 位地址 + 偏移寻址 ( which incidentally is not possible on OSX )。因此,对于 Haswell/Broadwell,如果数组不是静态分配的,您要么必须展开循环以在每个时钟周期执行操作,要么每次迭代需要 1.5 个时钟周期。以下是每个处理器每次迭代的时钟周期摘要:
Core2: 5 fused micro-ops/every two clock cycles
SB/IB: 4 fused micro-ops/every two clock cycles
HSW/BDW: 4 fused mirco-ops/every clock cycle for statically allocated array
HSW/BDW: 4 fused mirco-ops/every 1.5 clock cycles for non-statically allocated arrays
如果您使用堆栈分配的数组,您可能可以安全地读取缓冲区末尾。否则,您应该将阵列填充到 SIMD 宽度。那么循环的迭代次数为:
SSE2: (100+1)/2 = 51
AVX: (100+3)/4 = 26
根据我的经验,英特尔编译器会展开两次,这样迭代次数就会减半。展开两次的迭代次数为
SSE2: (100+3)/4 = 26
AVX: (100+7)/8 = 13
最后,就时钟周期而言,它是
Core2: 51*2 = 102 clock cycles
SB/IB: 26*2 = 51 clock cycles
HSW/BDW: 26*1.5 = 39 clock cycles for non-statically allocated arrays no-unroll
HSW/BDW: 26*1 = 26 clock cycles for statically allocated arrays no-unroll
HSW/BDW: 26*1 = 26 clock cycles with full unrolling
关于c++ - 英特尔自动矢量化行程计数解释?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/33303141/