tbb::strict_ppl Namespace Reference

For internal use only. More...

Namespaces
	internal

Classes
class	concurrent_queue
	A high-performance thread-safe non-blocking concurrent queue. More...

Functions
template<typename Index , typename Function , typename Partitioner >
void	parallel_for_impl (Index first, Index last, Index step, const Function &f, Partitioner &partitioner)
	Implementation of parallel iteration over stepped range of integers with explicit step and partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, Index step, const Function &f)
	Parallel iteration over a range of integers with a step provided and default partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, Index step, const Function &f, const simple_partitioner &partitioner)
	Parallel iteration over a range of integers with a step provided and simple partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, Index step, const Function &f, const auto_partitioner &partitioner)
	Parallel iteration over a range of integers with a step provided and auto partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, Index step, const Function &f, const static_partitioner &partitioner)
	Parallel iteration over a range of integers with a step provided and static partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, Index step, const Function &f, affinity_partitioner &partitioner)
	Parallel iteration over a range of integers with a step provided and affinity partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, const Function &f)
	Parallel iteration over a range of integers with a default step value and default partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, const Function &f, const simple_partitioner &partitioner)
	Parallel iteration over a range of integers with a default step value and simple partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, const Function &f, const auto_partitioner &partitioner)
	Parallel iteration over a range of integers with a default step value and auto partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, const Function &f, const static_partitioner &partitioner)
	Parallel iteration over a range of integers with a default step value and static partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, const Function &f, affinity_partitioner &partitioner)
	Parallel iteration over a range of integers with a default step value and affinity partitioner. More...
template<typename Index , typename Function , typename Partitioner >
void	parallel_for_impl (Index first, Index last, Index step, const Function &f, Partitioner &partitioner, tbb::task_group_context &context)
	Implementation of parallel iteration over stepped range of integers with explicit step, task group context, and partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, Index step, const Function &f, tbb::task_group_context &context)
	Parallel iteration over a range of integers with explicit step, task group context, and default partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, Index step, const Function &f, const simple_partitioner &partitioner, tbb::task_group_context &context)
	Parallel iteration over a range of integers with explicit step, task group context, and simple partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, Index step, const Function &f, const auto_partitioner &partitioner, tbb::task_group_context &context)
	Parallel iteration over a range of integers with explicit step, task group context, and auto partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, Index step, const Function &f, const static_partitioner &partitioner, tbb::task_group_context &context)
	Parallel iteration over a range of integers with explicit step, task group context, and static partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, Index step, const Function &f, affinity_partitioner &partitioner, tbb::task_group_context &context)
	Parallel iteration over a range of integers with explicit step, task group context, and affinity partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, const Function &f, tbb::task_group_context &context)
	Parallel iteration over a range of integers with a default step value, explicit task group context, and default partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, const Function &f, const simple_partitioner &partitioner, tbb::task_group_context &context)
	Parallel iteration over a range of integers with a default step value, explicit task group context, and simple partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, const Function &f, const auto_partitioner &partitioner, tbb::task_group_context &context)
	Parallel iteration over a range of integers with a default step value, explicit task group context, and auto partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, const Function &f, const static_partitioner &partitioner, tbb::task_group_context &context)
	Parallel iteration over a range of integers with a default step value, explicit task group context, and static partitioner. More...
template<typename Index , typename Function >
void	parallel_for (Index first, Index last, const Function &f, affinity_partitioner &partitioner, tbb::task_group_context &context)
	Parallel iteration over a range of integers with a default step value, explicit task group context, and affinity_partitioner. More...

Detailed Description

For internal use only.

Function Documentation

parallel_for() [1/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		Index	step,
		const Function &	f
	)

Parallel iteration over a range of integers with a step provided and default partitioner.

Definition at line 290 of file tbb/parallel_for.h.

References tbb::internal::first(), and tbb::internal::last().

Referenced by parallel_for().

                                                                          {
    parallel_for_impl<Index,Function,const auto_partitioner>(first, last, step, f, auto_partitioner());
}

Here is the call graph for this function:

Here is the caller graph for this function:

parallel_for() [2/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		Index	step,
		const Function &	f,
		const simple_partitioner &	partitioner
	)

Parallel iteration over a range of integers with a step provided and simple partitioner.

Definition at line 295 of file tbb/parallel_for.h.

References tbb::internal::first(), and tbb::internal::last().

                                                                                                                 {
    parallel_for_impl<Index,Function,const simple_partitioner>(first, last, step, f, partitioner);
}

Here is the call graph for this function:

parallel_for() [3/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		Index	step,
		const Function &	f,
		const auto_partitioner &	partitioner
	)

Parallel iteration over a range of integers with a step provided and auto partitioner.

Definition at line 300 of file tbb/parallel_for.h.

References tbb::internal::first(), and tbb::internal::last().

                                                                                                               {
    parallel_for_impl<Index,Function,const auto_partitioner>(first, last, step, f, partitioner);
}

Here is the call graph for this function:

parallel_for() [4/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		Index	step,
		const Function &	f,
		const static_partitioner &	partitioner
	)

Parallel iteration over a range of integers with a step provided and static partitioner.

