Question

想象一下，我有这个幼稚的功能来检测球面重叠。这个问题的重点并不是真正讨论在球上进行命中测试的最佳方法，因此这仅是为了说明。

inline bool sphere_hit(float x1, float y1, float z1, float r1,
        float x2, float y2, float z2, float r2) {
    float xd = (x1 - x2);
    float yd = (y1 - y2);
    float zd = (z1 - z2);

    float max_dist = (r1 + r2);

    return xd * xd + yd * yd + zd * zd < max_dist * max_dist;
}

我将其称为嵌套循环，如下所示：

std::vector<float> xs, ys, zs, rs;
int n_spheres;
// <snip>
int n_hits = 0;
for (int i = 0; i < n_spheres; ++i) {
    for (int j = i + 1; j < n_spheres; ++j) {
        if (sphere_hit(xs[i], ys[i], zs[i], rs[i],
                xs[j], ys[j], zs[j], rs[j])) {
            ++n_hits;
        }
    }
}
std::printf("total hits: %d\n", n_hits);

现在，clang（带有-O3 -march=native）很聪明，可以弄清楚如何将此循环矢量化（并展开）为256位avx2指令。太棒了！

但是，如果我做的事情比增加命中数复杂得多，例如调用某个任意函数handle_hit(i, j)，则clang会发出天真的标量版本。

命中率应该非常罕见，所以我认为应该进行的是检查每个矢量化循环迭代中的 any 通道的值是否正确，如果是，则跳转到标量慢路径。 vcmpltps后跟vmovmskps应该可以实现。但是，即使用sphere_hit包围了对__builtin_expect(..., 0)的调用，我也无法发出clang来发出此代码。

Answer 1

实际上，可以说服clang将这些代码向量化。带有编译器选项 -Rpass-analysis=loop-vectorize -Rpass=loop-vectorize -Rpass-missed=loop-vectorize，clang声称浮点运算是矢量化的，已由Godbolt output确认。（带红色下划线的for不是错误，而是矢量化报告）。

可以通过将sphere_hit的结果作为字符存储到临时数组hitx8中来进行矢量化。然后，通过从内存中将8个字符读取为一个sphere_hit，每次迭代测试8个uint64_t a结果。由于条件a!=0，这应该非常有效（请参见下面的代码）仍然很少见，因为球体命中非常少。而且，数组hitx8可能大部分时间都在L1或L2缓存中。

我没有测试代码的正确性，但是至少自动向量化的想法应该可以工作。

/* clang -Ofast -Wall -march=broadwell -Rpass-analysis=loop-vectorize -Rpass=loop-vectorize -Rpass-missed=loop-vectorize */
#include<string.h>
char sphere_hit(float x1, float y1, float z1, float r1,
        float x2, float y2, float z2, float r2);
void handle_hit(int i, int j);

void vectorized_code(float* __restrict xs, float* __restrict ys, float* __restrict zs, float* __restrict rs, char* __restrict hitx8, int n_spheres){
    unsigned long long int a;
    for (int i = 0; i < n_spheres; ++i) {
        for (int j = i + 1; j < n_spheres; ++j){
            /* Store the boolean results temporarily in char array hitx8.     */
            /* The indices of hitx8 are shifted by i+1, so the loop           */
            /* starts with hitx8[0]                                           */
            /* char array hitx8 should have n_spheres + 8 elements            */
            hitx8[j-i-1] = sphere_hit(xs[i], ys[i], zs[i], rs[i],
                    xs[j], ys[j], zs[j], rs[j]);
        }
        for (int j = n_spheres; j < n_spheres+8; ++j){
            /* Add 8 extra zeros at the end of hitx8.                   */
            hitx8[j-i-1] = 0;     /* hitx8 is 8 elements longer than xs */
        }
        for (int j = i + 1; j < n_spheres; j=j+8){
            memcpy(&a,&hitx8[j-i-1],8);
            /* Check 8 sphere hits in parallel:                                   */
            /* one `unsigned long long int a` contains 8 boolean values here      */ 
            /* The condition a!=0 is still rare since sphere hits are very rare.  */
            if (a!=0ull){ 
                if (hitx8[j-i-1+0] != 0) handle_hit(i,j+0);
                if (hitx8[j-i-1+1] != 0) handle_hit(i,j+1);
                if (hitx8[j-i-1+2] != 0) handle_hit(i,j+2);
                if (hitx8[j-i-1+3] != 0) handle_hit(i,j+3);
                if (hitx8[j-i-1+4] != 0) handle_hit(i,j+4);
                if (hitx8[j-i-1+5] != 0) handle_hit(i,j+5);
                if (hitx8[j-i-1+6] != 0) handle_hit(i,j+6);
                if (hitx8[j-i-1+7] != 0) handle_hit(i,j+7);
            }
        }
    }
}


inline char sphere_hit(float x1, float y1, float z1, float r1,
        float x2, float y2, float z2, float r2) {
    float xd = (x1 - x2);
    float yd = (y1 - y2);
    float zd = (z1 - z2);

    float max_dist = (r1 + r2);

    return xd * xd + yd * yd + zd * zd < max_dist * max_dist;
}

是否可以说服clang在不使用内部函数的情况下自动矢量化此代码？

1 个答案: