c - 当矩阵维度不是4的倍数时，如何避免AVX2的错误？

Question

我用 C 语言使用 AVX2、FMA 编写了矩阵 vector 乘法程序。我使用 GCC ver7 和 -mfma、-mavx 进行编译。

但是，我收到错误“已释放对象的校验和不正确 - 对象可能在释放后被修改。”

我认为如果矩阵维度不是 4 的倍数，就会产生错误。

我知道AVX2使用ymm寄存器，可以使用4个 double float 。因此，如果矩阵是 4 的倍数，我可以使用 AVX2 而不会出现错误。

但是，这是我的问题。如果矩阵不是 4 的倍数，如何有效地使用 AVX2 ???

这是我的代码。

#include "stdio.h"
#include "math.h"
#include "stdlib.h"
#include "time.h"
#include "x86intrin.h"

void mv(double *a,double *b,double *c, int m, int n, int l)
{
    __m256d va,vb,vc;
    int k;
    int i;
    for (k = 0; k < l; k++) {
        vb = _mm256_broadcast_sd(&b[k]);
        for (i = 0; i < m; i+=4) {
            va = _mm256_loadu_pd(&a[m*k+i]);
            vc = _mm256_loadu_pd(&c[i]);
            vc = _mm256_fmadd_pd(vc, va, vb);
            _mm256_storeu_pd( &c[i], vc );
        }
    }
}
int main(int argc, char* argv[]) {

    // set variables
    int m;
    double* a;
    double* b;
    double* c;
    int i;
    int temp=0;
    struct timespec startTime, endTime;

    m=9;
    // main program

    // set vector or matrix
    a=(double *)malloc(sizeof(double) * m*m);
    b=(double *)malloc(sizeof(double) * m*1);
    c=(double *)malloc(sizeof(double) * m*1);

    for (i=0;i<m;i++) {
        a[i]=1;
        b[i]=1;
        c[i]=0.0;
    }
    for (i=m;i<m*m;i++) {
        a[i]=1;
    }

    // check start time
    clock_gettime(CLOCK_REALTIME, &startTime);
    mv(a, b, c, m, 1, m);
    // check end time
    clock_gettime(CLOCK_REALTIME, &endTime);

    free(a);
    free(b);
    free(c);
    return 0;
}

Answer 1

您加载并存储 4 double 的 vector ，但循环条件仅检查第一个 vector 元素是否在边界内，因此当 m 时，您可以最多写入 3x8 = 24 字节的外部对象不是 4 的倍数。

您需要类似 i < (m-3) 的内容在主循环中，以及用于处理最后部分数据 vector 的清理策略。使用 SIMD 进行矢量化非常类似于展开:您必须检查是否可以在循环条件中执行多个 future 元素。

标量清理循环效果很好，但我们可以做得更好。例如，在最后一个完整的 256 位 vector (即最多 1 个)之后，在进行标量之前，执行尽可能多的 128 位 vector 。

在许多情况下(例如只写目标)，在数组末尾结束的未对齐 vector 加载非常好(当 m>=4 时)。如果 m%4 != 0 它可以与主循环重叠，但这没关系，因为您的输出数组不会与您的输入重叠，因此作为单个清理的一部分重做元素比通过分支来避免它要便宜。

但这在这里不起作用，因为你的逻辑是 c[i+0..3] += ... ，因此重做一个元素会导致错误。

// cleanup using a 128-bit FMA, then scalar if there's an odd element.
// untested

void mv(double *a,double *b,double *c, int m, int n, int l)
{
   /*  the loop below should actually work for m=1..3, but a separate strategy might be good.
    if (m < 4) {
        // maybe check m >= 2 and use __m128 vectors?
        // or vectorize differently?
    }
   */


    for (int k = 0; k < l; k++) {
        __m256 vb = _mm256_broadcast_sd(&b[k]);
        int i;
        for (i = 0; i < (m-3); i+=4) {
            __m256d va = _mm256_loadu_pd(&a[m*k+i]);
            __m256d vc = _mm256_loadu_pd(&c[i]);
                    vc = _mm256_fmadd_pd(vc, va, vb);
            _mm256_storeu_pd( &c[i], vc );
        }
        if (i<(m-1)) {
            __m128d lasta = _mm_loadu_pd(&a[m*k+i]);
            __m128d lastc = _mm_loadu_pd(&c[i]);
                    lastc = _mm_fmadd_pd(lastc, va, _mm256_castpd256_pd128(vb));
                _mm_storeu_pd( &c[i], lastc );
            // i+=2;  // last element only checks m odd/even, doesn't use i
        }
        // if (i<m)
        if (m&1) {
            // odd number of elements, do the last non-vector one
            c[m-1] += a[m*k + m-1] * _mm256_cvtsd_f64(vb);
        }

    }
}

我还没有具体了解 gcc/clang -O3 是如何编译它的。有时，编译器试图对清理代码变得过于聪明(例如，尝试自动矢量化标量清理循环)。

其他策略可能包括使用 AVX 掩码存储来处理最后最多 4 个元素:每个矩阵行的末尾都需要相同的掩码，因此生成一次，然后在每行的末尾使用它可以乖一点。请参阅Vectorizing with unaligned buffers: using VMASKMOVPS: generating a mask from a misalignment count? Or not using that insn at all 。 (为了简化分支，您可以对其进行设置，以便主循环仅转到 i < (m-4) ，然后您始终运行清理。在 m%4 == 0 情况下，掩码为全 1，因此如果您无法安全地读取矩阵末尾，则可能需要屏蔽加载和屏蔽存储。

<小时/>

您还可以考虑对齐行以提高效率，或者考虑与行的逻辑长度分开的行跨距。 (即将行填充到 32 字节边界)。在行末尾保留填充可以简化清理工作，因为您始终可以执行写入填充的整个 vector 。

<小时/>

特殊情况m==2 :而不是广播 b[] 中的一个元素，您想要将 2 个元素广播到 __m256d 的两个 128 位 channel 中，因此一个 256 位 FMA 可以一次处理 2 行。