为什么GCC不能对这个函数和循环进行向量化？

Question

为什么GCC不能对这个函数和循环进行向量化？

c++vectorizationopenmpsimdauto-vectorization

9

我正在尝试使一个函数启用SIMD并通过函数调用向量化循环。

#include <cmath>

#pragma omp declare simd
double BlackBoxFunction(const double x) {
    return 1.0/sqrt(x);
}

double ComputeIntegral(const int n, const double a, const double b) {
    const double dx = (b - a)/n;
    double I = 0.0;
    #pragma omp simd reduction(+: I)

    for (int i = 0; i < n; i++) {
      const double xip12 = a + dx*(double(i) + 0.5);
      const double yip12 = BlackBoxFunction(xip12);
      const double dI = yip12*dx;
      I += dI; 
  }
  return I;
}

对于上面的代码，如果我使用icpc编译它:

icpc worker.cc -qopenmp -qopt-report=5 -c

优化报告显示该函数和循环均被向量化。但是，如果我尝试使用 g++ 6.5 进行编译：

g++ worker.cc -O3 -fopenmp -fopt-info-vec-missed -funsafe-math-optimizations -c

输出显示note：not vectorized：control flow in loop。和note：bad loop form，循环无法矢量化。

如何使用GCC矢量化循环？

编辑：

如果我将函数编写到单独的文件中， worker.cc:

#include "library.h"

double ComputeIntegral(const int n, const double a, const double b) {
    const double dx = (b - a)/n;
    double I = 0.0;
    #pragma omp simd reduction(+: I)

    for (int i = 0; i < n; i++) {
      const double xip12 = a + dx*(double(i) + 0.5);
      const double yip12 = BlackBoxFunction(xip12);
      const double dI = yip12*dx;
      I += dI; 
  }
  return I;
}

library.h:

#ifndef __INCLUDED_LIBRARY_H__
#define __INCLUDED_LIBRARY_H__

#pragma omp declare simd
double BlackBoxFunction(const double x); 

#endif

和 library.cc 文件：

#include <cmath>

#pragma omp declare simd
double BlackBoxFunction(const double x) {
  return 1.0/sqrt(x);
}

然后我使用GCC编译它：

g++ worker.cc library.cc -O3 -fopenmp -fopt-info-vec-missed -funsafe-math-optimizations -c

它显示：

worker.cc:9:31: note: loop vectorized

但是

library.cc:5:18: note:not vectorized: control flow in loop.
library.cc:5:18: note:bad loop form.

这让我感到困惑。我想知道它是否已经矢量化。

- pangbryant

相关的GCC源代码在此：https://github.com/gcc-mirror/gcc/blob/gcc-6_5_0-release/gcc/tree-vect-loop.c#L1310。你可以看到，如果循环中有两个以上的基本块（包括循环机制本身），它会产生控制流警告。我猜这意味着函数调用将循环内容分成了两个或三个块；如果你手动内联`BlackBoxFunction`，它是否能正常工作？ - Rup

可能是GCC：两个类似循环之间的矢量化差异的重复。 - Damian

@Rup 我尝试了，但GCC仍然提示“循环中的控制流”和“错误的循环形式”。 - pangbryant

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- wim · Accepted Answer

在进行一些代码微调后，gcc可以实现向量化：

#include <cmath>

double BlackBoxFunction(const double x) {
    return 1.0/sqrt(x);
}

double ComputeIntegral(const int n, const double a, const double b) {
    const double dx = (b - a)/n;
    double I = 0.0;
    double d_i = 0.0;
    for (int i = 0; i < n; i++) {
      const double xip12 = a + dx*(d_i + 0.5);
      d_i = d_i + 1.0;
      const double yip12 = BlackBoxFunction(xip12);
      const double dI = yip12*dx;
      I += dI; 
  }
  return I;
}

这是使用编译器选项编译的：-Ofast -march=haswell -fopt-info-vec-missed -funsafe-math-optimizations。主循环编译为：

.L7:
    vaddpd  ymm2, ymm4, ymm7
    inc     eax
    vaddpd  ymm4, ymm4, ymm8
    vfmadd132pd     ymm2, ymm9, ymm5
    vsqrtpd ymm2, ymm2
    vdivpd  ymm2, ymm6, ymm2
    vfmadd231pd     ymm3, ymm5, ymm2
    cmp     eax, edx
    jne     .L7

请查看以下Godbolt链接。

我删除了#pragma omp ...，因为它们没有改善向量化，但也没有使向量化变差。

请注意，仅将编译器选项从-O3更改为-Ofast就足以启用向量化。然而，使用一个double计数器比每次迭代转换为双精度的int计数器更有效率。

还要注意，向量化报告非常误导人。检查生成的汇编代码以查看向量化是否成功。