将迭代器的地址传递给 STL::for_each 中的函数

Question

我有一个最终想要并行化的函数。

目前，我在 for 循环中调用事物。

double temp = 0;
int y = 123;  // is a value set by other code
for(vector<double>::iterator i=data.begin(); i != data.end(); i++){
    temp += doStuff(i, y);
}

doStuff 需要知道它在列表中的位置有多远。所以我使用 i - data.begin() 来计算。

接下来，我想改用 stl::for_each 函数。我的挑战是我需要传递迭代器的地址和 y 的值。我见过使用bind2nd将参数传递给函数的示例，但是如何将迭代器的地址作为第一个参数传递？

boost FOREACH 函数看起来也有可能，但我不知道它是否会像 STL 版本那样神奇地自动并行化。

想法、想法、建议？

Answer 1

如果您想要真正的并行化，请

• 在 (-O3) 和 SIMD 上使用带有树向量化优化的 GCC（例如 -march=native 以获得 SSE 支持）。如果操作 (dostuff) 并不简单，您可以选择提前执行此操作（std::transform 或 std::for_each）并累积下一个 (< code>std::accumulate），因为累积将像 SSE 指令上的其他操作一样得到优化！

  void apply_function(double& value)
  {
       值*= 3； // 只是一个示例...
  }
  
  // ...
  
  std::vector数据（1000）；
  std::for_each(data.begin(), data.end(), &apply_function);
  双和 = std::accumulate(data.begin(), data.end(), 0);
  

请注意，虽然这实际上不会在多个线程上运行，但性能的提升将是巨大的，因为 SSE4 指令可以在单个核心上*并行处理许多浮动操作。

如果您想要真正的并行性，请使用以下之一

GNU 并行模式

编译与g++ -fopenmp -D_GLIBCXX_PARALLEL：

__gnu_parallel::accumulate(data.begin(), data.end(), 0.0);

OpenMP 直接

使用 g++ -fopenmp 进行编译

double sum = 0.0;
#pragma omp parallel for reduction (+:sum)
for (size_t i=0; i<data.end(); i++)
{
    sum += do_stuff(i, data[i]);
}

这将导致循环并行化为与系统上（逻辑）CPU 核心数量一样多的线程（OMP 团队）实际机器，结果“神奇地”组合并同步。

最后备注：

您可以使用有状态函数对象来模拟 for_each 的二进制函数。这并不是完全推荐的做法。它也会显得非常低效（在没有优化的情况下编译时，确实如此）。这是因为函数对象在 STL 中是按值传递的。然而，期望编译器完全优化潜在的开销是合理的，特别是对于如下的简单情况：

struct myfunctor
{
    size_t index; 
    myfunctor() : index(0) {}

    double operator()(const double& v) const
    {
        return v * 3; // again, just a sample
    }
};

// ...
std::for_each(data.begin(), data.end(), myfunctor());

Answer 2

temp += doStuff( i, y ); 无法自动并行化。运算符+= 不能很好地处理并发性。

此外，stl 算法不会并行化任何东西。 Visual Studio 和 GCC 都有类似于 std::for_each 的并行算法。如果这就是你所追求的，你就必须使用它们。

OpenMP 可以自动并行化 for 循环，但您必须使用编译指示告诉编译器何时以及如何并行化（它无法为您弄清楚）。

您可能混淆了并行化与循环展开，这是 std::for_each 实现中的常见优化。

Answer 3

如果您可以更改doStuff，以便它从当前元素所在的索引中单独获取当前元素的值，那么这相当简单。请注意：

struct context {
    std::size_type _index;
    int            _y;
    double         _result;
};

context do_stuff_wrapper(context current, double value)
{
    current._result += doStuff(current._index, value, current._y);
    current._index++;
}

context c = { 0, 123, 0.0 };
context result = std::accumulate(data.begin(), data.end(), c, do_stuff_wrapper);

但是请注意，标准库算法无法“自动并行化”，因为它们调用的函数可能会产生副作用（编译器知道是否会产生副作用，但库函数不知道）。如果您想要并行循环，则必须使用专用并行算法库，例如 PPL 或 TBB。