AVX-512和分支

Question

我对于在分支方面理论上掩蔽可以做什么感到困惑。 假设我有一个Skylake-SP（哈，我希望......），我们忽略了编译器功能，理论上可能的是：

如果分支条件依赖于静态标志，并且所有分支都将数组设置为计算结果， 假设编译器不将其优化为两个单独的循环 ，它是否可以向量化？

do i = 1, nx
  if (my_flag .eq. 0) then
    a(i) = b(i) ** 2
  else
    a(i) = b(i) ** 3
  end if
end do

如果仅作为分支的子集设置有问题的值，它可以矢量化吗？

do i = 1, nx
  if (my_flag .eq. 0) then
    a(i) = b(i) ** 2
  end if
end do

如果分支条件本身依赖于矢量数据，它可以矢量化吗？

do i = 1, nx
  if (c(i) > 0) then
    a(i) = b(i) ** 2
  else
    a(i) = b(i) ** 3
  end if
end do

Answer 1

是的，对于所有循环，任何SSE2 / SSE4.1（对于blendps ）/ AVX / AVX-512都可以实现高效的asm实现，并且编译器在实践中进行自动向量化，但是gcc7.2 / clang5.0 / ICC18都错过了优化。

根据Skylake-AVX512的静态分析（见下文），最终循环的高效展开实现可以每1.25个时钟周期运行一个64字节结果向量（加上循环开销，具体取决于您展开的数量） 。 实际上， 如果您的数据在L1D高速缓存中很热， 则每个向量的1.33或1.5个时钟周期可能是可实现的。 否则你很容易在L2带宽上遇到瓶颈，因为每个存储矢量64B存储加载2x 64B。

对于循环的C版本，gcc，clang和ICC都会像我手工做的那样自动向量化 ：请参阅Godbolt编译器资源管理器中的 source + asm。

我不得不使用-ffast-math和gcc进行自动矢量化。 IDK为什么没有意识到它可以安全地自动矢量化而不破坏严格的FP规则。

Clang似乎分别评估tmp*tmp和tmp*tmp*tmp ，并将这两个结果混合而不是有条件地进行第二次乘法。

gcc两者都相乘并使用单独的movaps来合并另一种方式，因为它没有弄清楚如何反转条件。

ICC使用KNOTW来反转条件，但是然后使用合并掩蔽进行第二次乘法，就像我一样。

更改代码以在if分支而不是else分支中进行额外的乘法（ **3而不是**2 ）使得所有3个编译器生成更好的代码而没有从其他方式分支的每个错过优化。 （gcc仍然缺少优化，但ICC和clang看起来很稳定，两者基本上都是我手写代码所做的事情。）

ICC选择仅使用256b向量自动向量化。 也许它默认情况下是为了避免降低最大涡轮时钟速度？ 也许有一个选项可以使用全宽矢量？ gcc 8.0快照也可以，但gcc7.2使用ZMM向量。

---

AVX-512掩码寄存器和合并掩码使其更加高效，但是长时间使用SIMD（甚至非SIMD无分支代码）进行两种方式然后进行混合。 例如，为了基于矢量比较结果有条件地添加，使用该矢量比较结果作为AND掩码以保持一些元素不变，并使其他元素为零。

0是附加标识： x + 0 = x 。 因此，如果掩码是全零，则x + (y&mask)是无操作，如果掩码是全1，则x+y是x+y 。 请参阅如何在内在函数中使用if条件 。 （有趣的技巧：使用打包比较结果作为整数-1或0，因此您可以计算匹配但减去比较掩码）。

乘法不太简单，因为1是乘法身份，但你可以通过混合来解决这个问题。

假设编译器没有将它优化为两个单独的循环，它可以矢量化吗？

在第一种情况下，如果它没有将条件提升出循环并进行两次循环，那么您应该对编译器不满意。 特别是在第二种情况下，它只需要一个循环，因为如果条件为假，则不修改数组。

---

我们来谈谈第三种情况，因为它只是编译器不应该只提升条件的情况 。 （如果你的编译器感觉很愚蠢，它可以使用这个版本的循环不变掩码全0或全部为其他版本）。

if (c(i) > 0)

所以我们需要从c加载元素向量并与零进行比较。 AVX512可以为16个单精度float的向量执行此操作，其中一条指令具有屏蔽寄存器目标和存储器源操作数。

; with zmm0 = 0.0 in all elements, from vxorps xmm0,xmm0,xmm0 outside the loop.
vcmpps    k1, zmm0, [rdx],  _CMP_NLT_UQ     ; !(0 < c(i))

我知道（从已经写下一部分）我将要求k1对于c(i) > 0条件为假的元素为真。 只有第二个向量操作数可以是内存而不是寄存器，所以我不得不将其反转并使用不小于而不是大于。 （而且我不能只使用>=而不是< ，因为这会将无序的情况（一个或两个NaN）放在错误的类别中.FP比较有4个可能的结果：高于/低于/等于/无序，所以你有为所有4种情况选择一个做你想做的谓词（即源代码说的，如果你是编译器）。如果用-ffast-math编译，编译器可以忽略NaN的可能性。

如果需要将两个条件链接在一起，AVX512比较屏蔽指令可以屏蔽写入屏蔽的操作，具有零屏蔽或合并屏蔽。

vcmpltps    k1,        zmm1, zmm2       ; k1 = zmm1<zmm2
vcmpltps    k2{k1}{z}, zmm3, zmm4       ; k2 = (zmm3<zmm4) & (zmm1<zmm2)

zmm3k1为0时k2为0，因为我们使用k1作为零掩码。

---

  if (c(i) > 0) then
    a(i) = b(i) ** 2
  else
    a(i) = b(i) ** 3
  end if

这里的公共子表达式是b(i) * b(i) 。 我们可以通过乘以b(i)一个额外的时间得到b(i)**3 。

vmovups    zmm1, [rsi]       ; load a vector from b(i)
vmulps     zmm2, zmm1, zmm1  ; zmm2 = zmm1*zmm1 = b(i)**2

AVX-512可以基于掩码进行合并，作为（几乎）任何其他指令的一部分。

vmulps     zmm2{k1}, zmm2, zmm1  ; zmm2 *= zmm1   for elements where k1 is true

vmovups    [rdi], zmm2           ; store all 16 elements into a(i)

BTW，AVX512为商店提供合并屏蔽功能。 以前的SIMD指令集将从[rdi]加载，混合，然后存储回[rdi] 。 这意味着您可以比使用AVX1 / AVX2更有效地实现第二个循环（有时保留a(i)未修改）与每个元素的条件。

---

把这一切放在一起:( NASM语法）

 ; x86-64 System V calling convention
 ; args: rdi = a() output array.
 ;       rsi = b() input array
 ;       rdx = c() array to be tested for positive numbers
 ;       rcx = count (in elements)
 ; preferably all 64-byte aligned, but will work slowly if some aren't
 ; rcx must be >= 16, and a multiple of 16, because I didn't write any cleanup code

global square_or_cube
square_or_cube: 

    vxorps     xmm0,  xmm0,xmm0

 .loop:                          ; do {
    vcmpps     k1, zmm0, [rdx], 21    ; _CMP_NLT_UQ  ; !(0 < c(i))

    vmovups    zmm1, [rsi]            ; load a vector from b(i)
    vmulps     zmm2,     zmm1, zmm1   ; zmm2 = zmm1*zmm1 = b(i)**2

    vmulps     zmm2{k1}, zmm2, zmm1   ; zmm2 *= zmm1   for elements where k1 is true, otherwise unmodified.
    vmovups    [rdi], zmm2            ; store all 16 elements into a(i)

    ; TODO: unroll some and/or use indexed addressing mode tricks to save instructions
    add         rdi, 64      ; pointer increments
    add         rsi, 64
    add         rdx, 64

    sub         rcx, 16         ;  count -= 16 
    ja        .loop             ; } while(count>0);

---

我用IACA分析了这一点 （省略指针增量指令以模拟展开和更聪明的asm技巧）。 根据IACA的说法，即使是合并屏蔽的vmulps只是一个vmulps ，而且内存源指令微型融合到前端的单个uop。 （商店也是如此。）这是我所希望的，IACA的输出在这种情况下看起来是正确的，尽管我无法访问SKL-SP硬件上的性能计数器来检查。

$ iaca.sh -arch SKX avx512-conditional
Intel(R) Architecture Code Analyzer Version - 2.3 build:246dfea (Thu, 6 Jul 2017 13:38:05 +0300)
Analyzed File - avx512-conditional
Binary Format - 64Bit
Architecture  - SKX
Analysis Type - Throughput

Throughput Analysis Report
--------------------------
Block Throughput: 1.50 Cycles       Throughput Bottleneck: FrontEnd

Port Binding In Cycles Per Iteration:
---------------------------------------------------------------------------------------
|  Port  |  0   -  DV  |  1   |  2   -  D   |  3   -  D   |  4   |  5   |  6   |  7   |
---------------------------------------------------------------------------------------
| Cycles | 1.5    0.0  | 0.0  | 1.0    1.0  | 1.0    1.0  | 1.0  | 1.5  | 1.0  | 1.0  |
---------------------------------------------------------------------------------------

N - port number or number of cycles resource conflict caused delay, DV - Divider pipe (on port 0)
D - Data fetch pipe (on ports 2 and 3), CP - on a critical path
F - Macro Fusion with the previous instruction occurred
* - instruction micro-ops not bound to a port
^ - Micro Fusion happened
# - ESP Tracking sync uop was issued
@ - SSE instruction followed an AVX256/AVX512 instruction, dozens of cycles penalty is expected
X - instruction not supported, was not accounted in Analysis

| Num Of |                    Ports pressure in cycles                     |    |
|  Uops  |  0  - DV  |  1  |  2  -  D  |  3  -  D  |  4  |  5  |  6  |  7  |    |
---------------------------------------------------------------------------------
|   2^   |           |     | 1.0   1.0 |           |     | 1.0 |     |     | CP | vcmpps k1, zmm0, zmmword ptr [rdx], 0x15
|   1    |           |     |           | 1.0   1.0 |     |     |     |     |    | vmovups zmm1, zmmword ptr [rsi]
|   1    | 1.0       |     |           |           |     |     |     |     | CP | vmulps zmm2, zmm1, zmm1
|   1    | 0.5       |     |           |           |     | 0.5 |     |     | CP | vmulps zmm2{k1}, zmm2, zmm1
|   2^   |           |     |           |           | 1.0 |     |     | 1.0 |    | vmovups zmmword ptr [rdi], zmm2
|   1    |           |     |           |           |     |     | 1.0 |     |    | sub rcx, 0x10
|   0F   |           |     |           |           |     |     |     |     |    | jnbe 0xffffffffffffffdd
Total Num Of Uops: 8

---

AVX-512实际上有vfpclassps （C / C ++内在[_mm512_fpclass_ps_mask ] 4 ，asm文档，在相关的vfpclasspd （packed double）中有一个表），根据你选择的谓词对FP值进行分类。 它可能比使用恰好为零的另一个寄存器的完全比较稍微有效。
（实际上，根据IACA，它不是。两者都被InstLatx64电子表格列为3周期延迟.Agner Fog对Skylake-S（非AVX512台式机芯片）AVX2 cmpps的测量显示4个周期，所以很奇怪在生成掩码寄存器结果而不是向量时，AVX512版本的延迟较低。

我希望结果对于正数而言是假的，我认为vfpclassps可以通过将几乎所有谓词位设置为-Inf，有限负，安静和信令NaN，-0.0和+0.0来做到这一点。

vfpclassps    k1, [rdx], 0x1 | 0x2 | 0x4 | 0x10 | 0x40 | 0x80     ; QNaN | -0.0 | +0.0 | -Infinity | Negative (finite) | SNaN
; k1 = a 16-bit bitmap of which elements (from memory at [rdx]) need an extra multiply

vpfclassps很有意思，因为它可以让你区分+0.0和-0.0，就像你可以通过检查二进制表示中的符号位一样（就像你可以使用AVX2 vblendps将符号位用作混合控制一样，而不是先进行比较）。

此外，在这种情况下，它在循环外部保存一条指令，设置全零的寄存器。

---

相关：AVX512有指令乘以2**floor(x) （ vscalefpd ），但不能将数字乘以任意幂（整数或其他）。 Xeon Phi有AVX512ER ，可以为你提供2**x快速近似值（不含地板x ），但我们也不能直接使用指数函数，而且SKL-SP无论如何也没有AVX512ER。

---

IACA_start / end的NASM宏 ：

我是根据iaca_marks.h C / C ++标题iaca_marks.h 。

%if 1
%macro  IACA_start 0
     mov ebx, 111
     db 0x64, 0x67, 0x90
%endmacro
%macro  IACA_end 0
     mov ebx, 222
     db 0x64, 0x67, 0x90
%endmacro
%else
%define IACA_start
%define IACA_end
%endif

将它们包裹在您要分析的任何代码周围。

---

循环内循环不变条件的条件分支

编译器可以在循环内分支。 IDK，如果有的话会像这样编写代码，但他们当然可以。

; rdi = destination
; rsi = source
; edx = condition
; rcx = element count
global square_or_cube
square_or_cube: 

 .loop:                          ; do {
    vmovups    zmm1, [rsi]            ; load a vector from b(i)
    vmulps     zmm2, zmm1, zmm1   ; zmm2 = zmm1*zmm1 = b(i)**2

    test       edx,edx
    jz        .only_square        ; test-and-branch to conditionally skip the 2nd multiply
    vmulps     zmm2, zmm2, zmm1   ; zmm2 *= zmm1
   .only_square:

    vmovups    [rdi], zmm2        ; store all 16 elements into a(i)

    add         rdi, 64      ; pointer increments
    add         rsi, 64

    sub         rcx, 16         ;  count -= 16 
    ja        .loop             ; } while(count>0);

Answer 2

注意：这个答案主要讨论了一个非常具体的内存访问问题，当涉及到矢量化时，它主要应用于概念级别，将一系列标量访问转换为数组到矢量化访问，而不假设底层数组的哪些部分被映射。 在像Fortran这样的语言中，语言本身的语义可以保证数组是连续映射的，或者在进入循环之前进行边界检查可能足以避免下面提到的问题。

这个答案一般不应被视为对矢量化的良好处理，特别是在Fortran中。 有关矢量化问题的更全面的处理出现在另一个答案中 ，该答案也专门针对AVX-512。

---

向量化条件的一个经常被忽视的问题是，编译器可以通过混合或其他逐元素预测技术来矢量化您感兴趣的类型的条件循环， 只要它们能够证明向量化访问的元素与访问时相同。标量逐元素实现。 如果指令集不提供元素方式来执行关于此条件的向量加载，或者如果编译器无法使用它们，则这可以有效地阻止向量化。

换句话说，如果通过循环体的所有路径访问相同的元素，则编译器通常只能用普通向量加载完全向量化。

根本原因是编译后的代码不能访问原始代码语义无法访问的元素，即使它们稍后被“混淆”，因为这样做可能会导致错误！ 如果指令集不提供有条件地访问存储器中的元素并抑制未选择元素的故障的指令，则这是优化的重大障碍。

在你给出的例子中，这意味着（1）和（3）可以被矢量化“而不会提升条件”，而（2）则不能，因为（2）仅在if体中访问a[i]和b[i] ，但不是if if没有执行。 当然，一个真正的编译器只会在循环中提升一个简单的标志检查并且在myflag == false情况下根本不执行循环，所以这不是一个很好的例子。

让我们看一下包含所有示例的几个案例。 首先，我们需要一个无法悬挂的标志 - 让我们只使用一组bool值。 所以一个有趣的有点通用的循环，输出数组a ，两个输入数组b和c以及一个标志数组f可能看起来像：

do i = 1, nx
  if (f(i) > 0) then
    a(i) = g(b(i), c(i));
  else
    a(i) = h(b(i), c(i));
  end if
end do

根据对应于每个元素的标志f(i) ，我们将函数g或h应用于输入元素b(i)和c(i) 。 根据我的上述条件， 只有当 g和h实际访问b和c的相同元素时，我们才能进行矢量化。

让我们继续讨论上述两个实际工作示例：

void example1(bool* f, int* __restrict__ a, int* __restrict__ b, int* __restrict__ c, size_t n) {
    for (size_t i = 0; i < n; i++) {
        if (f[i]) {
            a[i] = b[i];
        } else {
            a[i] = c[i];
        }
    }
}

void example2(bool* f, int* __restrict__ a, int* __restrict__ b, int* __restrict__ c, size_t n) {
    for (size_t i = 0; i < n; i++) {
        if (f[i]) {
            a[i] = b[i] + c[i] ;
        } else {
            a[i] = b[i] - c[i] * 2 + 1 ;
        }
    }
}

两者都有相同的基本形式，但更难以矢量化？ 第一种是根据标志直接分配b[i]或c[i] 。 第二个是b[i]和c[i]的更复杂的函数， 它们在两个路径上都显着不同。

那么第二个更容易矢量化，因为它无条件地访问b[i]和c[i] 。 实际上，由于某种原因， gcc无法对其中任何一个进行矢量化。 clang只对第二个进行矢量化。 有点令人惊讶的是icc设法对两者进行矢量化 - 因为它足够智能使用vpmaskmovd ，这是一个屏蔽负载，可以抑制卸载元素的故障。

你可以在godbolt上检查生成的程序集 。

我最初开始这个答案的想法是，访问不同的数组元素目前是当前编译器矢量化的一个不可逾越的障碍，但那是因为我通常不检查icc 。 这对我来说实际上是新闻， icc以这种方式使用蒙面动作。 所以障碍就在那里，但至少有一些编译器会对它进行故障² 。

作为开发人员，您通常知道两个数组都是完全可访问的，因此可以安全地访问[0, n)范围内的b和c所有元素，将它传递给编译器会很好。 我尝试添加无条件的虚拟语句，如b[i] = b[i]; c[i] = c[i]; b[i] = b[i]; c[i] = c[i]; 或者... + c[i] * 0应该编译为空，但至少允许编译器在语义上看到所有元素都被访问。 确实“编译掉”但代码生成没有得到改进：不会发生额外的矢量化。 可能在完成vectorizaton分析之前，它们已经在编译过程的早期被淘汰，因此信息会丢失给矢量化器。

除了蒙面移动指令，这些指令不是免费的并且不完全通用，还有其他方法可以改善这种情况吗？ 编译器可以利用其对平台内存保护模型的了解。 例如，一旦访问了x86上的4K页面中的任何字节，就可以自由地读取该页面上的所有其他字节。 可以想象一个复杂的实现，从安全的标量代码开始，但只要对两个数组的写入被“注意到”切换到页面其余部分的向量化循环。

如果数组访问是对齐的，则可以播放类似的技巧：矢量化循环可以检查标志数组是统一0还是统一1，如果不是，使用简单的无条件无掩码读取实现是安全的，否则它会回退到更多认真执行。 如果面具很少是统一的，或者几乎总是统一的，那么这种转变显然只会有利可图³ ，因此在实践中可能不太可能实施。

---

²至少如果AVX可用：如果将第一个示例限制为AVX前指令， icc仍然无法对第一个示例进行矢量化，因为这是在vpmaskmovd/q和vmaskmovps/pd时。

³因为在这种情况下，如果您已经确定掩模是均匀的，那么您可以无条件地执行操作，只需执行if的选定侧而不进行任何掩蔽/混合，具体取决于它是uniform- 0还是uniform- 1 。 所以你最终得到了三个内部实现的循环：全零标志情况，all-1标志情况和混合标志情况，当下一个标志向量与当前循环不同时，它们之间会跳转。