openmp并行的矩阵向量乘法和加法任务

Question

我想计算以下矩阵向量乘法和加法运算：

y = (A + C + C^T + R + R^T + D1 + D1^T + D2 + D2^T)x

我可以使用 openmp 中的任务并行来加速此操作吗？代码如下

    y.setZero();
    int ny = y.size();
#pragma omp parallel shared(x)
{
#pragma omp single
    {
        VectorXd yA(ny),yC(ny), yCt(ny), yR(ny), yRt(ny), yD1(ny), yD1t(ny), yD2(ny), yD2t(ny);
        yA.setZero();
        yC.setZero();
        yCt.setZero();
        yR.setZero();
        yRt.setZero();
        yD1.setZero();
        yD1t.setZero();
        yD2.setZero();
        yD2t.setZero();

    #pragma omp task
        yA = A * x;
    #pragma omp task
        yC = C * x;
    #pragma omp task
        yCt = C.transpose() * x;
    #pragma omp task
        yR = R * x;
    #pragma omp task
        yRt = R.transpose() * x;
    #pragma omp task
        yD1 = D1 * x;
    #pragma omp task
        yD1t = D1.transpose() * x;
    #pragma omp task
        yD2 = D2 * x;
    #pragma omp task
        yD2t = D2.transpose() * x;

    #pragma omp taskwait
        y = yA + yC + yCt + yR + yRt + yD1 + yD1t + yD2 + yD2t;
    }
};

该代码基于 Eigen 库。与不使用 openmp 相比，我在计算机中观察不到明显的加速。但我认为可以与openmp并行。所以我问这个问题。如果有人能回答我的问题，我将不胜感激。

Answer 1

我可以使用 openmp 中的任务并行来加速此操作吗？代码如下
块引用

是的。
虽然在你的代码中，我可以看到 3 个需要改进的地方。

1) 数据共享 -
开始使用 OpenMP 时，我建议在您的任务中明确使用 default(none)、shared(...) 或 firstprivate(...) - 这样您就可以了解变量的实际复制方式。

2) 缩放 -
就性能而言，您的代码不会扩展到 9 个核心以上，因为您只执行 9 个任务。
在进行代数运算时，您可以通过块运算对应用程序进行任务化。
例如，您可以将 A = B + C 拆分为 4 个独立的块操作（使用 Eigen 接口...）

• A(0, 0, n/2, n/ 2) = B(0, 0, n/2, n/2) + C(0, 0, n/2, n/2)
• A(0, n/2, n/2, n/2) = B (0, n/2, n/2, n/2) + C(0, n/2, n/2, n/2)
• A(n/2, 0, n/2, n/2) = B(n/2, 0, n/2, n/2) + C(n/2, 0, n/2, n/2)
• A(n/2, n/2, n/2, n/2) = B(n/2, n/2, n/2, n/2) + C(n/2, n/2, n/2, n/2)

这里的块大小是 n/2 并定义您的 任务粒度

3) 同步性 -
为了确保正确的执行顺序，您使用了#pragma omp taskwait - 这是一个等待先前生成的任务完成的显式屏障。
从 OpenMP 4.0 开始，任务可以具有依赖项，以保证更精细的执行顺序。

混合起来 -
我用你的问题的 3 个版本做了一个微基准 - 源

• 顺序 - 计算是在 1 个核心
• 任务等待 上完成的- 您的版本
• 块 - 使用 Eigen 块操作和 OpenMP 依赖项。
  我将计算分为 2 个操作，并用 m 个块对每个操作进行任务化。
  • 添加 - M := A + C + C^T + R + R^T + D1 + D1^T + D2 + D2^T
  • mult - y := Mx
    在此图中，是 m=2 的依赖任务图 - add(0, 0) 任务在左上角的块上工作，add( 1, 0) 任务在右上角的块上工作，等等... - mult 任务取决于在同一行上工作的 add 任务块 - norm 任务是正确性检查。

我在 16 个内核上运行它，使用 n=4,096 和 m=16（每行操作的块数）。这是我的结果

连续版本花费了 1.28707 秒。
taskwait 版本花费了 0.177616 秒。（成功）
任务版本耗时 0.128707 秒。（成功）

我再次运行它，但这次是在 64 个核心上，并且使用 m=64

连续版本花费了 1.31316 秒。
taskwait 版本花费了 0.170817 秒。（成功）
任务版本花费了 0.0785489 秒。（成功）

“块版本”随内核扩展，但“taskwait”版本则不然。

这是第一次执行的甘特图 (m=16)。
大蓝色任务对应于顺序版本执行，红色任务对应于任务等待版本执行。紫色和粉色任务分别对应块版本的 add 和 mult 任务。

如您所见，taskwait 版本仅使用 16 个核心中的 9 个，而 block 版本可以使用每个核心。

块版本的缩放，并使用箭头启用依赖关系渲染

这些数字是使用 多处理器计算 (MPC) - 实现 OpenMP 运行时和跟踪工具。