Question

我试图使用阻塞和矢量内在函数来矢量化矩阵乘法。在我看来，矢量乘法中的加法部分不能被矢量化。你能否看看我是否可以改进我的代码以进一步进行矢量化？

    double dd[4], bb[4];
    __m256d op_a, op_b, op_d;
    for(i = 0; i < num_blocks; i++){
        for(j = 0; j < num_blocks; j++){
            for(k = 0; k < num_blocks; k++){
                for(ii = 0; ii < block_size ; ii++){
                    for(kk = 0; kk < block_size; kk++){
                        for(jj = 0; jj < block_size ; jj+=4){

                            aoffset=n*(i*block_size+ii)+j*block_size +jj ;
                            boffset=n*(j*block_size+jj)+k*block_size +kk;
                            coffset=n*(i*block_size+ii)+ k*block_size + kk;

                            bb[0]=b[n*(j*block_size+jj)+k*block_size +kk];
                            bb[1]=b[n*(j*block_size+jj+1)+k*block_size +kk];
                            bb[2]=b[n*(j*block_size+jj+2)+k*block_size +kk];
                            bb[3]=b[n*(j*block_size+jj+3)+k*block_size +kk];

                            op_a = _mm256_loadu_pd (a+aoffset);
                            op_b= _mm256_loadu_pd (bb);
                            op_d = _mm256_mul_pd(op_a, op_b);
                            _mm256_storeu_pd (dd, op_d);
                            c[coffset]+=(dd[0]+dd[1]+dd[2]+dd[3]);

                        }
                    }
                }
            }
        }
    }

感谢。

Answer 1

您可以使用此版本的矩阵乘法（c [i，j] = a [i，k] * b [k，j]）算法（标量版本）：

for(int i = 0; i < i_size; ++i)
{
    for(int j = 0; j < j_size; ++j)
         c[i][j] = 0;

    for(int k = 0; k < k_size; ++k)
    {
         double aa = a[i][k];
         for(int j = 0; j < j_size; ++j)
             c[i][j] += aa*b[k][j];
    }
}

矢量化版本：

for(int i = 0; i < i_size; ++i)
{
    for(int j = 0; j < j_size; j += 4)
         _mm256_store_pd(c[i] + j, _mm256_setzero_pd());

    for(int k = 0; k < k_size; ++k)
    {
         __m256d aa = _mm256_set1_pd(a[i][k]);
         for(int j = 0; j < j_size; j += 4)
         {
             _mm256_store_pd(c[i] + j, _mm256_add_pd(_mm256_load_pd(c[i] + j), _mm256_mul_pd(aa, _mm256_load_pd(b[k] + j))));
         }
    }
}

Answer 2

＆＃34;水平添加＆＃34;是SSE指令集的最新版本，因此如果您的目标是与许多不同的处理器兼容，则无法使用加速版本。

但是，您绝对可以对添加内容进行矢量化。请注意，内部循环仅影响单个coffset。你应该向外移动coffset计算（编译器会自动执行此操作，但如果你这样做，代码更具可读性），并且在最里面的循环中使用四个累加器，每{{1}只执行一次水平加法}。即使使用向量水平加法，这也是一种改进，对于标量水平加法，它非常大。

类似的东西：

coffset

您也可以事先在for(kk = 0; kk < block_size; kk++){ op_e = _mm256_setzero_pd(); for(jj = 0; jj < block_size ; jj+=4){ aoffset=n*(i*block_size+ii)+j*block_size +jj ; boffset=n*(j*block_size+jj)+k*block_size +kk; bb[0]=b[n*(j*block_size+jj)+k*block_size +kk]; bb[1]=b[n*(j*block_size+jj+1)+k*block_size +kk]; bb[2]=b[n*(j*block_size+jj+2)+k*block_size +kk]; bb[3]=b[n*(j*block_size+jj+3)+k*block_size +kk]; op_a = _mm256_loadu_pd (a+aoffset); op_b= _mm256_loadu_pd (bb); op_d = _mm256_mul_pd(op_a, op_b); op_e = _mm256_add_pd(op_e, op_d); } _mm256_storeu_pd(dd, op_e); coffset = n*(i*block_size+ii)+ k*block_size + kk; c[coffset] = (dd[0]+dd[1]+dd[2]+dd[3]); }上进行转置，而不是在最里面的循环中收集向量，从而加快速度。

使用内在函数向量化矩阵乘法的加法部分？

2 个答案: