使用 OpenMP (C) 的矩阵乘法 - 折叠所有循环

Question

所以我正在学习 C 语言中的 OpenMP 基础知识和工作共享结构，尤其是 for 循环。 所有教程中使用的最著名的例子之一是矩阵乘法，但它们都只是并行化外循环或两个外循环。 我想知道为什么我们不像我在这里所做的那样并行化和折叠所有 3 个循环（使用原子）：

    for(int i=0;i<100;i++){
        //Initialize the arrays
        for(int j=0;j<100;j++){
            A[i][j] = i;
            B[i][j] = j;
            C[i][j] = 0;       
        }       
    }

    //Starting the matrix multiplication
    #pragma omp parallel num_threads(4)
    {
        #pragma omp for collapse(3)
        for(int i=0;i<100;i++){
            for(int j=0;j<100;j++){
                for(int k=0;k<100;k++){
                        #pragma omp atomic
                        C[i][j] = C[i][j]+ (A[i][k]*B[k][j]);
                }       
            }       
        }   
    }

你能告诉我我在这里遗漏了什么，或者为什么这不是一个劣质/优越的解决方案？

Answer 1

与非原子架构相比，原子操作在大多数架构上的成本非常高（请参阅此处了解原因或此处了解更详细的分析）。 当许多线程同时访问同一个共享内存区域时尤其如此。 简单地说，一个原因是由于隐式同步和来自缓存一致性协议的通信，执行原子操作的线程无法完全并行运行而无需在大多数硬件上等待其他线程。 另一个导致速度变慢的原因是原子操作的高延迟（同样是由于缓存层次结构）。

如果您想编写可扩展的代码，您需要最小化同步和通信（包括原子操作）。 因此，使用collapse(2)比使用collapse(3)好得多。 但这并不是您的代码的唯一问题。 实际上，为了提高效率，您必须连续执行内存访问并尽可能多地将数据保存在缓存中。

例如，由于更连续的内存访问（在我的 PC 上大约为 8 倍），交换迭代 i 的循环和迭代 k 的循环（不适用于collapse(2) ）在大多数系统上要快几倍：

    for(int i=0;i<100;i++){
        //Initialize the arrays
        for(int j=0;j<100;j++){
            A[i][j] = i;
            B[i][j] = j;
            C[i][j] = 0;       
        }       
    }

    //Starting the matrix multiplication
    #pragma omp parallel num_threads(4)
    {
        #pragma omp for
        for(int i=0;i<100;i++){
            for(int k=0;k<100;k++){
                for(int j=0;j<100;j++){
                    C[i][j] = C[i][j] + (A[i][k]*B[k][j]);
                }
            }
        }
    }

编写快速矩阵乘法代码并不容易。 如果您的目标是在生产代码中使用BLAS库，例如OpenBLAS 、 ATLAS 、 Eigen或Intel MKL，而不是编写您自己的代码。 事实上，这样的库经过了非常优化，并且通常可以在许多内核上很好地扩展。 如果您的目标是了解如何编写高效的矩阵乘法代码，那么阅读本教程可能是一个很好的起点。

Answer 2

折叠循环要求您知道自己在做什么，因为它可能导致迭代空间非常不利于缓存的拆分或引入数据依赖性，具体取决于循环计数的乘积与线程数的关系。

想象一下以下构造的示例，这实际上并不少见（循环计数很小只是为了说明这一点）：

for (int i = 0; i < 7; i++)
  for (int j = 0; j < 3; j++)
     a[i] += b[i][j];

如果您并行化外循环，三个线程将获得两次迭代，而一个线程仅获得一次，但所有线程都执行内循环的所有迭代：

---0-- ---1-- ---2-- -3- (thread number)
000111 222333 444555 666 (values of i)
012012 012012 012012 012 (values of j)

每个a[i]仅由一个线程处理。 智能编译器可以使用寄存器优化来实现内部循环，首先在寄存器中累加值，然后只在最后分配给a[i] ，它会运行得非常快。

如果你折叠这两个循环，你最终会处于非常不同的情况。 由于现在总共有 7x3 = 21 次迭代，默认拆分将是（取决于编译器和 OpenMP 运行时，但大多数都这样做）每个线程 5 次迭代，其中 1 次获得 6 次迭代：

--0-- --1-- --2-- ---3-- (thread number)
00011 12223 33444 555666 (values of i)
01201 20120 12012 012012 (values of j)

如您所见，现在a[1]由线程 0 和线程 1 处理。类似地， a[3]由线程 1 和线程 2 处理。就这样 - 您刚刚引入了一个数据依赖项在前一种情况下不存在，所以现在您必须使用atomic来防止数据竞争。 您为同步付出的代价远高于或多或少进行一次迭代！ 在您的情况下，如果您只折叠两个外部循环，则根本不需要使用atomic （尽管在您的特定情况下，4 除以 100，即使将所有循环折叠在一起，您也不需要atomic构造，但在一般情况下您需要它）。

另一个问题是，在折叠循环后，只有一个循环索引，并且必须使用除法和模运算从这个新索引重建i和j索引。 对于像您这样的简单循环体，重建索引的开销可能太高了。

Answer 3

很少有充分的理由不使用库进行矩阵-矩阵乘法，因此正如已经建议的那样，请调用 BLAS 而不是自己编写。 尽管如此，您提出的问题并非特定于矩阵-矩阵乘法，因此无论如何都值得回答。

这里有一些可以改进的地方：

1. 使用连续内存。
2. 如果 K 是最内层的循环，则您正在做点积，这更难矢量化。 例如，循环顺序 IKJ 将更好地矢量化。
3. 如果要使用 OpenMP 并行化点积，请使用归约而不是许多原子。

我在下面分别说明了这些技术中的每一种。

连续内存

int n = 100;
double * C = malloc(n*n*sizeof(double));
for(int i=0;i<n;i++){
  for(int j=0;j<n;j++){
    C[i*n+j] = 0.0;
  }       
}

IKJ 循环排序

for(int i=0;i<100;i++){
  for(int k=0;k<100;k++){
    for(int j=0;j<100;j++){
      C[i][j] = C[i][j]+ (A[i][k]*B[k][j]);
    }
  }
}

平行点积

double x = 0;
#pragma omp parallel for reduction(+:x)
for(int k=0;k<100;k++){
  x += (A[i][k]*B[k][j]);
}
C[i][j] += x;

外部资源

如何编写快速数字代码：一个小简介更详细地介绍了这些主题。

BLISlab是专门针对矩阵-矩阵乘法的优秀教程，它将教您专家如何编写 BLAS 库调用。