优雅地并行初始化 openmp 线程 for 循环

Question

我有一个 for 循环，它使用（有点复杂）计数器对象 sp_ct 来初始化数组。串行代码看起来像

sp_ct.depos(0);
for(int p=0;p<size; p++, sp_ct.increment() ) {
  in[p]=sp_ct.parable_at_basis();
}

My counter 支持并行化，因为它可以在 p 递增后初始化为状态，从而产生以下工作代码片段：

  int firstloop=-1;
#pragma omp parallel for \
       default(none) shared(size,in) firstprivate(sp_ct,firstloop)
  for(int p=0;p<size;p++) {
    if( firstloop == -1 ) {
      sp_ct.depos(p); firstloop=0;
    } else { 
      sp_ct.increment();
    }
    in[p]=sp_ct.parable_at_basis();
  } // end omp paralell for

我不喜欢这样，因为混乱掩盖了真正发生的事情上，并且因为它在循环内有一个不必要的分支（是的，我知道这可能不会对运行时间产生可测量的影响，因为它是所以可预测的......）。

我更喜欢写这样的东西

#pragma omp parallel for default(none) shared(size,in) firstprivate(sp_ct,firstloop)
  for(int p=0;p<size;p++) {
#prgma omp initialize // or something
    {  sp_ct.depos(p); }
    in[p]=sp_ct.parable_at_basis();
    sp_ct.increment();
    }
  } // end omp paralell for

这可能吗？

Answer 1

如果我概括您的问题，问题是“如何为并行部分的每个线程执行一些初始化代码？”，对吗？您可以使用firstprivate子句的属性：“给定变量的初始化或构造就像在线程执行构造之前为每个线程完成一次一样”。

struct thread_initializer
{
  explicit thread_initializer(
    int size /*initialization params*/) : size_(size) {}

  //Copy constructor that does the init
  thread_initializer(thread_initializer& _it) : size_(_it.size)
  {
    //Here goes once per thread initialization
    for(int p=0;p<size;p++)
      sp_ct.depos(p);
  }

  int size_;
  scp_type sp_ct;
};

然后可以编写循环：

thread_initializer init(size);
#pragma omp parallel for \
       default(none) shared(size,in) firstprivate(init)
for(int p=0;p<size;p++) {
  init.sp_ct.increment();
}
in[p]=init.sp_ct.parable_at_basis();

不好的事情是您必须编写这个额外的初始化程序，并且一些代码被移离其实际执行点。好处是您可以重用它以及更清晰的循环语法。

Answer 2

据我所知，您可以通过手动定义块来做到这一点。这看起来有点像我试图在 OpenMP 中进行归纳 OpenMP 归纳：获取 OpenMP 中并行化 for 循环的范围值

所以你可能想要这样的东西：

#pragma omp parallel
{
    const int nthreads = omp_get_num_threads();
    const int ithread = omp_get_thread_num();
    const int start = ithread*size/nthreads;
    const int finish = (ithread+1)*size/nthreads;       
    Counter_class_name sp_ct;

    sp_ct.depos(start);   
    for(int p=start; p<finish; p++, sp_ct.increment()) {
        in[p]=sp_ct.parable_at_basis();
    }
}

注意，除了一些声明和更改该代码的范围值几乎与序列代码相同。

此外，您不必声明任何共享或私有的内容。并行块内声明的所有内容都是私有的，而外部声明的所有内容都是共享的。你也不需要firstprivate。这使得代码更干净、更清晰（恕我直言）。

Answer 3

我明白你想做什么，但我认为这是不可能的。我只是要编写一些代码，我相信这些代码可以实现相同的目标，并且有些干净，如果您喜欢它，那就太棒了！

sp_ct.depos(0);
in[0]=sp_ct.parable_at_basis();
#pragma omp parallel for \
       default(none) shared(size,in) firstprivate(sp_ct,firstloop)
  for(int p = 1; p < size; p++) {
    sp_ct.increment();
    in[p]=sp_ct.parable_at_basis();
  } // end omp paralell for

Answer 4

Riko，实现 sp_ct.depos()，这样它将仅根据需要频繁调用 .increment()，以将计数器带至传递的参数。然后您可以使用以下代码：

sp_ct.depos(0);
#pragma omp parallel for \
       default(none) shared(size,in) firstprivate(sp_ct)
for(int p=0;p<size;p++) {
  sp_ct.depos(p);
  in[p]=sp_ct.parable_at_basis();
} // end omp paralell for

此解决方案还有一个额外的好处：仅当每个线程仅接收 0 - size 中的一个块时，您的实现才有效。指定 schedule(static) 时会出现这种情况，而忽略块大小 (OpenMP 4.0 规范，第 2.7.1 章，第 57 页）。但由于您没有指定时间表，所以使用的时间表将取决于实现（OpenMP 4.0 规范，第 2.3.2 章）。如果实现选择使用动态或引导，线程将接收多个块，它们之间有间隙。因此，一个线程可以接收块 0-20，然后接收块 70-90，这将使 p 和 sp_ct 输出第二个块上的同步。上述解决方案与所有时间表兼容。