Eigen::ForkJoinScheduler Class Reference

#include <ForkJoin.h>

Static Public Member Functions
template<typename DoFnType >
static void	ParallelForAsync (int start, int end, int granularity, DoFnType do_func, std::function< void()> done, Eigen::ThreadPool *thread_pool)
template<typename DoFnType >
static void	ParallelFor (int start, int end, int granularity, DoFnType do_func, Eigen::ThreadPool *thread_pool)

Static Private Member Functions
template<typename LeftType , typename RightType >
static void	ForkJoin (LeftType &&left_thunk, RightType &&right_thunk, Eigen::ThreadPool *thread_pool)
static void	RunParallelForAsync (int start, int end, int granularity, std::function< void(int)> &do_func, std::function< void()> &done, Eigen::ThreadPool *thread_pool)
static void	RunParallelForAsync (int start, int end, int granularity, std::function< void(int, int)> &do_func, std::function< void()> &done, Eigen::ThreadPool *thread_pool)

Member Function Documentation

ForkJoin()

template<typename LeftType , typename RightType >

static void Eigen::ForkJoinScheduler::ForkJoin ( LeftType &&  left_thunk, RightType &&  right_thunk, Eigen::ThreadPool *  thread_pool  )

inlinestaticprivate

                                                                                                     {
    std::atomic<bool> right_done(false);
    auto execute_right = [&right_thunk, &right_done]() {
      std::forward<RightType>(right_thunk)();
      right_done.store(true, std::memory_order_release);
    };
    thread_pool->Schedule(execute_right);
    std::forward<LeftType>(left_thunk)();
    Eigen::ThreadPool::Task task;
    while (!right_done.load(std::memory_order_acquire)) {
      thread_pool->MaybeGetTask(&task);
      if (task.f) task.f();
    }
  }

References Eigen::ThreadPoolTempl< Environment >::MaybeGetTask(), and Eigen::ThreadPoolTempl< Environment >::Schedule().

Referenced by RunParallelForAsync().

ParallelFor()

template<typename DoFnType >

static void Eigen::ForkJoinScheduler::ParallelFor ( int  start, int  end, int  granularity, DoFnType  do_func, Eigen::ThreadPool *  thread_pool  )

inlinestatic

                                                                                                               {
    if (start >= end) return;
    auto dummy_done = []() {};
    Barrier barrier(1);
    thread_pool->Schedule([start, end, granularity, thread_pool, &do_func, &dummy_done, &barrier]() {
      ForkJoinScheduler::ParallelForAsync(start, end, granularity, do_func, dummy_done, thread_pool);
      barrier.Notify();
    });
    barrier.Wait();
  }

References Eigen::placeholders::end, Eigen::Barrier::Notify(), ParallelForAsync(), Eigen::ThreadPoolTempl< Environment >::Schedule(), oomph::CumulativeTimings::start(), and Eigen::Barrier::Wait().

ParallelForAsync()

template<typename DoFnType >

static void Eigen::ForkJoinScheduler::ParallelForAsync ( int  start, int  end, int  granularity, DoFnType  do_func, std::function< void()>  done, Eigen::ThreadPool *  thread_pool  )

inlinestatic

                                                             {
    if (start >= end) {
      done();
      return;
    }
    ForkJoinScheduler::RunParallelForAsync(start, end, granularity, do_func, done, thread_pool);
  }

References Eigen::placeholders::end, RunParallelForAsync(), and oomph::CumulativeTimings::start().

Referenced by ParallelFor().

RunParallelForAsync() [1/2]

static void Eigen::ForkJoinScheduler::RunParallelForAsync ( int  start, int  end, int  granularity, std::function< void(int)> &  do_func, std::function< void()> &  done, Eigen::ThreadPool *  thread_pool  )

inlinestaticprivate

                                                                                           {
    std::function<void(int, int)> wrapped_do_func = [&do_func](int start, int end) {
      for (int i = start; i < end; ++i) do_func(i);
    };
    ForkJoinScheduler::RunParallelForAsync(start, end, granularity, wrapped_do_func, done, thread_pool);
  }

References Eigen::placeholders::end, i, and oomph::CumulativeTimings::start().

Referenced by ParallelForAsync(), and RunParallelForAsync().

RunParallelForAsync() [2/2]

static void Eigen::ForkJoinScheduler::RunParallelForAsync ( int  start, int  end, int  granularity, std::function< void(int, int)> &  do_func, std::function< void()> &  done, Eigen::ThreadPool *  thread_pool  )

inlinestaticprivate

                                                                                           {
    if ((end - start) <= granularity) {
      do_func(start, end);
      for (int j = 0; j < end - start; ++j) done();
    } else {
      // Typical workloads choose initial values of `{start, end, granularity}` such that `start - end` and
      // `granularity` are powers of two. Since modern processors usually implement (2^x)-way
      // set-associative caches, we minimize the number of cache misses by choosing midpoints that are not
      // powers of two (to avoid having two addresses in the main memory pointing to the same point in the
      // cache). More specifically, we restrict the set of candidate midpoints to:
      //
      //   P := {start, start + granularity, start + 2*granularity, ..., end},
      //
      // and choose the entry in `P` at (roughly) the 9/16 mark.
      const int size = end - start;
      const int mid = start + Eigen::numext::div_ceil(9 * (size + 1) / 16, granularity) * granularity;
      ForkJoinScheduler::ForkJoin(
          [start, mid, granularity, &do_func, &done, thread_pool]() {
            RunParallelForAsync(start, mid, granularity, do_func, done, thread_pool);
          },
          [mid, end, granularity, &do_func, &done, thread_pool]() {
            RunParallelForAsync(mid, end, granularity, do_func, done, thread_pool);
          },
          thread_pool);
    }
  }

References Eigen::numext::div_ceil(), Eigen::placeholders::end, ForkJoin(), j, RunParallelForAsync(), size, and oomph::CumulativeTimings::start().

---

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

• ForkJoin.h