平行约简(例如求和)hpx：：期货<double>的向量

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

本文关键字：期货 lt double 向量 gt hpx 求和      更新时间：2023-10-16

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

为此，我们将模拟区域划分为大小相等的子网格。我们能够在具有正确相关性和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 van Dyke代码，或者是否有其他解决方案？

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

您可以使用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)。

相关文章：