Question

我用C中的AVX2，FMA制作了矩阵矢量乘法程序。我使用带有-mfma，-mavx的GCC ver7进行了编译。

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

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

我知道AVX2使用ymm寄存器，该寄存器可以使用4个双精度浮点数。因此，如果矩阵是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的向量，但是循环条件仅检查 first 向量元素是入站的，因此您最多可以写入3x8 =的外部对象m不是4的倍数时为24个字节。

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

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

在许多情况下（例如，仅写目标），在数组末尾结束的未对齐向量加载非常好（当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情况下，掩码为如果您不能安全地读取矩阵的末尾，则可能需要掩盖的负载以及掩盖的存储。

您还可以考虑将行对齐以提高效率，或者将行距与行的逻辑长度分开。（即，将行填充到32字节边界）。在行末尾保留填充可以简化清理过程，因为您始终可以完成写入填充的整个矢量。

特殊情况m==2 ：您不想广播b[]中的一个元素，而是想将两个元素广播到{{1}的两个128位通道中}，因此一个256位FMA可以一次执行2行。

当矩阵尺寸不是4的倍数时，如何避免AVX2的错误？

1 个答案: