c++ 如何优雅地使用 c++17 并行执行和计算整数的 for 循环？

Question

我可以的

std::vector<int> a;
a.reserve(1000);
for(int i=0; i<1000; i++)
    a.push_back(i);
std::for_each(std::execution::par_unseq, std::begin(a), std::end(a), [&](int i) {
  ... do something based on i ...
});

但是有没有更优雅的方法来创建不需要我首先用升序整数填充向量的 for(int i=0; i

Answer 1

您可以使用std::generate 创建矢量{0, 1, ..., 999}

std::vector<int> v(1000);
std::generate(v.begin(), v.end(), [n = 0] () mutable { return n++; });

有一个接受ExecutionPolicy 的重载，因此您可以将上面的内容修改为

std::vector<int> v(1000);
std::generate(std::execution::par, v.begin(), v.end(), [n = 0] () mutable { return n++; });

Answer 2

虽然我不能建议避免填充向量的方法，但我可以推荐使用 std::iota() 函数作为（也许）最有效/最优雅的方式来填充递增整数：

std::vector<int> a(1000);
std::iota(std::begin(a), std::end(a), 0);
std::for_each(std::execution::par_unseq, std::begin(a), std::end(a), [&](int i) {
  // ... do something based on i ...
});

std::iota 的复杂度正好是last - first 增量 和赋值，而std::generate 函数的复杂度是last - first g() 的调用和任务。即使一个体面的编译器要为 g 内联一个简单的增量 lambda 函数，iota 的语法也要简单得多，恕我直言。

Answer 3

VisualC++ 提供丰富的并行编程环境，并发运行时ConCRT。
您可以使用 OpenMP，它是开放标准，但在 ConCRT 中也可用。如wikipedia 所述，它是embarrassingly parallel，下面的代码应该创建 1000 个线程：

#include <omp.h>
...
#pragma omp parallel for
for(int s = 0; s < 1000; s++)
{
    for(int i = 0; i < s; i++)
        ... do something parallel based on i ...
}

如果未指定编译器选项 /openmp，则忽略 #pragma omp 指令。 其实我不明白你的向量的作用，所以我省略了它。另外，我不明白用任何 for_each 替换标准 for 并使用保存的索引的原因，因为 for 循环可以做到这一点挺好的。
或者，您可以使用 Microsoft 特定库 PPL。以下代码还创建 1000 个线程，生成从 0 到 999 的索引，并作为 s 变量传递给并行例程：

#include <ppl.h>
...
using namespace concurrency;
parallel_for(0, 1000, [&](int s)
{
   for(int i = 0; i < s; i++)
      ... do something parallel based on i ...
});

对于繁重的并行计算，并发运行时还可以使用 AMP。 AMP 在 GPU 而不是 CPU 上执行并行例程。

Answer 4

这里有两种方法可以做到这一点预先填充一个向量只是为了存储一个整数序列。

1. 您可以使用Boost.counting_range（或根据您的喜好直接使用Boost.counting_iterator）来实现...虽然通过阅读文档了解如何操作，但祝您好运。

    auto range = boost::counting_range<int>(0,1000);
    std::for_each(std::execution::par_unseq,
                  range.begin(),
                  range.end(),
                  [&](int i) {
                      //  ... do something based on i ...
                  });
   

2. 如果你不想包含Boost，我们可以直接写一个简单的版本。

   没有为将iota 和iterator 混在一起而不是想出一个像样的名字而道歉，下面将让您编写类似于上面的 Boost 版本的内容：

    std::for_each(std::execution::par_unseq,
                  ioterable<int>(0),
                  ioterable<int>(1000),
                  [&](int i) {
                    //  ... do something based on i ...
                  }
    );
   

   您可以看到使用 Boost 节省了多少样板代码：

    template <typename NumericType>
    struct ioterable
    {
        using iterator_category = std::input_iterator_tag;
        using value_type = NumericType;
        using difference_type = NumericType;
        using pointer = std::add_pointer_t<NumericType>;
        using reference = NumericType;
   
        explicit ioterable(NumericType n) : val_(n) {}
   
        ioterable() = default;
        ioterable(ioterable&&) = default;
        ioterable(ioterable const&) = default;
        ioterable& operator=(ioterable&&) = default;
        ioterable& operator=(ioterable const&) = default;
   
        ioterable& operator++() { ++val_; return *this; }
        ioterable operator++(int) { ioterable tmp(*this); ++val_; return tmp; }
        bool operator==(ioterable const& other) const { return val_ == other.val_; }
        bool operator!=(ioterable const& other) const { return val_ != other.val_; }
   
        value_type operator*() const { return val_; }
   
    private:
        NumericType val_{ std::numeric_limits<NumericType>::max() };
    };
   

3. 为了后代，如果您将来可以使用 C++20，std::ranges::iota_view 将在可用的情况下更可取。