hpx::futures<double>向量的并行约简(例如和)

Question

我们目前正试图实现一个红色-黑色高斯-塞德尔数值模拟求解器。

为此，我们将模拟区域划分为大小相等的子网格。我们能够异步地为每个子网格上的压力方程执行红黑循环，具有正确的依赖关系和一个hpx::dataflow对象。

但是现在我们有了以下问题:在每一个n个循环之后，我们必须执行一个剩余的计算来确定我们是否已经收敛了。

因此，最优解是，我们分别/异步地开始每一个局部残差计算，然后在hpx::future<double>向量上求和。利用HPX期货的思想，可以得到一个最优解，即我们尽快总结出所有的元素。

但到目前为止，我们只能得到以下代码：

#include <hpx/hpx_main.hpp>
#include <hpx/hpx.hpp>
#include <memory>
#include <iostream>

class A {
public:
  double residual() {
    // Calculate actual local residual
    return 1.0;
  }
};

int main() {
  // Create instances
  std::vector<A> vec(3);
  std::vector<hpx::shared_future<double>> res(vec.size());

  // asynchronous launch resdiual calculation
  for (size_t i = 0; i < res.size(); ++i) {
    res[i] = hpx::async( &A::residual, &vec[i] );
  }

  double residual = 0.0;
  for (size_t i = 0; i < res.size(); ++i) {
    residual += res[i].get();
  }

  std::cout << "residual: " << residual << std::endl;

  return 0;
}

这还远远不是最优的。在最坏的情况下，它的性能就像一个全局障碍，然后是对所有元素的纯顺序和。

那么，我们的问题是，我们如何才能像这样并行地实现这个"HPX“呢？

更新02.02.2019:

我们已经重写了代码，这样就不能完全异步地开始剩余计算，而是基于通过hpx::dataflow对象的数据依赖关系。

  // asynchronous launch resdiual calculation
  for (size_t i = 0; i < res.size(); ++i) {
    res[i] = hpx::dataflow( hpx::util::unwrapping(&A::residual), &vec[i], *DEPENDENCIES* );
  }

是否也可以用数据流对象调用@Mike代码，或者有另一种解决方案？

(提示:由于template argument deduction/substitution failed错误，我没有让您的代码工作)

Answer 1

您可以将transform_reduce模式用于您想要实现的目标：

std::vector<A> vec(300);
double res = hpx::parallel::transform_reduce(hpx::parallel::execution::par,        
                     vec.begin(), vec.end(),                      \\ (1)                         
                     0, [](double a, double b){ return a + b; },  \\ (2)
                     [](const A& a_ref){ return a_ref.residual(); });   \\ (3)

该代码将计算每个A在vec (1)中的剩余(3)，然后汇总所有结果(2)。