Question

我正在尝试对更大的矩阵（1000x1000到5000x5000双精度）进行乘法运算。我必须使用OpenMP来并行化乘法。并行的for循环由p个线程处理，并且我猜是基于打印出omp_get_thread_num（）正确地调度了它们。我正在4核CPU上运行，并已确认最大线程数为4。如果这有任何区别，则CPU是虚拟的。问题在于，当我更改线程的nb时，运行时间不会减少。

lscpu results

我已检查libgomp已安装ldconfig -p | grep -i "gomp"库。
我尝试将并行循环的位置更改为嵌套循环之一。
我尝试更改调度和块大小。

#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#include <time.h>

double** createMatrix(int N)
{
  double** rndMatrix;
  srand48((long int)time(NULL));
  rndMatrix = malloc(sizeof(double*)*N);
  int n,m;

  for(n=0; n<N; n++){
      rndMatrix[n] = malloc(sizeof(double*)*N);
      for (m=0;m<N;m++){
          rndMatrix[n][m] = drand48();
      }
  }
  return rndMatrix;
}

void problem1(double** a, double** b, int N, int p){
    int i,k,j;
  int g;
  double** c;
  c = malloc(sizeof(double*)*N);

  for(g=0; g<N; ++g)
      c[g] = malloc(sizeof(double*)*N);

  //Timer start
  clock_t tStart = clock();
  //time_t tStart, tEnd;
  //tStart =time(NULL);

  //Parallelised part
#pragma omp parallel shared(a,b,c,N) private(i,k,j) num_threads(p)
  {
#pragma omp for schedule(static) nowait
      for(i=0; i<N; ++i){
          for(j=0; j<N; ++j){
                  double sum = 0;
                  for(k=0; k<N; ++k){
                      sum += a[i][k] * b[k][j];
                  }
                  c[i][j]=sum;
          }
      }
  }

  //Timer end
  printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
  //tEnd = time(NULL);
  //printf("Time taken: %ds\n",  tEnd - tStart);
}


int main(void)
{
  int p=0;
  int N=0;
  //User input:

  printf("Enter matrix dimension:\n");
  scanf("%d", &N);

  printf("Please enter nb of threads:\n");
  scanf("%d", &p);

  double **a;
  double **b;

  a = createMatrix(N);
  sleep(2);
  b = createMatrix(N);

  problem1(a,b,N,p);

  return 0;
}

Answer 1

您使用了错误的算法以ijk顺序乘以矩阵。

for(i=0; i<N; ++i){
      for(j=0; j<N; ++j){
           double sum = 0;
           for(k=0; k<N; ++k){
                sum += a[i][k] * b[k][j];
           }
           c[i][j]=sum;
       }
}

只要k在内部循环中递增，b就会逐列遍历并生成高速缓存未命中。结果是每次迭代一次缓存未命中。这将在很大程度上占用计算时间，并且算法受内存限制。

您可以增加核心数量，但不会增加您的内存带宽（高速缓存大小略有增加可能会稍微缩短计算时间）。

仅当您遇到核心受限问题时，Open-MP才有用，而不是用于内存限制的计算。

要查看额外内核的效果，必须使用其他算法。例如，通过将迭代顺序更改为ikj。

    for(i=0; i<N; ++i){
      for(k=0; k<N; ++k){
        double r = a[i][k];
        for(j=0; j<N; ++j){
          c[i][j] += r * b[k][j];
        }
      }
    }

当内部索引（j）递增时，将按行遍历c [i] [j]和b [i] [j]。而不是每个迭代一次未命中，而是每八次迭代只有两个未命中，并且内存带宽将不再是限制因素。您的计算时间将大大减少，并将随着所使用内核的数量而扩展。

耗时（N = 2000，p = 1）：4.62s
  耗时（N = 2000，p = 2）：3.03s
  花费时间（N = 2000，p = 4）：2.34s

ikj不是唯一的方法。您还可以使用分块矩阵乘法，其中乘法由ijk完成，但适用于适合LI缓存的小型矩阵。

#define BL 40
  for (int jj=0;jj<N;jj+=BL)
    for (int kk=0;kk<N;kk+=BL)
      for (i=0;i<N;i++)
        {
          for (j=jj;j<min(jj+BL-1,N);j++)
        {
          double sum=0.0;
          for (k=kk;k<min(kk+BL-1,N);k++)
            sum += a[i][k]*b[k][j];
          c[i][j]=sum;
        }
        }

  }

该算法稍长一些，但是由于避免了高速缓存遗漏，因此也是核心限制，可以通过并行化进行改进。

耗时（N = 2000，p = 1）：7.22s
  花费时间（N = 2000，p = 2）：3.78s
  花费时间（N = 2000，p = 4）：3.08s

但是，如果在内存受限的问题上使用open-MP，您将一无所获。

即使正在运行多个线程，OpenMP也不会减少运行时间。怎么会这样

1 个答案: