OpenMP и общие структуры и указатели

Question

У меня есть функция, которая передается две структуры по ссылке.Эти структуры состоят из динамически распределенных массивов.Теперь, когда я пытаюсь реализовать OpenMP, я получаю замедление, а не ускорение.Я думаю, что это может быть связано с возможными проблемами обмена.Вот часть кода для прочтения (C):

void    leap(MHD *mhd,GRID *grid,short int gchk)
{
  /*-- V A R I A B L E S --*/
  // Indexes
  int i,j,k,tid;
  double rhoinv[grid->nx][grid->ny][grid->nz];
  double rhoiinv[grid->nx][grid->ny][grid->nz];
  double rhoeinv[grid->nx][grid->ny][grid->nz];
  double rhoninv[grid->nx][grid->ny][grid->nz]; // Rho Inversion
  #pragma omp parallel shared(mhd->rho,mhd->rhoi,mhd->rhoe,mhd->rhon,grid,rhoinv,rhoiinv,rhoeinv,rhoninv) \
                       private(i,j,k,tid,stime)
  {
    tid=omp_get_thread_num();
    printf("-----  Thread %d Checking in!\n",tid);
    #pragma omp barrier
    if (tid == 0)
    {
      stime=clock();
      printf("-----1) Calculating leap helpers");
    }
    #pragma omp for
    for(i=0;i<grid->nx;i++)
    {
      for(j=0;j<grid->ny;j++)
      {
        for(k=0;k<grid->nz;k++)
        {
          //      rho's
          rhoinv[i][j][k]=1./mhd->rho[i][j][k];
          rhoiinv[i][j][k]=1./mhd->rhoi[i][j][k];
          rhoeinv[i][j][k]=1./mhd->rhoe[i][j][k];
          rhoninv[i][j][k]=1./mhd->rhon[i][j][k];
        }
      }
    }
    if (tid == 0)
    {
      printf("........%04.2f [s] -----\n",(clock()-stime)/CLOCKS_PER_SEC);
      stime=clock();
    }
    #pragma omp barrier
  }/*-- End Parallel Region --*/
}

Теперь я пробовал default (shared) и shared (mhd), но ни один из них не показывает никаких признаков улучшения.Может ли быть так, что, так как массивы распределены

mhd->rho=(double ***)newarray(nx,ny,nz,sizeof(double));

Что, объявив структуру или указатель на элемент структуры, я фактически не делю память только указателями на нее?Oh и nx = 389 ny = 7 и nz = 739 в этом примере.Время выполнения для этого раздела в последовательном режиме составляет 0,23 [с] и 0,79 [с] для 8 потоков.

Answer 1

Моя проблема сводилась к настоящей простой ошибке .... clock ().Хотя я защищал свой алгоритм синхронизации, рассчитывая время только для определенного потока, я забыл одну важную вещь о clock () ... он возвращает время настенных часов, которое является общим временем процессора (суммирование по активным потокам).Мне нужно было позвонить omp_get_wtime ().Делая это, я внезапно вижу ускорение для многих разделов моего кода.Для записи я изменил свой код, включив в него

#ifdef _OPENMP
    #include <omp.h>
    #define TIMESCALE 1
#else
    #define omp_get_thread_num() 0
    #define omp_get_num_procs() 0
    #define omp_get_num_threads() 1
    #define omp_set_num_threads(bob) 0
    #define omp_get_wtime() clock()
    #define TIMESCALE CLOCKS_PER_SEC
#endif

И мой алгоритм синхронизации теперь

    #pragma omp barrier
    if (tid == 0)
    {
        stime=omp_get_wtime();
        printf("-----1) Calculating leap helpers");
    }
    #pragma omp for
    for(i=0;i<grid->nx;i++)
    {
        for(j=0;j<grid->ny;j++)
        {
            for(k=0;k<grid->nz;k++)
            {
                //      rho's
                rhoinv[i][j][k]=1./mhd->rho[i][j][k];
                rhoiinv[i][j][k]=1./mhd->rhoi[i][j][k];
                rhoeinv[i][j][k]=1./mhd->rhoe[i][j][k];
                rhoninv[i][j][k]=1./mhd->rhon[i][j][k];
                //  1./(gamma-1.)
                gaminv[i][j][k]=1./(mhd->gamma[i][j][k]-1.);
                gamiinv[i][j][k]=1./(mhd->gammai[i][j][k]-1.);
                gameinv[i][j][k]=1./(mhd->gammae[i][j][k]-1.);
                gamninv[i][j][k]=1./(mhd->gamman[i][j][k]-1.);
            }
        }
    }
    if (tid == 0)
    {
        printf("........%04.2f [s] -----\n",(omp_get_wtime()-stime)/TIMESCALE);
        stime=omp_get_wtime();
        printf("-----2) Calculating leap helpers");
    }

Answer 2

Ну, вы также используете двойные и деления. Можете ли вы сделать деление на умножение?

Единица с плавающей запятой распределяется между ядрами, и деления не имеют определенного количества циклов до завершения (в отличие от умножения). Таким образом, вы в конечном итоге сериализации для доступа к блоку fp.

Я уверен, что если вы используете целочисленные типы или умножение, вы увидите ускорение.

Answer 3

Важным моментом здесь может быть ваша верхняя граница ваших петель. Поскольку вы используете grid->nz и т.д., openMP не может знать, будут ли они меняться или нет для каждой итерации. Загрузите эти значения в локальные переменные и используйте их для условия цикла.