Definition at line 305 of file tbb/parallel_for.h.

References tbb::internal::first(), and tbb::internal::last().

                                                                                                                 {
    parallel_for_impl<Index,Function,const static_partitioner>(first, last, step, f, partitioner);
}

Here is the call graph for this function:

parallel_for() [5/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		Index	step,
		const Function &	f,
		affinity_partitioner &	partitioner
	)

Parallel iteration over a range of integers with a step provided and affinity partitioner.

Definition at line 310 of file tbb/parallel_for.h.

References parallel_for_impl().

                                                                                                             {
    parallel_for_impl(first, last, step, f, partitioner);
}

Here is the call graph for this function:

parallel_for() [6/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		const Function &	f
	)

Parallel iteration over a range of integers with a default step value and default partitioner.

Definition at line 316 of file tbb/parallel_for.h.

References tbb::internal::first(), and tbb::internal::last().

                                                              {
    parallel_for_impl<Index,Function,const auto_partitioner>(first, last, static_cast<Index>(1), f, auto_partitioner());
}

Here is the call graph for this function:

parallel_for() [7/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		const Function &	f,
		const simple_partitioner &	partitioner
	)

Parallel iteration over a range of integers with a default step value and simple partitioner.

Definition at line 321 of file tbb/parallel_for.h.

References tbb::internal::first(), and tbb::internal::last().

                                                                                                     {
    parallel_for_impl<Index,Function,const simple_partitioner>(first, last, static_cast<Index>(1), f, partitioner);
}

Here is the call graph for this function:

parallel_for() [8/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		const Function &	f,
		const auto_partitioner &	partitioner
	)

Parallel iteration over a range of integers with a default step value and auto partitioner.

Definition at line 326 of file tbb/parallel_for.h.

References tbb::internal::first(), and tbb::internal::last().

                                                                                                   {
    parallel_for_impl<Index,Function,const auto_partitioner>(first, last, static_cast<Index>(1), f, partitioner);
}

Here is the call graph for this function:

parallel_for() [9/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		const Function &	f,
		const static_partitioner &	partitioner
	)

Parallel iteration over a range of integers with a default step value and static partitioner.

Definition at line 331 of file tbb/parallel_for.h.

References tbb::internal::first(), and tbb::internal::last().

                                                                                                     {
    parallel_for_impl<Index,Function,const static_partitioner>(first, last, static_cast<Index>(1), f, partitioner);
}

Here is the call graph for this function:

parallel_for() [10/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		const Function &	f,
		affinity_partitioner &	partitioner
	)

Parallel iteration over a range of integers with a default step value and affinity partitioner.

Definition at line 336 of file tbb/parallel_for.h.

References parallel_for_impl().

                                                                                                 {
    parallel_for_impl(first, last, static_cast<Index>(1), f, partitioner);
}

Here is the call graph for this function:

parallel_for() [11/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		Index	step,
		const Function &	f,
		tbb::task_group_context &	context
	)

Parallel iteration over a range of integers with explicit step, task group context, and default partitioner.

Definition at line 357 of file tbb/parallel_for.h.

References tbb::task::context(), tbb::internal::first(), and tbb::internal::last().

                                                                                                          {
    parallel_for_impl<Index,Function,const auto_partitioner>(first, last, step, f, auto_partitioner(), context);
}

Here is the call graph for this function:

parallel_for() [12/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		Index	step,
		const Function &	f,
		const simple_partitioner &	partitioner,
		tbb::task_group_context &	context
	)

Parallel iteration over a range of integers with explicit step, task group context, and simple partitioner.

Definition at line 362 of file tbb/parallel_for.h.

References tbb::task::context(), tbb::internal::first(), and tbb::internal::last().

                                                                                                                                                 {
    parallel_for_impl<Index,Function,const simple_partitioner>(first, last, step, f, partitioner, context);
}

Here is the call graph for this function:

parallel_for() [13/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		Index	step,
		const Function &	f,
		const auto_partitioner &	partitioner,
		tbb::task_group_context &	context
	)

Parallel iteration over a range of integers with explicit step, task group context, and auto partitioner.

Definition at line 367 of file tbb/parallel_for.h.

References tbb::task::context(), tbb::internal::first(), and tbb::internal::last().

                                                                                                                                               {
    parallel_for_impl<Index,Function,const auto_partitioner>(first, last, step, f, partitioner, context);
}

Here is the call graph for this function:

parallel_for() [14/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		Index	step,
		const Function &	f,
		const static_partitioner &	partitioner,
		tbb::task_group_context &	context
	)

Parallel iteration over a range of integers with explicit step, task group context, and static partitioner.

Definition at line 372 of file tbb/parallel_for.h.

References tbb::task::context(), tbb::internal::first(), and tbb::internal::last().

                                                                                                                                                 {
    parallel_for_impl<Index,Function,const static_partitioner>(first, last, step, f, partitioner, context);
}

Here is the call graph for this function:

parallel_for() [15/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		Index	step,
		const Function &	f,
		affinity_partitioner &	partitioner,
		tbb::task_group_context &	context
	)

Parallel iteration over a range of integers with explicit step, task group context, and affinity partitioner.

Definition at line 377 of file tbb/parallel_for.h.

References parallel_for_impl().

                                                                                                                                             {
    parallel_for_impl(first, last, step, f, partitioner, context);
}

Here is the call graph for this function:

parallel_for() [16/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		const Function &	f,
		tbb::task_group_context &	context
	)

Parallel iteration over a range of integers with a default step value, explicit task group context, and default partitioner.

Definition at line 384 of file tbb/parallel_for.h.

References tbb::task::context(), tbb::internal::first(), and tbb::internal::last().

                                                                                              {
    parallel_for_impl<Index,Function,const auto_partitioner>(first, last, static_cast<Index>(1), f, auto_partitioner(), context);
}

Here is the call graph for this function:

parallel_for() [17/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		const Function &	f,
		const simple_partitioner &	partitioner,
		tbb::task_group_context &	context
	)

Parallel iteration over a range of integers with a default step value, explicit task group context, and simple partitioner.

Definition at line 389 of file tbb/parallel_for.h.

References tbb::internal::first(), and tbb::internal::last().

                                                                                                                                     {
    parallel_for_impl<Index,Function,const simple_partitioner>(first, last, static_cast<Index>(1), f, partitioner, context);
}

Here is the call graph for this function:

parallel_for() [18/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		const Function &	f,
		const auto_partitioner &	partitioner,
		tbb::task_group_context &	context
	)

Parallel iteration over a range of integers with a default step value, explicit task group context, and auto partitioner.

Definition at line 394 of file tbb/parallel_for.h.

References tbb::internal::first(), and tbb::internal::last().

                                                                                                                                   {
    parallel_for_impl<Index,Function,const auto_partitioner>(first, last, static_cast<Index>(1), f, partitioner, context);
}

Here is the call graph for this function:

parallel_for() [19/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		const Function &	f,
		const static_partitioner &	partitioner,
		tbb::task_group_context &	context
	)

Parallel iteration over a range of integers with a default step value, explicit task group context, and static partitioner.

Definition at line 399 of file tbb/parallel_for.h.

References tbb::internal::first(), and tbb::internal::last().

                                                                                                                                     {
    parallel_for_impl<Index,Function,const static_partitioner>(first, last, static_cast<Index>(1), f, partitioner, context);
}

Here is the call graph for this function:

parallel_for() [20/20]

template<typename Index , typename Function >

void tbb::strict_ppl::parallel_for	(	Index	first,
		Index	last,
		const Function &	f,
		affinity_partitioner &	partitioner,
		tbb::task_group_context &	context
	)

Parallel iteration over a range of integers with a default step value, explicit task group context, and affinity_partitioner.

Definition at line 404 of file tbb/parallel_for.h.

References parallel_for(), and parallel_for_impl().

                                                                                                                                 {
    parallel_for_impl(first, last, static_cast<Index>(1), f, partitioner, context);
}

Here is the call graph for this function:

parallel_for_impl() [1/2]

template<typename Index , typename Function , typename Partitioner >

void tbb::strict_ppl::parallel_for_impl	(	Index	first,
		Index	last,
		Index	step,
		const Function &	f,
		Partitioner &	partitioner
	)

Implementation of parallel iteration over stepped range of integers with explicit step and partitioner.

Definition at line 276 of file tbb/parallel_for.h.

References tbb::internal::eid_nonpositive_step, end, tbb::parallel_for(), and tbb::internal::throw_exception().

                                                                                                         {
    if (step <= 0 )
        internal::throw_exception(internal::eid_nonpositive_step); // throws std::invalid_argument
    else if (last > first) {
        // Above "else" avoids "potential divide by zero" warning on some platforms
        Index end = (last - first - Index(1)) / step + Index(1);
        tbb::blocked_range<Index> range(static_cast<Index>(0), end);
        internal::parallel_for_body<Function, Index> body(f, first, step);
        tbb::parallel_for(range, body, partitioner);
    }
}

Here is the call graph for this function:

parallel_for_impl() [2/2]

template<typename Index , typename Function , typename Partitioner >

void tbb::strict_ppl::parallel_for_impl	(	Index	first,
		Index	last,
		Index	step,
		const Function &	f,
		Partitioner &	partitioner,
		tbb::task_group_context &	context
	)

Implementation of parallel iteration over stepped range of integers with explicit step, task group context, and partitioner.

Definition at line 343 of file tbb/parallel_for.h.

References tbb::internal::eid_nonpositive_step, end, tbb::parallel_for(), and tbb::internal::throw_exception().

Referenced by parallel_for().

                                                                                                                                         {
    if (step <= 0 )
        internal::throw_exception(internal::eid_nonpositive_step); // throws std::invalid_argument
    else if (last > first) {
        // Above "else" avoids "potential divide by zero" warning on some platforms
        Index end = (last - first - Index(1)) / step + Index(1);
        tbb::blocked_range<Index> range(static_cast<Index>(0), end);
        internal::parallel_for_body<Function, Index> body(f, first, step);
        tbb::parallel_for(range, body, partitioner, context);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: