poly/divideconquer.h

Go to the documentation of this file.

#ifndef GRPPI_POLY_DIVIDECONQUER_H
#define GRPPI_POLY_DIVIDECONQUER_H

#include "polymorphic_execution.h"
#include "../common/support.h"

namespace grppi {

template <typename Input, typename Divider, typename Solver, typename Combiner>
typename std::result_of<Solver(Input)>::type 
divide_conquer_multi_impl(polymorphic_execution & ex, 
                              Input & input, 
                              Divider && divide_op, Solver && solve_op, 
                              Combiner && combine_op)
{
  return {};
}

template <typename E, typename ... O,
          typename Input, typename Divider, typename Solver, typename Combiner,
          internal::requires_execution_not_supported<E> = 0>
typename std::result_of<Solver(Input)>::type 
divide_conquer_multi_impl(polymorphic_execution & ex, 
                              Input & input, 
                              Divider && divide_op, Solver && solve_op, 
                              Combiner && combine_op) 
{
  return divide_conquer_multi_impl<O...>(ex, input,  
      std::forward<Divider>(divide_op), std::forward<Solver>(solve_op),
      std::forward<Combiner>(combine_op) );
}

template <typename E, typename ... O,
          typename Input, typename Divider, typename Solver, typename Combiner,
          internal::requires_execution_supported<E> = 0>
typename std::result_of<Solver(Input)>::type 
divide_conquer_multi_impl(polymorphic_execution & ex, 
                              Input & input, 
                              Divider && divide_op, Solver && solve_op, 
                              Combiner && combine_op) 
{
  if (typeid(E) == ex.type()) {
    return divide_conquer(*ex.execution_ptr<E>(), 
        input, 
        std::forward<Divider>(divide_op), std::forward<Solver>(solve_op),
        std::forward<Combiner>(combine_op));
  }
  else {
    return divide_conquer_multi_impl<O...>(ex, input,  
        std::forward<Divider>(divide_op), std::forward<Solver>(solve_op),
        std::forward<Combiner>(combine_op));
  }
}

template <typename Input, typename Divider, typename Solver, typename Combiner>
typename std::result_of<Solver(Input)>::type 
divide_conquer(polymorphic_execution & ex, 
                   Input & input, 
                   Divider && divide_op, Solver && solve_op, 
                   Combiner && combine_op) 
{
  return divide_conquer_multi_impl<
    sequential_execution,
    parallel_execution_native,
    parallel_execution_omp,
    parallel_execution_tbb
  >(ex, input,  
      std::forward<Divider>(divide_op), std::forward<Solver>(solve_op),
      std::forward<Combiner>(combine_op));
}

} // end namespace grppi

#endif