Reduce.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "BinaryAlgorithm.hpp"
 
#include "CeresEngine/Foundation/Algorithm/Partitioner.hpp"
 
#include <numeric>
 
namespace CeresEngine {
 
    class ReduceAlgorithmFunctor : public BinaryAlgorithmFunctor<ReduceAlgorithmFunctor> {
        friend BinaryAlgorithmFunctor<ReduceAlgorithmFunctor>;
 
        template<class Executor, class T> class Graph {
        private:
            Executor mExecutor;
 
        public:
            explicit Graph(const Executor& executor) : mExecutor(executor) {}
 
            template<class P, class I, class S, class Fun> Async<T> launch(P p, I first, S last, T i, Fun f) {
                auto middle = p(first, last);
                const traits::iter_difference_t<I> isTooSmall = middle == last;
                constexpr traits::iter_difference_t<I> isNotParallelize = traits::is_forward_iterator_v<I>;
                if(isTooSmall || isNotParallelize) {
                    return with(mExecutor, [first, last, i, f]() { return run(first, last, i, f); });
                }
 
                // Create task that launches tasks for rhs: [middle, last]
                return when_all(
                    // Create task that launches tasks for rhs: [middle, last]
                    launch(p, middle, last, i, f),
 
                    // Launch tasks for lhs: [first, middle]
                    launch(p, first, middle, i, f))
                    .then(f);
            }
        };
 
        template<class I, class S, class T, class Fun = std::plus<>>
        requires(
            // clang-format off
                    traits::is_input_iterator_v<I> &&
                    traits::is_sentinel_for_v<S, I> &&
                    std::is_same_v<traits::iter_value_t<I>, T> &&
                    traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
                    std::is_copy_constructible_v<Fun>
            // clang-format on
            ) static constexpr T run(I first, S last, T init, Fun op) {
            return std::accumulate(first, last, std::move(init), std::move(op));
        }
 
        template<class E, class P, class I, class S, class T, class Fun = std::plus<>>
        requires(
            // clang-format off
                    traits::is_executor_v<E> &&
                    traits::is_partitioner_v<P, I, S> &&
                    traits::is_input_iterator_v<I> &&
                    traits::is_sentinel_for_v<S, I> &&
                    std::is_same_v<traits::iter_value_t<I>, T> &&
                    traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
                    std::is_copy_constructible_v<Fun>
            // clang-format on
            ) static Async<T> run(const E& executor, P p, I first, S last, T i, Fun f = Fun()) {
            if constexpr(traits::is_inline_executor_v<E>) {
                co_return run(first, last, i, f);
            } else {
                co_return co_await Graph<E, T>(executor).launch(p, first, last, i, f);
            }
        }
    };
 
    inline constexpr ReduceAlgorithmFunctor reduce;
 
} // namespace CeresEngine