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 AsTraits< EP >::SpinningMutex
template<class EP >
using	BlockingMutex = typename AsTraits< 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 >

Typedef Documentation

AsTraits

template<class EP >

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

BlockingMutex

template<class EP >

using Slic3r::execution::BlockingMutex = typedef typename AsTraits<EP>::BlockingMutex

SpinningMutex

template<class EP >

using Slic3r::execution::SpinningMutex = typedef typename AsTraits<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),
                  std::max(granularity, size_t(1)));
}

References 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; },
        std::max(granularity, size_t(1)));
}

References 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),
                           std::max(granularity, size_t(1)));
}

Referenced by Slic3r::sla::DefaultSupportTree::add_pinheads(), Slic3r::sla::beam_mesh_hit(), Slic3r::csg::check_csgmesh_booleans(), Slic3r::sla::create_branching_tree(), Slic3r::create_face_neighbors_index(), Slic3r::anonymous_namespace{SL1.cpp}::extract_slices_from_sla_archive(), Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::find_min_score(), Slic3r::csg::detail_cgal::get_cgalptrs(), Slic3r::sla::make_layers(), Slic3r::SLAPrint::Steps::merge_slices_and_eval_stats(), Slic3r::normals(), Slic3r::sla::pinhead_mesh_hit(), Slic3r::point_grid(), Slic3r::sla::SupportPointGenerator::project_onto_mesh(), Slic3r::sla::remove_inside_triangles(), Slic3r::sla::DefaultSupportTree::routing_to_model(), and Slic3r::slices_to_mesh().

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 Slic3r::sla::DefaultSupportTree::add_pinheads(), Slic3r::sla::create_branching_tree(), Slic3r::SLAPrint::Steps::merge_slices_and_eval_stats(), and Slic3r::slices_to_mesh().

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),
                                std::max(granularity, size_t(1)));
}

Referenced by accumulate(), accumulate(), Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::find_ground_level(), 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; }, std::max(granularity, size_t(1)));
}

References reduce().

Here is the call graph for this function: