在GCC中生成沒有cmp指令的循環

Question

我有許多緊湊的循環，我正在嘗試使用GCC和內在函數進行優化。 考慮例如以下功能。

void triad(float *x, float *y, float *z, const int n) {
    float k = 3.14159f;
    int i;
    __m256 k4 = _mm256_set1_ps(k);
    for(i=0; i<n; i+=8) {
        _mm256_store_ps(&z[i], _mm256_add_ps(_mm256_load_ps(&x[i]), _mm256_mul_ps(k4, _mm256_load_ps(&y[i]))));
    }
}

這會產生這樣的主循環

20: vmulps ymm0,ymm1,[rsi+rax*1]
25: vaddps ymm0,ymm0,[rdi+rax*1]
2a: vmovaps [rdx+rax*1],ymm0
2f: add    rax,0x20
33: cmp    rax,rcx
36: jne    20 

但是cmp指令是不必要的。 而不是讓rax從零開始並在sizeof(float)*n處完成，我們可以將基本指針（ rsi ， rdi和rdx ）設置為數組的末尾，並將rax設置為-sizeof(float)*n然后測試為零。 我可以用我自己的匯編代碼這樣做

.L2  vmulps          ymm1, ymm2, [rdi+rax]
     vaddps          ymm0, ymm1, [rsi+rax]
     vmovaps         [rdx+rax], ymm0
     add             rax, 32
     jne             .L2

但我無法讓GCC這樣做。 我現在有幾個測試，這會產生重大影響。 直到最近，GCC和內在函數都讓我很好，所以我想知道是否有編譯器開關或重新排序/更改我的代碼的方法，因此cmp指令不是用GCC生成的。

我嘗試了以下但它仍然產生cmp 。 我嘗試的所有變化仍然產生cmp 。

void triad2(float *x, float *y, float *z, const int n) {
    float k = 3.14159f;
    float *x2 = x+n;
    float *y2 = y+n;
    float *z2 = z+n;    
    int i;
    __m256 k4 = _mm256_set1_ps(k);
    for(i=-n; i<0; i+=8) {
        _mm256_store_ps(&z2[i], _mm256_add_ps(_mm256_load_ps(&x2[i]), _mm256_mul_ps(k4, _mm256_load_ps(&y2[i]))));
    }
}

編輯：我感興趣的是為這些函數最大化指令級並行（ILP），這些函數適合L1緩存（實際上對於n=2048 ）。 盡管可以使用展開來改善帶寬，但是可以降低ILP（假設可以在不展開的情況下獲得全帶寬）。

編輯：這是Core2（前Nehalem），IvyBridge和Haswell系統的結果表。 內在函數是使用內在函數的結果，unroll1是我的匯編代碼不使用cmp ，而unroll16是我的匯編代碼展開16次。 百分比是峰值性能的百分比（頻率* num_bytes_cycle，其中num_bytes_cycle對於SSE為24，對於AVX為48，對於FMA為96）。

                 SSE         AVX         FMA
intrinsic      71.3%       90.9%       53.6%      
unroll1        97.0%       96.1%       63.5%
unroll16       98.6%       90.4%       93.6%
ScottD         96.5%
32B code align             95.5%

對於SSE，我得到的結果幾乎與unrol一樣好，只有當我不使用cmp才會展開。 在AVX上，我得到了最好的結果，沒有展開，也沒有使用cmp 。 有趣的是，在IB展開實際上更糟糕。 在Haswell，我通過展開得到了最好的結果。 這就是我問這個問題的原因 。 可以在該問題中找到測試它的源代碼。

編輯：

基於ScottD的答案，我現在得到了近97％的內部函數用於我的Core2系統（在Nehalem 64位模式之前）。 我不確定為什么cmp實際上很重要，因為無論如何它應該每次迭代需要2個時鍾周期。 對於Sandy Bridge來說，效率損失是由於代碼對齊而不是額外的cmp 。 在Haswell上，無論如何只展開作品。

Answer 1

這個怎么樣。 編譯器是gcc 4.9.0 mingw x64：

void triad(float *x, float *y, float *z, const int n) {
    float k = 3.14159f;
    intptr_t i;
    __m256 k4 = _mm256_set1_ps(k);

    for(i = -n; i < 0; i += 8) {
        _mm256_store_ps(&z[i+n], _mm256_add_ps(_mm256_load_ps(&x[i+n]), _mm256_mul_ps(k4, _mm256_load_ps(&y[i+n]))));
    }
}

gcc -c -O3 -march = corei7 -mavx2 triad.c

0000000000000000 <triad>:
   0:   44 89 c8                mov    eax,r9d
   3:   f7 d8                   neg    eax
   5:   48 98                   cdqe
   7:   48 85 c0                test   rax,rax
   a:   79 31                   jns    3d <triad+0x3d>
   c:   c5 fc 28 0d 00 00 00 00 vmovaps ymm1,YMMWORD PTR [rip+0x0]
  14:   4d 63 c9                movsxd r9,r9d
  17:   49 c1 e1 02             shl    r9,0x2
  1b:   4c 01 ca                add    rdx,r9
  1e:   4c 01 c9                add    rcx,r9
  21:   4d 01 c8                add    r8,r9

  24:   c5 f4 59 04 82          vmulps ymm0,ymm1,YMMWORD PTR [rdx+rax*4]
  29:   c5 fc 58 04 81          vaddps ymm0,ymm0,YMMWORD PTR [rcx+rax*4]
  2e:   c4 c1 7c 29 04 80       vmovaps YMMWORD PTR [r8+rax*4],ymm0
  34:   48 83 c0 08             add    rax,0x8
  38:   78 ea                   js     24 <triad+0x24>

  3a:   c5 f8 77                vzeroupper
  3d:   c3                      ret

就像你手寫的代碼一樣，gcc使用5條循環指令。 gcc代碼使用scale = 4，其中你使用scale = 1。 我能夠讓gcc使用scale = 1和5指令循環，但C代碼很笨拙，循環中的2個AVX指令從5個字節增長到6個字節。

Answer 2

英特爾Ivy Bridge或更高版本上的指令解碼器可以將cmp和jne融合到管道中的單個操作中（稱為宏操作融合），因此在這些最近的處理器上cmp應該消失。

Answer 3

最終代碼：

#define SF sizeof(float)
#ifndef NO                   //floats per vector, compile with -DNO = 1,2,4,8,...
#define NO 8                 //MUST be power of two
#endif

void triadfinaler(float const *restrict x, float const *restrict y,   \
                  float *restrict z, size_t n)
{
  float *restrict d = __builtin_assume_aligned(z, NO*SF);       //gcc builtin,
  float const *restrict m = __builtin_assume_aligned(y, NO*SF); //optional but produces
  float const *restrict a = __builtin_assume_aligned(x, NO*SF); //better code
  float const k = 3.14159f;
  n*=SF;
  while (n &= ~((size_t)(NO*SF)-1))    //this is why NO*SF must be power of two
    {
      size_t nl = n/SF;
      for (size_t i = 0; i<NO; i++)
        {
          d[nl-NO+i] = k * m[nl-NO+i] + a[nl-NO+i];
        }
      n -= (NO*SF);
    }
}

我更喜歡讓編譯器選擇指令，而不是使用內在函數（尤其是因為你使用的是intel-intrinsics，而gcc並不喜歡）。 無論如何，以下代碼在gcc 4.8上為我生成了很好的程序集：

void triad(float *restrict x, float *restrict y, float *restrict z, size_t n)
//I hope you weren't aliasing any function arguments... Oh, an it's void, not float
{
  float *restrict d = __builtin_assume_aligned(z, 32);  // Uh, make sure your arrays
  float *restrict m = __builtin_assume_aligned(y, 32);  // are aligned? Faster that way
  float *restrict a = __builtin_assume_aligned(x, 32);  //
  float const k = 3.14159f;
  while (n &= ~((size_t)0x7))       //black magic, causes gcc to omit code for non-multiples of 8 floats
    {
      n -= 8;                       //You were always computing on 8 floats at a time, right?
      d[n+0] = k * m[n+0] + a[n+0]; //manual unrolling
      d[n+1] = k * m[n+1] + a[n+1];
      d[n+2] = k * m[n+2] + a[n+2];
      d[n+3] = k * m[n+3] + a[n+3];
      d[n+4] = k * m[n+4] + a[n+4];
      d[n+5] = k * m[n+5] + a[n+5];
      d[n+6] = k * m[n+6] + a[n+6];
      d[n+7] = k * m[n+7] + a[n+7];
    }
}

這為我的corei7avx2生成了很好的代碼，-O3：

triad:
    andq    $-8, %rcx
    je  .L8
    vmovaps .LC0(%rip), %ymm1

.L4:
    subq    $8, %rcx
    vmovaps (%rsi,%rcx,4), %ymm0
    vfmadd213ps (%rdi,%rcx,4), %ymm1, %ymm0
    vmovaps %ymm0, (%rdx,%rcx,4)
    andq    $-8, %rcx
    jne .L4
    vzeroupper
.L8:
    rep ret
    .cfi_endproc

.LC0:
    .long   1078530000
    .long   1078530000
    .long   1078530000
    .long   1078530000
    .long   1078530000
    .long   1078530000
    .long   1078530000
    .long   1078530000

編輯：我有點失望的編譯器沒有優化這個代碼到最后一條指令，所以我搞砸了一點。 只是改變循環中的事物的順序擺脫了編譯器發出的AND ，這讓我走上了正確的軌道。 然后我只需要讓它不要在循環中進行不必要的地址計算。 嘆。

void triadtwo(float *restrict x, float *restrict y, float *restrict z, size_t n)
{
  float *restrict d = __builtin_assume_aligned(z, 32);
  float *restrict m = __builtin_assume_aligned(y, 32);
  float *restrict a = __builtin_assume_aligned(x, 32);
  float const k = 3.14159f;
  n<<=2;
  while (n &= -32)
    {
      d[(n>>2)-8] = k * m[(n>>2)-8] + a[(n>>2)-8];
      d[(n>>2)-7] = k * m[(n>>2)-7] + a[(n>>2)-7];
      d[(n>>2)-6] = k * m[(n>>2)-6] + a[(n>>2)-6];
      d[(n>>2)-5] = k * m[(n>>2)-5] + a[(n>>2)-5];
      d[(n>>2)-4] = k * m[(n>>2)-4] + a[(n>>2)-4];
      d[(n>>2)-3] = k * m[(n>>2)-3] + a[(n>>2)-3];
      d[(n>>2)-2] = k * m[(n>>2)-2] + a[(n>>2)-2];
      d[(n>>2)-1] = k * m[(n>>2)-1] + a[(n>>2)-1];
      n -= 32;
    }
}

丑陋的代碼？ 是。 但是大會 ：

triadtwo:
    salq    $2, %rcx
    andq    $-32, %rcx
    je  .L54
    vmovaps .LC0(%rip), %ymm1

.L50:
    vmovaps -32(%rsi,%rcx), %ymm0
    vfmadd213ps -32(%rdi,%rcx), %ymm1, %ymm0
    vmovaps %ymm0, -32(%rdx,%rcx)
    subq    $32, %rcx
    jne .L50
    vzeroupper
.L54:
    rep ret
    .cfi_endproc
.LC0:
    .long   1078530000
    .long   1078530000
    .long   1078530000
    .long   1078530000
    .long   1078530000
    .long   1078530000
    .long   1078530000
    .long   1078530000

Mmmmhhh ，循環中的五個指令，宏觀可融合的減法和分支......