在 C++ 中并行查找向量的第一个

Question

我有一个很大的向量。一些向量成员并行匹配某个条件。我想找到与条件匹配的第一个元素。

我的问题与这个问题 (tbb: parallel find first element) 非常相似，但我没有 tbb。检查条件非常繁琐（所以我不能按顺序为所有这些检查）。这就是为什么我想并行运行它。不得不提的是，我想找到第一个元素（所以元素的索引位置对我来说很重要）。

例如，如果我有 4 个线程。

ThreadNr   Index      condition
1            0         Not Meet
2            1         Not Meet
3            2         Not Meet
4            3         Not Meet

ThreadNr   Index      condition
1            4         Not Meet
2            5          Meet
3            6         Not Meet
4            7          Meet

函数必须重新调整索引号 5。 线程必须分布并处理顺序迭代块（块大小可以大于 1。例如线程 1 处理前 4 个元素，线程 2 处理后 4 个元素，依此类推）。

对于上面的例子，如果线程 4（索引 7）在线程 2（索引 5）之前找到成员，它必须等待所有线程完成工作。正如我之前所说，最低的索引号是目标。

如果您有更好的算法，请纠正我。

注意：我可以使用外部库，例如 boost 1.62、OpenMP 2.0

Answer 1

由于 OpenMP 2.0 没有取消构造，您必须自己实现一个，例如，通过使用共享变量。这也意味着您不能使用 for 工作共享结构，因为不允许中断并行循环（这就是 OpenMP 4.0 引入取消结构的原因）。如果您在每个元素的评估之间实施取消检查，则可能会发生两个或多个线程找到匹配标准的元素。因此，您应该对索引执行最小缩减：

int found = 0;
int first_index = INVALID_VALUE;
int iteration = 0;

#pragma omp parallel
{
   int my_index = INVALID_VALUE;
   int i;

   do
   {
      // Later versions of OpenMP allow for "atomic capture"
      // but OpenMP 2.0 requires a critical directive instead
      #pragma omp critical(iteration)
      {
         i = iteration++;
      }

      if (i < N && check(i))
      {
         found = 1;
         my_index = i;
      }
   } while (!found && i < N);

   #pragma omp critical(reduction)
   if (my_index != INVALID_VALUE)
   {
      if (first_index == INVALID_VALUE || my_index < first_index)
         first_index = my_index;
   }

   // Only needed if more code follows before the end of the region
   #pragma omp barrier

   ...
}

此代码假定检查第 i 个元素 (check(i)) 的条件不会改变元素的状态，因此，可能发生的最坏情况是找到匹配元素的线程可能等待所有其他线程完成检查它们当前正在处理的元素，并且等待时间将是所有处理时间的最大值。

do-loop 中使用的critical 结构很昂贵。如果check() 不需要那么多时间，那么您可以考虑使用块而不是迭代：

do
{
   #pragma omp critical(chunk)
   {
       my_chunk = chunk++;
   }

   if (my_chunk >= N_chunks)
      break;

   for (i = my_chunk * chunk_size; !found && i < (my_chunk+1)*chunk_size; i++)
   {
      if (check(i))
      {
         found = 1;
         my_index = i;
         break;
      }
   }
} while (!found && my_chunk < N_chunks);

---

当元素的数量不是那么大并且检查每个元素的成本很高时，另一种效果相当不错的解决方案：

#pragma omp parallel
{
   #pragma omp for schedule(dynamic,x)
   for (i = 0; i < N; i++)
   {
      if (!found && check(i))
      {
         my_index = i;
         found = 1;
      }
   }

   // Min reduction from the solution above
   ...
}

一旦found 变为真，其余的循环迭代将运行“空”主体，因为&& 的快捷方式属性。

Answer 2

使用 OpenMP，您可以尝试使用 #pragma omp for schedule(dynamic) 构建一个 for 循环。每个线程将按照与向量相同的顺序执行一次迭代。 如果你想通过线程检查4个元素，试试#pragma omp for schedule(dynamic, 4)