并行减少（例如求和）hpx::futures<double> 的向量

Question

我们目前正在尝试实现用于数值模拟的红黑高斯-赛德尔求解器。

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

但是现在我们有以下问题：在每第n个循环之后我们必须执行残差计算以确定我们是否已经收敛。

所以最佳解决方案是，我们开始每个局部残差计算 separately/asynchronously，然后对 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"？

2019 年 2 月 2 日更新：

我们已经重写了代码，因此我们无法完全异步地开始残差计算，而是通过 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 van Dyke 代码，或者是否有其他解决方案？

（提示：由于 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)

此代码将计算vec（1）中每个A的残差（3），然后将所有结果相加（2）。

并行减少（例如求和）hpx::futures<double> 的向量

Parallel reduce (e.g. sum) a vector of hpx::futures<double>

c++

hpx