Question

考虑T型元素的容器，例如： std::vector<T> input，以及过于耗时的功能T f(const T&, const T&)。我希望在f上应用input，直到保留一个元素 - 并行。

我是C ++的新手，所以我根据自己的需要调整了Thread pool pattern in C++11的现有实现，特别是this example。

讨论代码：

#include <thread>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <memory>
#include <future>
#include <functional>
#include <stdexcept>

#include "ThreadPool.h"

template<class T>
T ParallelReduction(ThreadPool& pool, const std::vector<T>& input, const std::function<T(T,T)>& func)
{
    std::queue<std::future<T>> futureResults;
    std::for_each(input.begin(), input.end(), [&futureResults](T e)
    {
        // T -> future<T>
        futureResults.push(std::async([e]{return e;}));
    });

    for (;;)
    {
        if (futureResults.size() > 1)
        {
            // Get two "old" partial results, forward them to func(T,T)
            T a = futureResults.front().get();
            futureResults.pop();
            T b = futureResults.front().get();
            futureResults.pop();

            futureResults.push(pool.enqueue([a, b, func]{return func(a,b);}));
        }
        else
        {
            // all input and partial result elements have been processed once, return the final result
            return futureResults.front().get();
        }
    }
}

int main(int argc, char *argv[])
{
    ThreadPool pool(4);

    std::vector<int> input(12);
    int n = 0;
    std::generate(input.begin(), input.end(), [&n]{ return ++n; });

    auto sum = ParallelReduction<int>(pool, input, [](int a, int b){return a + b;});
    std::cout << sum << "\n";

    auto fibonacci = ParallelReduction<int>(pool, input, [](int a, int b){return a * b;});
    std::cout << fibonacci << "\n";

    return 0;
}

我的问题：

是否可以在不引入futureResults的情况下实现这一点，即一个有效的解决方案＆＃34; inline＆＃34;在std::vector<T>& input？
如果没有，我们是否可以优化我们在第一部分中将值T分配给std::future<T>的方式？
将std::future<T>转发给我们的函数func而不是T是否更有效，即让子线程等待并访问a和{{1}的值而不是主线程？
循环内部的部分看起来很糟糕 - 有什么想法吗？
我可以在哪里优化代码？

C ++ 11：用于连续减少输入的线程池

0 个答案: