GrPPI  0.2
Generic and Reusable Parallel Pattern Interface
poly/farm.h
Go to the documentation of this file.
1 
22 #ifndef GRPPI_POLY_FARM_H
23 #define GRPPI_POLY_FARM_H
24 
25 #include "polymorphic_execution.h"
26 #include "../common/support.h"
27 
28 namespace grppi {
29 
30 template <typename Generator, typename Consumer>
31 void farm_multi_impl(polymorphic_execution & ex, Generator generate_op,
32  Consumer consume_op)
33 {
34 }
35 
36 
37 template <typename Generator, typename Transformer, typename Consumer>
38 void farm_multi_impl(polymorphic_execution & ex, Generator generate_op,
39  Transformer transform_op, Consumer consume_op)
40 {
41 }
42 
43 template <typename E, typename ... O, typename Generator, typename Transformer,
44  internal::requires_execution_not_supported<E> = 0>
45 void farm_multi_impl(polymorphic_execution & ex, Generator && generate_op,
46  Transformer && transform_op)
47 {
48  farm_multi_impl<O...>(ex, std::forward<Generator>(generate_op),
49  std::forward<Transformer>(transform_op));
50 }
51 
52 template <typename E, typename ... O, typename Generator, typename Transformer,
53  typename Consumer,
54  internal::requires_execution_not_supported<E> = 0>
55 void farm_multi_impl(polymorphic_execution & ex, Generator && generate_op,
56  Transformer && transform_op, Consumer && consume_op)
57 {
58  farm_multi_impl<O...>(ex, std::forward<Generator>(generate_op),
59  std::forward<Transformer>(transform_op),
60  std::forward<Consumer>(consume_op));
61 }
62 
63 
64 
65 template <typename E, typename ... O, typename Generator, typename Consumer,
66  internal::requires_execution_supported<E> = 0>
67 void farm_multi_impl(polymorphic_execution & ex, Generator && generate_op,
68  Consumer && consume_op)
69 {
70  if (typeid(E) == ex.type()) {
71  farm(*ex.execution_ptr<E>(), std::forward<Generator>(generate_op),
72  std::forward<Consumer>(consume_op));
73  }
74  else {
75  farm_multi_impl<O...>(ex, std::forward<Generator>(generate_op),
76  std::forward<Consumer>(consume_op));
77  }
78 }
79 
80 
81 template <typename E, typename ... O, typename Generator, typename Transformer, typename Consumer,
82  internal::requires_execution_supported<E> = 0>
83 void farm_multi_impl(polymorphic_execution & ex, Generator && generate_op,
84  Transformer && transform_op, Consumer && consume_op)
85 {
86  if (typeid(E) == ex.type()) {
87  farm(*ex.execution_ptr<E>(), std::forward<Generator>(generate_op),
88  std::forward<Transformer>(transform_op),
89  std::forward<Consumer>(consume_op));
90  }
91  else {
92  farm_multi_impl<O...>(ex, std::forward<Generator>(generate_op),
93  std::forward<Transformer>(transform_op),
94  std::forward<Consumer>(consume_op));
95  }
96 }
97 
98 
116 template <typename Generator, typename Consumer>
117 void farm(polymorphic_execution & ex, Generator && generate_op,
118  Consumer && consume_op)
119 {
120  farm_multi_impl<
121  sequential_execution,
122  parallel_execution_native,
123  parallel_execution_omp,
124  parallel_execution_tbb
125  >(ex, std::forward<Generator>(generate_op),
126  std::forward<Consumer>(consume_op));
127 }
128 
140 template <typename Generator, typename Transformer, typename Consumer>
141 void farm(polymorphic_execution & ex, Generator && generate_op,
142  Transformer && transform_op, Consumer && consume_op)
143 {
144  farm_multi_impl<
145  sequential_execution,
146  parallel_execution_native,
147  parallel_execution_omp,
148  parallel_execution_tbb
149  >(ex, std::forward<Generator>(generate_op),
150  std::forward<Transformer>(transform_op),
151  std::forward<Consumer>(consume_op));
152 }
153 
154 } // end namespace grppi
155 
156 #endif
grppi
Definition: callable_traits.h:24
grppi::parallel_execution_native
Native parallel execution policy. This policy uses ISO C++ threads as implementation building block a...
Definition: parallel_execution_native.h:136
grppi::polymorphic_execution::type
const std::type_info & type() const noexcept
Definition: polymorphic_execution.h:77
polymorphic_execution.h
grppi::internal::requires_execution_supported
std::enable_if_t< is_supported< E >(), int > requires_execution_supported
Definition: support.h:32
grppi::parallel_execution_omp
OpenMP parallel execution policy.
Definition: parallel_execution_omp.h:40
grppi::parallel_execution_tbb
TBB parallel execution policy.
Definition: parallel_execution_tbb.h:37
grppi::polymorphic_execution::execution_ptr
E * execution_ptr()
Get the execution pointer for a given type.
Definition: polymorphic_execution.h:91
grppi::sequential_execution
Sequential execution policy.
Definition: sequential_execution.h:31
grppi::polymorphic_execution
Definition: polymorphic_execution.h:63
grppi::farm
auto farm(Execution &ex, Transformer &&transform_op)
Invoke Farm pattern on a data stream that can be composed in other streaming patterns.
Definition: farm.h:51
grppi::internal::requires_execution_not_supported
std::enable_if_t<!is_supported< E >(), int > requires_execution_not_supported
Definition: support.h:36
grppi::farm_multi_impl
void farm_multi_impl(polymorphic_execution &ex, Generator generate_op, Consumer consume_op)
Definition: poly/farm.h:31
Generated by   doxygen 1.8.11