ParallelExecutor< TT > Class Template Reference

Abstraction for running concurrent tasks in parallel by an executor executor workers can be OpenMP threads, std::thread. More...

Collaboration diagram for ParallelExecutor< TT >:

Public Member Functions
template<typename F , typename... Args>
void	operator() (int num_tasks, F &&f, Args &&... args)
	Concurrently execute an arbitrary function/kernel with task id and arbitrary args. More...
template<>
void	operator() (int num_tasks, F &&f, Args &&... args)
	implements parallel tasks executed by threads in an OpenMP thread pool. More...
template<>
void	operator() (int num_tasks, F &&f, Args &&... args)
	implements parallel tasks executed by STD threads. More...

Detailed Description

template<Executor TT = Executor::OPENMP>
class qmcplusplus::ParallelExecutor< TT >

Abstraction for running concurrent tasks in parallel by an executor executor workers can be OpenMP threads, std::thread.

Note: it is not related to the executor that C++ standard is working on currently.

Construct with num_tasks to run then call operator(F, args...) F is lambda or function with form void F(int task_id, args...) [](int task_id, args...){...}

This has not been tested for nested threading with openmp It is not intended for use below the top level of openmp threading.

Definition at line 35 of file ParallelExecutor.hpp.

Member Function Documentation

operator()() [1/3]

void operator()	(	int	num_tasks,
		F &&	f,
		Args &&...	args
	)

implements parallel tasks executed by threads in an OpenMP thread pool.

This specialization throws below the top openmp theading level exception must be caught at thread level or terminate is called.

Definition at line 37 of file ParallelExecutorOPENMP.hpp.

References omp_get_level().

{
  const std::string nesting_error{"ParallelExecutor should not be used for nested openmp threading\n"};
  if (omp_get_level() > 0)
    throw std::runtime_error(nesting_error);
  int nested_throw_count = 0;
  int throw_count        = 0;
#pragma omp parallel for reduction(+ : nested_throw_count, throw_count)
  for (int task_id = 0; task_id < num_tasks; ++task_id)
  {
    try
    {
      f(task_id, std::forward<Args>(args)...);
    }
    catch (const std::runtime_error& re)
    {
      if (nesting_error == re.what())
        ++nested_throw_count;
      else
      {
        std::cerr << re.what() << std::flush;
        ++throw_count;
      }
    }
    catch (...)
    {
      ++throw_count;
    }
  }
  if (throw_count > 0)
    throw std::runtime_error("Unexpected exception thrown in threaded section");
  else if (nested_throw_count > 0)
    throw std::runtime_error(nesting_error);
}

operator()() [2/3]

void operator()	(	int	num_tasks,
		F &&	f,
		Args &&...	args
	)

Concurrently execute an arbitrary function/kernel with task id and arbitrary args.

ie each task will run f(int task_id, Args... args)

operator()() [3/3]

void operator()	(	int	num_tasks,
		F &&	f,
		Args &&...	args
	)

implements parallel tasks executed by STD threads.

One task one thread mapping.

Definition at line 50 of file ParallelExecutorSTD.hpp.

{
  std::vector<std::thread> threads(num_tasks_);

  for (int task_id = 0; task_id < num_tasks; ++task_id)
  {
    threads[task_id] = std::thread(TaskWrapper<F>{std::forward<F>(f)}, task_id, std::forward<Args>(args)...);
  }

  for (int task_id = 0; task_id < num_tasks; ++task_id)
  {
    threads[task_id].join();
  }
}

---

The documentation for this class was generated from the following file:

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Concurrency/ParallelExecutor.hpp