Arrayfire 矢量化

Question

我正在尝试加快以下计算，但未能达到所需的速度。我确定问题出在我的代码上，而不是 GPU 的物理限制。

我有一个 10,000 x 6 x 6 的矩阵 V。 另一个矩阵 P 是 6 x 1,000

都复杂

我需要做 V * P（应该是 10,000 x 6 x 1000） 取它的大小（或 mag sq），然后在 6 维中求和。 产生 10,000 x 1000 的实际值。

我尝试了以下方法：

af::array V{ 10000, 6, 6, c32 };
af::array P{ 6, 1000, c32 };
af::array VP = af::matmul(V, P); (results in 10,000x1000x6 - ok, as long as i still sum in the 6 dim)
af::array res = af::sum(af::abs(VP),2);

这还不够快。然后我尝试将 V 转换为数组，所以我有：

af::array V[6] = { af::array{ 10000, 6, c32 },
            af::array{ 10000, 6, c32 }, af::array{ 10000, 6, c32 }, af::array{
                    10000, 6, c32 }, af::array{ 10000, 6, c32 }, af::array{
                    10000, 6, c32 } };
af::array VP[6];
af::array res;
for (int i = 0; i < 6; i++)
{
    VP[i] = af::matmul(V[i], P);
}
res= af::abs(mCalledData[0]);

for (int i = 1; i < 6; i++)
{
    res+= af::abs(VP[i]);
}

这有大约 2 倍的加速。我想出了另一种解决方案，但是采用 3 个数组的 af::matmult 不支持选项（如 Hermitian）并且不支持 gfor，所以我无法尝试这条路线。

目前，矩阵乘法（在这两种方法中）大约需要 2.2 毫秒，看起来 arrayfire 可以将 abs 和 sum 组合成一个需要大约 2 毫秒的 JIT 内核。

我对arrayfire 的了解有限，所以我猜有一些我没有想到的东西。有谁知道如何提高这个算法的速度？

谢谢！

Answer 1

我可以确认您的发现，循环版本的速度大约是批处理 matmul 的两倍。 Matmul 本身本质上并不是在您的代码 sn-p 中花费较长运行时间的那个，它是另一个在 abs 之后沿第三维求和的操作，这是昂贵的。原因如下。

1) sum(abs(result)) - abs 在这里又不是问题。 Sum 是归约算法，通常在快速移动的维度上非常快。然而，沿更高维度减少元素步幅是连续元素的矩阵大小。与沿连续位置的减少相比，这代价高昂。

2) looped abs additions - 然而，这个版本正在访问内存中连续的元素，因为我们基本上是添加 6 个矩阵的各个元素。最重要的是，整个循环（连同 abs OP）将被转换为一个 JIT 内核，该内核执行以下非常有效的操作。

res = res + ptr0[i] + ptr1[i] + ptr2[i] + ptr0[i] + ptr1[i]

以上只是说明，并不是准确的 JIT 内核。

因此，在这种特定情况下，批处理版本比循环版本更快，因为正在对 matmul 的结果执行归约操作。

我的测试 GPU：GTX 1060

单个[10k x 6] * [6 x 1k] 的 matmul 本身在 GTX 1060 上大约是半毫秒。至少我认为，在我的 GTX 1060 上，六个这样的 matmul 不能在毫秒内完成。你的目标运行时是什么？

已编辑（2020 年 1 月 10 日）：- 实际上，这不起作用，因为 abs 对每个 matmul 的结果进行了操作。

您可以尝试在 ArrayFire 的 master 分支中查看我们最新的 gemm 类别条目。但是，在我们的下一个功能版本 3.7 之前，您必须从源代码构建 arrayfire。您可以查看以下页面的文档。

https://github.com/arrayfire/arrayfire/blob/master/include/af/blas.h#L230

遵循Carray from cuBLAS gemm API的原则。