Question

我有一个并行代码，基本上可以简化为：

#include <algorithm>
#include <vector>

struct TKeyObjPtr;

class TObj
{
public:
  virtual void Calculate(TKeyObjPtr const &) = 0;
};

struct TKeyObjPtr
{
  int Key;
  TObj *ObjPtr;
};

void Calculate(std::vector<TKeyObjPtr> const &KeyObjPtrVec)
{
  #pragma omp parallel for
  for (auto It1= KeyObjPtrVec.begin(); It1!=KeyObjPtrVec.end(); ++It1)
    for (auto It2= It1+1; It2!=KeyObjPtrVec.end() && It2->Key==It1->Key; ++It2)
      It1->ObjPtr->Calculate(*It2);
}

我想通过使用c++17并行算法来使代码现代化。不幸的是，我在重写这样一个简单的代码时遇到了麻烦。

一个选项将使用boost::counting_iterator：

void Calculate(std::vector<TKeyObjPtr> const &KeyObjPtrVec)
{
  std::for_each(std::execution::par_unseq,
    boost::counting_iterator<std::size_t>(0u),
    boost::counting_iterator<std::size_t>(KeyObjPtrVec.size()),
    [&KeyObjPtrVec](auto i)
      {
        for (auto j= i+1; j<KeyObjPtrVec.size() && KeyObjPtrVec[j].Key==KeyObjPtrVec[i].Key; ++j)
          KeyObjPtrVec[i].ObjPtr->Calculate(KeyObjPtrVec[j]);
      });
}

这有效，但冗长得多，更糟糕的是，我认为它不符合标准，因为boost::counting_iterator是隐藏式迭代器，因此不是碰到Cpp17ForwardIterator requirements。

是否可以像OpenMP一样简洁地编写上述代码，同时满足标准对并行算法的约束？

Answer 1

迭代器可以按值分配。分配的迭代器是副本，当原始分配来源增加时，该迭代器不会前进。因此，您可以简单地

template<typename I>
void calculate(const I It1, const I It2) {
  // This statement can also run at any time later. The iterators will point
  // how they were when the calculate(...) was called.
  It1->ObjPtr->Calculate(*It2); 
}

void Calculate(std::vector<TKeyObjPtr> const &KeyObjPtrVec) {
  for (auto It1 = KeyObjPtrVec.begin(); It1 != KeyObjPtrVec.end(); ++It1)
    for (auto It2 = It1 + 1; It2 != KeyObjPtrVec.end() && 
      It2->Key == It1->Key; ++It2)
        calculate(It1, It2);
}

不幸的是，C ++ 17并不是这样的专用并行编程平台。您需要安排一个有意义的大小和任务队列的线程池，从那里他们可以选择任务。任务记录可以只保存分配给该结构字段的这两个迭代器。您还需要一种机制来知道所有并行处理何时完成，以便您可以继续。

使用c ++ 17算法并行化简单循环

1 个答案: