threading_std Namespace Reference

Classes
class	task_group

Functions
template<typename Fn , typename... Args, typename Result = std::result_of_t<Fn && (Args && ...)>>
future< Result >	async (Fn &&fn, Args &&...args)
template<typename Int , typename Body , typename Partitioner = auto_partitioner>
void	parallel_for (const blocked_range< Int > &range, const Body &body, const Partitioner &p=Partitioner())
	Parallel iteration over range with default partitioner. More...
template<typename Index , typename Function , typename Partitioner = auto_partitioner>
void	parallel_for (Index first, Index last, const Function &f, const Partitioner &p=Partitioner())
template<typename Int , typename Value , typename RealBody , typename Reduction , typename Partitioner = auto_partitioner>
Value	parallel_reduce (const blocked_range< Int > &range, const Value &identity, const RealBody &real_body, const Reduction &reduction, const Partitioner &p=Partitioner())
	Parallel iteration with reduction. More...

Variables
constexpr auto	launch = std::launch::THREADING_STD_LAUNCH

Function Documentation

template<typename Fn , typename... Args, typename Result = std::result_of_t<Fn && (Args && ...)>>

future<Result> threading_std::async	(	Fn &&	fn,
		Args &&...	args
	)

Definition at line 105 of file threading_std.h.

References run_benchmark_import::args, threading_serial::async(), and launch.

Referenced by threading_std::task_group::run().

                                              {
  return std::async(launch, std::forward<Fn>(fn), std::forward<Args>(args)...);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Int , typename Body , typename Partitioner = auto_partitioner>

void threading_std::parallel_for	(	const blocked_range< Int > &	range,
		const Body &	body,
		const Partitioner &	p = Partitioner()
	)

Parallel iteration over range with default partitioner.

Definition at line 133 of file threading_std.h.

References threading_serial::async(), threading_common::blocked_range< Value >::begin(), cpu_threads(), threading_common::blocked_range< Value >::end(), launch, and threading_common::blocked_range< Value >::size().

Referenced by parallel_for().

                                                        {
  const Int worker_count = cpu_threads();
  std::vector<std::future<void>> worker_threads;
  worker_threads.reserve(worker_count);

  for (Int i = 0,
           start_entry = range.begin(),
           stop_entry = range.end(),
           stride = (range.size() + worker_count - 1) / worker_count;
       i < worker_count && start_entry < stop_entry;
       ++i, start_entry += stride) {
    const auto end_entry = std::min(start_entry + stride, stop_entry);
    // TODO grainsize?
    worker_threads.emplace_back(
        std::async(launch, body, blocked_range<Int>(start_entry, end_entry)));
  }
  for (auto& child : worker_threads) {
    child.wait();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Index , typename Function , typename Partitioner = auto_partitioner>

void threading_std::parallel_for	(	Index	first,
		Index	last,
		const Function &	f,
		const Partitioner &	p = Partitioner()
	)

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

Definition at line 159 of file threading_std.h.

References threading_common::blocked_range< Value >::begin(), threading_common::blocked_range< Value >::end(), f(), and parallel_for().

                                                        {
  parallel_for(
      blocked_range<Index>(first, last),
      [&f](const blocked_range<Index>& r) {
        //#pragma ivdep
        //#pragma omp simd
        for (auto i = r.begin(), e = r.end(); i < e; i++) {
          f(i);
        }
      },
      p);
}

Here is the call graph for this function:

template<typename Int , typename Value , typename RealBody , typename Reduction , typename Partitioner = auto_partitioner>

Value threading_std::parallel_reduce	(	const blocked_range< Int > &	range,
		const Value &	identity,
		const RealBody &	real_body,
		const Reduction &	reduction,
		const Partitioner &	p = Partitioner()
	)

Parallel iteration with reduction.

Definition at line 182 of file threading_std.h.

References threading_serial::async(), threading_common::blocked_range< Value >::begin(), cpu_threads(), threading_common::blocked_range< Value >::end(), launch, and threading_common::blocked_range< Value >::size().

                                                            {
  const size_t worker_count = cpu_threads();
  std::vector<std::future<Value>> worker_threads;
  worker_threads.reserve(worker_count);

  for (Int i = 0,
           start_entry = range.begin(),
           stop_entry = range.end(),
           stride = (range.size() + worker_count - 1) / worker_count;
       i < worker_count && start_entry < stop_entry;
       ++i, start_entry += stride) {
    const auto end_entry = std::min(start_entry + stride, stop_entry);
    // TODO grainsize?
    worker_threads.emplace_back(std::async(
        launch, real_body, blocked_range<Int>(start_entry, end_entry), Value{}));
  }
  Value v = identity;
  for (auto& child : worker_threads) {
    v = reduction(v, child.get());
  }

  return v;
}

Here is the call graph for this function:

Variable Documentation

constexpr auto threading_std::launch = std::launch::THREADING_STD_LAUNCH

Definition at line 100 of file threading_std.h.

Referenced by async(), parallel_for(), and parallel_reduce().