dynamic_execution.h

Go to the documentation of this file.

#ifndef GRPPI_DYN_DYNAMIC_EXECUTION_H
#define GRPPI_DYN_DYNAMIC_EXECUTION_H

#include "../seq/sequential_execution.h"
#include "../native/parallel_execution_native.h"
#include "../tbb/parallel_execution_tbb.h"
#include "../omp/parallel_execution_omp.h"
#include "../ff/parallel_execution_ff.h"

#include <memory>

namespace grppi{

class dynamic_execution {
public:

  dynamic_execution() noexcept :
    execution_{}
  {}

  template <typename E>
  dynamic_execution(const E & e) : execution_{std::make_unique<execution<E>>(e)} {}

  bool has_execution() const { return execution_.get() != nullptr; }

  template <typename ... InputIterators, typename OutputIterator, 
            typename Transformer>
  void map(std::tuple<InputIterators...> firsts,
          OutputIterator first_out, std::size_t sequence_size, 
          Transformer && transform_op) const;
  
  template <typename InputIterator, typename Identity, typename Combiner>
  auto reduce(InputIterator first, std::size_t sequence_size,
          Identity && identity,
          Combiner && combine_op) const;

  template <typename ... InputIterators, typename Identity, 
            typename Transformer, typename Combiner>
  auto map_reduce(std::tuple<InputIterators...> firsts, 
          std::size_t sequence_size,
          Identity && identity,
          Transformer && transform_op, Combiner && combine_op) const;

  template <typename ... InputIterators, typename OutputIterator,
            typename StencilTransformer, typename Neighbourhood>
  void stencil(std::tuple<InputIterators...> firsts, OutputIterator first_out,
          std::size_t sequence_size,
          StencilTransformer && transform_op,
          Neighbourhood && neighbour_op) const;

  template <typename Input, typename Divider, typename Solver, typename Combiner>
  [[deprecated("Use new interface with predicate argument")]]
  auto divide_conquer(Input && input, 
                      Divider && divide_op, 
                      Solver && solve_op, 
                      Combiner && combine_op) const; 


  template <typename Input, typename Divider, typename Predicate, typename Solver, typename Combiner>
  auto divide_conquer(Input && input,
                      Divider && divide_op,
                      Predicate && predicate_op,
                      Solver && solve_op,
                      Combiner && combine_op) const;


  template <typename Generator, typename ... Transformers>
  void pipeline(Generator && generate_op, 
          Transformers && ... transform_ops) const;

private:

  class execution_base {
  public:
    virtual ~execution_base() {};
  };

  template <typename E>
  class execution : public execution_base {
  public:
    execution(const E & e) : ex_{e} {}
    virtual ~execution() = default;
    E ex_;
  };

private:
  std::unique_ptr<execution_base> execution_;

};

template <>
constexpr bool is_supported<dynamic_execution>() { return true; }

template <>
constexpr bool supports_map<dynamic_execution>() { return true; }

template <>
constexpr bool supports_reduce<dynamic_execution>() { return true; }

template <>
constexpr bool supports_map_reduce<dynamic_execution>() { return true; }

template <>
constexpr bool supports_stencil<dynamic_execution>() { return true; }

template <>
constexpr bool supports_divide_conquer<dynamic_execution>() { return true; }

template <>
constexpr bool supports_pipeline<dynamic_execution>() { return true; }



#define GRPPI_TRY_PATTERN(E,PATTERN,...)\
{\
  if (supports_##PATTERN<E>()) {\
    auto * ex = dynamic_cast<execution<E>*>(execution_.get());\
    if (ex) {\
      return ex->ex_.PATTERN(__VA_ARGS__);\
    }\
  }\
}

#define GRPPI_PATTERN_NOT_IMPLEMENTED(PATTERN,...)\
throw std::runtime_error{"Pattern " #PATTERN " not implemented"};

#ifdef GRPPI_OMP
#define GRPPI_TRY_PATTERN_OMP(PATTERN,...) \
GRPPI_TRY_PATTERN(parallel_execution_omp,PATTERN,__VA_ARGS__)
#else
#define GRPPI_TRY_PATTERN_OMP(PATTERN,...)
#endif

#ifdef GRPPI_TBB
#define GRPPI_TRY_PATTERN_TBB(PATTERN,...) \
GRPPI_TRY_PATTERN(parallel_execution_tbb,PATTERN,__VA_ARGS__)
#else
#define GRPPI_TRY_PATTERN_TBB(PATTERN,...)
#endif

#ifdef GRPPI_FF
#define GRPPI_TRY_PATTERN_FF(PATTERN,...) \
GRPPI_TRY_PATTERN(parallel_execution_ff,PATTERN,__VA_ARGS__)
#else
#define GRPPI_TRY_PATTERN_FF(PATTERN,...)
#endif

#define GRPPI_TRY_PATTERN_ALL(...) \
GRPPI_TRY_PATTERN(sequential_execution, __VA_ARGS__) \
GRPPI_TRY_PATTERN(parallel_execution_native, __VA_ARGS__) \
GRPPI_TRY_PATTERN_OMP(__VA_ARGS__) \
GRPPI_TRY_PATTERN_TBB(__VA_ARGS__) \
GRPPI_TRY_PATTERN_FF(__VA_ARGS__) \
GRPPI_PATTERN_NOT_IMPLEMENTED(__VA_ARGS__)\

#define GRPPI_TRY_PATTERN_ALL_NOFF(...) \
GRPPI_TRY_PATTERN(sequential_execution, __VA_ARGS__) \
GRPPI_TRY_PATTERN(parallel_execution_native, __VA_ARGS__) \
GRPPI_TRY_PATTERN_OMP(__VA_ARGS__) \
GRPPI_TRY_PATTERN_TBB(__VA_ARGS__) \
GRPPI_PATTERN_NOT_IMPLEMENTED(__VA_ARGS__)\

template <typename ... InputIterators, typename OutputIterator, 
          typename Transformer>
void dynamic_execution::map(
    std::tuple<InputIterators...> firsts,
    OutputIterator first_out, 
    std::size_t sequence_size, 
    Transformer && transform_op) const 
{
  GRPPI_TRY_PATTERN_ALL(map, firsts, first_out, sequence_size, 
      std::forward<Transformer>(transform_op));
}

template <typename InputIterator, typename Identity, typename Combiner>
auto dynamic_execution::reduce(InputIterator first, std::size_t sequence_size,
          Identity && identity,
          Combiner && combine_op) const
{
  GRPPI_TRY_PATTERN_ALL(reduce, first, sequence_size, 
      std::forward<Identity>(identity), std::forward<Combiner>(combine_op));
}

template <typename ... InputIterators, typename Identity, 
          typename Transformer, typename Combiner>
auto dynamic_execution::map_reduce(
    std::tuple<InputIterators...> firsts, 
    std::size_t sequence_size,
    Identity && identity,
    Transformer && transform_op, 
    Combiner && combine_op) const
{
  GRPPI_TRY_PATTERN_ALL(map_reduce, firsts, sequence_size, 
      std::forward<Identity>(identity), 
      std::forward<Transformer>(transform_op),
      std::forward<Combiner>(combine_op));
}

template <typename ... InputIterators, typename OutputIterator,
          typename StencilTransformer, typename Neighbourhood>
void dynamic_execution::stencil(
    std::tuple<InputIterators...> firsts, 
    OutputIterator first_out,
    std::size_t sequence_size,
    StencilTransformer && transform_op,
    Neighbourhood && neighbour_op) const
{
  GRPPI_TRY_PATTERN_ALL(stencil, firsts, first_out, sequence_size,
      std::forward<StencilTransformer>(transform_op),
      std::forward<Neighbourhood>(neighbour_op));
}

template <typename Input, typename Divider, typename Solver, typename Combiner>
auto dynamic_execution::divide_conquer(
    Input && input, 
    Divider && divide_op, 
    Solver && solve_op, 
    Combiner && combine_op) const
{
  GRPPI_TRY_PATTERN_ALL_NOFF(divide_conquer, std::forward<Input>(input),
      std::forward<Divider>(divide_op),
      std::forward<Solver>(solve_op),
      std::forward<Combiner>(combine_op));
}


template <typename Input, typename Divider,typename Predicate, typename Solver, typename Combiner>
auto dynamic_execution::divide_conquer(
    Input && input,
    Divider && divide_op,
    Predicate && predicate_op,
    Solver && solve_op,
    Combiner && combine_op) const
{
  GRPPI_TRY_PATTERN_ALL(divide_conquer, std::forward<Input>(input),
      std::forward<Divider>(divide_op),
      std::forward<Predicate>(predicate_op),
      std::forward<Solver>(solve_op),
      std::forward<Combiner>(combine_op));
}

template <typename Generator, typename ... Transformers>
void dynamic_execution::pipeline(
    Generator && generate_op, 
    Transformers && ... transform_ops) const
{
  GRPPI_TRY_PATTERN_ALL(pipeline, std::forward<Generator>(generate_op),
      std::forward<Transformers>(transform_ops)...);
}

#undef GRPPI_TRY_PATTERN
#undef GRPPI_TRY_PATTERN_OMP
#undef GRPPI_TRY_PATTERN_TBB
#undef GRPPI_TRY_PATTERN_ALL
#undef GRPPI_TRY_PATTERN_ALL_NOFF

} // end namespace grppi

#endif