85 lines
2.4 KiB
C++
85 lines
2.4 KiB
C++
#ifndef EXECUTIONSEQ_HPP
|
|
#define EXECUTIONSEQ_HPP
|
|
|
|
#ifdef PRUSASLICER_USE_EXECUTION_STD // Conflicts with our version of TBB
|
|
#include <execution>
|
|
#endif
|
|
|
|
#include "Execution.hpp"
|
|
|
|
namespace Slic3r {
|
|
|
|
// Execution policy implementing dummy sequential algorithms
|
|
struct ExecutionSeq {};
|
|
|
|
template<> struct IsExecutionPolicy_<ExecutionSeq> : public std::true_type {};
|
|
|
|
static constexpr ExecutionSeq ex_seq = {};
|
|
|
|
template<class EP> struct IsSequentialEP_ { static constexpr bool value = false; };
|
|
|
|
template<> struct IsSequentialEP_<ExecutionSeq>: public std::true_type {};
|
|
#ifdef PRUSASLICER_USE_EXECUTION_STD
|
|
template<> struct IsExecutionPolicy_<std::execution::sequenced_policy>: public std::true_type {};
|
|
template<> struct IsSequentialEP_<std::execution::sequenced_policy>: public std::true_type {};
|
|
#endif
|
|
|
|
template<class EP>
|
|
constexpr bool IsSequentialEP = IsSequentialEP_<remove_cvref_t<EP>>::value;
|
|
|
|
template<class EP, class R = EP>
|
|
using SequentialEPOnly = std::enable_if_t<IsSequentialEP<EP>, R>;
|
|
|
|
template<class EP>
|
|
struct execution::Traits<EP, SequentialEPOnly<EP, void>> {
|
|
private:
|
|
struct _Mtx { inline void lock() {} inline void unlock() {} };
|
|
|
|
template<class Fn, class It>
|
|
static IteratorOnly<It, void> loop_(It from, It to, Fn &&fn)
|
|
{
|
|
for (auto it = from; it != to; ++it) fn(*it);
|
|
}
|
|
|
|
template<class Fn, class I>
|
|
static IntegerOnly<I, void> loop_(I from, I to, Fn &&fn)
|
|
{
|
|
for (I i = from; i < to; ++i) fn(i);
|
|
}
|
|
|
|
public:
|
|
using SpinningMutex = _Mtx;
|
|
using BlockingMutex = _Mtx;
|
|
|
|
template<class It, class Fn>
|
|
static void for_each(const EP &,
|
|
It from,
|
|
It to,
|
|
Fn &&fn,
|
|
size_t /* ignore granularity */ = 1)
|
|
{
|
|
loop_(from, to, std::forward<Fn>(fn));
|
|
}
|
|
|
|
template<class I, class MergeFn, class T, class AccessFn>
|
|
static T reduce(const EP &,
|
|
I from,
|
|
I to,
|
|
const T & init,
|
|
MergeFn &&mergefn,
|
|
AccessFn &&access,
|
|
size_t /*granularity*/ = 1
|
|
)
|
|
{
|
|
T acc = init;
|
|
loop_(from, to, [&](auto &i) { acc = mergefn(acc, access(i)); });
|
|
return acc;
|
|
}
|
|
|
|
static size_t max_concurrency(const EP &) { return 1; }
|
|
};
|
|
|
|
} // namespace Slic3r
|
|
|
|
#endif // EXECUTIONSEQ_HPP
|