Slic3r::execution Namespace Reference

Classes
struct	Traits
struct	Traits< EP, SequentialEPOnly< EP, void > >
struct	Traits< ExecutionTBB >

Typedefs
template<class EP>
using	AsTraits = Traits<remove_cvref_t<EP>>
template<class EP>
using	SpinningMutex = typename Traits<EP>::SpinningMutex
template<class EP>
using	BlockingMutex = typename Traits<EP>::BlockingMutex

Functions
template<class EP, class = ExecutionPolicyOnly<EP>>
size_t	max_concurrency (const EP &ep)
template<class EP, class It, class Fn, class = ExecutionPolicyOnly<EP>>
void	for_each (const EP &ep, It from, It to, Fn &&fn, size_t granularity=1)
template<class EP, class I, class MergeFn, class T, class AccessFn, class = ExecutionPolicyOnly<EP>>
T	reduce (const EP &ep, I from, I to, const T &init, MergeFn &&mergefn, AccessFn &&accessfn, size_t granularity=1)
template<class EP, class I, class MergeFn, class T, class = ExecutionPolicyOnly<EP>>
T	reduce (const EP &ep, I from, I to, const T &init, MergeFn &&mergefn, size_t granularity=1)
template<class EP, class I, class T, class AccessFn, class = ExecutionPolicyOnly<EP>>
T	accumulate (const EP &ep, I from, I to, const T &init, AccessFn &&accessfn, size_t granularity=1)
template<class EP, class I, class T, class = ExecutionPolicyOnly<EP>>
T	accumulate (const EP &ep, I from, I to, const T &init, size_t granularity=1)

---

Class Documentation

Slic3r::execution::Traits

struct Slic3r::execution::Traits

template<class EP, class En = void>
struct Slic3r::execution::Traits< EP, En >

Inheritance diagram for Slic3r::execution::Traits< EP, En >:

Typedef Documentation

AsTraits

template<class EP>

using Slic3r::execution::AsTraits = Traits<remove_cvref_t<EP>>

BlockingMutex

template<class EP>

using Slic3r::execution::BlockingMutex = typename Traits<EP>::BlockingMutex

SpinningMutex

template<class EP>

using Slic3r::execution::SpinningMutex = typename Traits<EP>::SpinningMutex

Function Documentation

accumulate() [1/2]

template<class EP, class I, class T, class AccessFn, class = ExecutionPolicyOnly<EP>>

T Slic3r::execution::accumulate	(	const EP &	ep,
		I	from,
		I	to,
		const T &	init,
		AccessFn &&	accessfn,
		size_t	granularity = 1 )

{
    return reduce(ep, from, to, init, std::plus<T>{},
                  std::forward<AccessFn>(accessfn), granularity);
}

References Slic3r::I, and reduce().

Here is the call graph for this function:

accumulate() [2/2]

template<class EP, class I, class T, class = ExecutionPolicyOnly<EP>>

T Slic3r::execution::accumulate	(	const EP &	ep,
		I	from,
		I	to,
		const T &	init,
		size_t	granularity = 1 )

{
    return reduce(
        ep, from, to, init, std::plus<T>{}, [](const auto &i) { return i; },
        granularity);
}

References Slic3r::I, and reduce().

Here is the call graph for this function:

for_each()

template<class EP, class It, class Fn, class = ExecutionPolicyOnly<EP>>

void Slic3r::execution::for_each	(	const EP &	ep,
		It	from,
		It	to,
		Fn &&	fn,
		size_t	granularity = 1 )

{
    AsTraits<EP>::for_each(ep, from, to, std::forward<Fn>(fn), granularity);
}

Referenced by Slic3r::csg::check_csgmesh_booleans(), Slic3r::csg::check_csgmesh_booleans(), Slic3r::create_face_neighbors_index(), Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::find_min_score(), Slic3r::sla::_ccr< false >::for_each(), Slic3r::sla::_ccr< true >::for_each(), marchsq::_Loop< Slic3r::ExecutionTBB >::for_each_idx(), Slic3r::csg::detail_cgal::get_cgalptrs(), and Slic3r::csg::detail_mcut::get_mcutptrs().

Here is the caller graph for this function:

max_concurrency()

template<class EP, class = ExecutionPolicyOnly<EP>>

size_t Slic3r::execution::max_concurrency

(

const EP &

ep

)

{
    return AsTraits<EP>::max_concurrency(ep);
}

Referenced by marchsq::_Loop< Slic3r::ExecutionTBB >::for_each_idx(), Slic3r::sla::_ccr< false >::max_concurreny(), and Slic3r::sla::_ccr< true >::max_concurreny().

Here is the caller graph for this function:

reduce() [1/2]

template<class EP, class I, class MergeFn, class T, class AccessFn, class = ExecutionPolicyOnly<EP>>

T Slic3r::execution::reduce	(	const EP &	ep,
		I	from,
		I	to,
		const T &	init,
		MergeFn &&	mergefn,
		AccessFn &&	accessfn,
		size_t	granularity = 1 )

{
    return AsTraits<EP>::reduce(ep, from, to, init,
                                std::forward<MergeFn>(mergefn),
                                std::forward<AccessFn>(accessfn),
                                granularity);
}

References Slic3r::I.

Referenced by accumulate(), accumulate(), Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::find_ground_level(), reduce(), Slic3r::sla::_ccr< false >::reduce(), Slic3r::sla::_ccr< true >::reduce(), Slic3r::slices_to_mesh(), and Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::sum_score().

Here is the caller graph for this function:

reduce() [2/2]

template<class EP, class I, class MergeFn, class T, class = ExecutionPolicyOnly<EP>>

T Slic3r::execution::reduce	(	const EP &	ep,
		I	from,
		I	to,
		const T &	init,
		MergeFn &&	mergefn,
		size_t	granularity = 1 )

{
    return reduce(
        ep, from, to, init, std::forward<MergeFn>(mergefn),
        [](const auto &i) { return i; }, granularity);
}

References Slic3r::I, and reduce().

Here is the call graph for this function: