c++ - 我们如何并行运行一个算法的 n 个实例，并以有效的方式计算结果函数的平均值？

Question

我要运行 n并行算法实例并计算函数的平均值 f结果。如果我没有大错特错的话，下面的代码可以实现这个目标:

struct X {};
int f(X) { return /* ... */; }

int main()
{
    std::size_t const n = /* ... */;
    std::vector<std::future<X>> results;
    results.reserve(n);

    for (std::size_t i = 0; i < n; ++i)
        results.push_back(std::async([]() -> X { /* ... */ }));

    int mean = 0;
    for (std::size_t i = 0; i < n; ++i)
        mean += f(results[i].get());
    mean /= n;
}

但是，有没有更好的方法来做到这一点？上面代码的明显问题如下:行中求和的顺序 mean += f(results[i].get());没关系。因此，最好将结果添加到 mean 中。一旦可用。如果在上面的代码中，i 的结果th 任务尚不可用，程序等待该结果，而任务 i + 1 的所有结果可能都是至 n - 1已经可用。

那么，我们怎样才能以更好的方式做到这一点？

Answer 1

您正在阻止 future ，这是一项为时过早的操作。

为什么不在异步线程中更新累加和，然后在所有线程完成时阻塞？

#include <condition_variable>
#include <thread>
#include <mutex>

struct X {};
int f(X);
X make_x(int);

struct algo_state
{
    std::mutex m;
    std::condition_variable cv;
    int remaining_tasks;
    int accumulator;
};

void task(X x, algo_state& state)
{
    auto part = f(x);
    auto lock = std::unique_lock(state.m);
    state.accumulator += part;
    if (--state.remaining_tasks == 0)
    {
        lock.unlock();
        state.cv.notify_one();
    }
}

int main()
{
    int get_n();
    auto n = get_n();
    algo_state state = {
        {},
        {},
        n,
        0
    };

    for(int i = 0 ; i < n ; ++i)
        std::thread([&] { task(make_x(i), state); }).detach();

    auto lock = std::unique_lock(state.m);
    state.cv.wait(lock, [&] { return state.remaining_tasks == 0; });
    auto mean = state.accumulator / n;
    return mean;
}