parallel.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ALGORITHM_PARALLEL_HPP__
#define NEFORCE_CORE_ALGORITHM_PARALLEL_HPP__

 
#include "NeForce/core/algorithm/iterator.hpp"
#include "NeForce/core/async/thread.hpp"
NEFORCE_BEGIN_NAMESPACE__



template <typename Iterator, typename BinaryOperation, typename Result, size_t Threshhold = 10>
void reduce(Iterator first, Iterator last, BinaryOperation op, Result& res) {
    static_assert(is_ranges_input_iter_v<Iterator>, "Iterator must be input_iterator");
 
    const size_t dist = _NEFORCE distance(first, last);
    if (dist <= Threshhold) {
        for (Iterator it = first; it != last; ++it) {
            res = op(res, *it);
        }
    } else {
        Iterator mid = _NEFORCE next(first, dist / 2);
        Result l_res = res, r_res = res;
        _NEFORCE thread r_thd(reduce<Iterator, BinaryOperation, Result, Threshhold>, mid, last, op,
                              _NEFORCE ref(r_res));
        _NEFORCE reduce(first, mid, op, l_res);
        r_thd.join();
        res = op(l_res, r_res);
    }
}

template <typename Iterator, typename UnaryOperation, typename BinaryOp, typename Result, size_t Threshhold = 10>
void transform_reduce(Iterator first, Iterator last, UnaryOperation transform, BinaryOp reduce, Result& res) {
    static_assert(is_ranges_input_iter_v<Iterator>, "Iterator must be input_iterator");
 
    const size_t dist = _NEFORCE distance(first, last);
    if (dist <= Threshhold) {
        for (Iterator it = first; it != last; ++it) {
            res = reduce(res, transform(*it));
        }
    } else {
        Iterator mid = _NEFORCE next(first, dist / 2);
        Result l_res = _NEFORCE initialize<Result>(), r_res = _NEFORCE initialize<Result>();
        _NEFORCE thread r_thd(transform_reduce<Iterator, UnaryOperation, BinaryOp, Result, Threshhold>, mid, last,
                              transform, reduce, _NEFORCE ref(r_res));
        _NEFORCE transform_reduce(first, mid, transform, reduce, l_res);
        r_thd.join();
        res = reduce(res, reduce(l_res, r_res));
    }
}
 // ParallelAlgorithms
 // StandardAlgorithms
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ALGORITHM_PARALLEL_HPP__