ForEach.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 "Partitioner.hpp"
#include "UnaryAlgorithm.hpp"
 
#include "CeresEngine/Foundation/Async.hpp"
#include "CeresEngine/Foundation/Container/ConcurrentQueue.hpp"
#include "CeresEngine/Foundation/Traits/is_forward_iterator.hpp"
#include "CeresEngine/Foundation/Traits/is_indirectly_unary_invocable.hpp"
 
#include <iostream>
 
namespace CeresEngine {
 
    class ForEachAlgorithmFunctor : public UnaryAlgorithmFunctor<ForEachAlgorithmFunctor> {
        friend UnaryAlgorithmFunctor<ForEachAlgorithmFunctor>;
 
        template<class Executor> class Graph {
        private:
            const Executor& mExecutor;
 
        public:
            explicit Graph(const Executor& executor) : mExecutor(executor) {}
 
            template<class P, class I, class S, class Fun> Async<> launch(P p, I first, S last, Fun f) {
                const auto middle = p(first, last);
                const bool isTooSmall = middle == last;
                constexpr bool isParallelizable = traits::is_forward_iterator_v<I>;
 
                // NOTE: If the grain is either too small or the iterators are
                // not parallelizable, we execute the work inline.
                if(isTooSmall || !isParallelizable) {
                    return with(mExecutor, [first, last, f]() { run(first, last, f); });
                }
 
                return when_all(
                    // Create task that launches tasks for rhs: [middle, last]
                    launch(p, middle, last, f),
 
                    // Launch tasks for lhs: [first, middle]
                    launch(p, first, middle, f));
            }
        };
 
        template<class I, class S, class Fun>
        requires(
            // clang-format off
                    traits::is_input_iterator_v<I> &&
                    traits::is_sentinel_for_v<S, I> &&
                    traits::is_indirectly_unary_invocable_v<Fun, I> &&
                    std::is_copy_constructible_v<Fun>
            // clang-format on
            ) static constexpr void run(I first, S last, Fun f) {
            std::for_each(first, last, std::move(f));
        }
 
        template<class E, class P, class I, class S, class Fun>
        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> &&
                    traits::is_indirectly_unary_invocable_v<Fun, I> &&
                    std::is_copy_constructible_v<Fun>
            // clang-format on
            ) static Async<> run(const E& executor, P p, I first, S last, Fun f) {
            if constexpr(traits::is_inline_executor_v<E>) {
                co_return run(first, last, f);
            } else {
                co_return co_await Graph<E>(executor).launch(p, first, last, f);
            }
        }
    };
 
    inline constexpr ForEachAlgorithmFunctor for_each;
 
} // namespace CeresEngine