21 #ifndef __TBB__flow_graph_join_impl_H 22 #define __TBB__flow_graph_join_impl_H 24 #ifndef __TBB_flow_graph_H 25 #error Do not #include this internal file directly; use public TBB headers instead. 43 template<
typename KeyType>
54 template<
typename TupleType,
typename PortType >
59 template<
typename TupleType >
61 tbb::flow::get<N-1>( my_input ).consume();
65 template<
typename TupleType >
67 tbb::flow::get<N-1>( my_input ).
release();
70 template <
typename TupleType>
76 template<
typename InputTuple,
typename OutputTuple >
77 static inline bool reserve( InputTuple &my_input, OutputTuple &out) {
78 if ( !tbb::flow::get<N-1>( my_input ).
reserve( tbb::flow::get<N-1>( out ) ) )
return false;
86 template<
typename InputTuple,
typename OutputTuple>
87 static inline bool get_my_item( InputTuple &my_input, OutputTuple &out) {
88 bool res = tbb::flow::get<N-1>(my_input).get_item(tbb::flow::get<N-1>(out) );
92 template<
typename InputTuple,
typename OutputTuple>
93 static inline bool get_items(InputTuple &my_input, OutputTuple &out) {
97 template<
typename InputTuple>
100 tbb::flow::get<N-1>(my_input).reset_port();
103 template<
typename InputTuple>
108 template<
typename InputTuple,
typename KeyFuncTuple>
110 tbb::flow::get<N-1>(my_input).set_my_key_func(tbb::flow::get<N-1>(my_key_funcs));
111 tbb::flow::get<N-1>(my_key_funcs) = NULL;
115 template<
typename KeyFuncTuple>
117 if(tbb::flow::get<N-1>(other_inputs).get_my_key_func()) {
118 tbb::flow::get<N-1>(my_inputs).set_my_key_func(tbb::flow::get<N-1>(other_inputs).get_my_key_func()->clone());
123 template<
typename InputTuple>
126 tbb::flow::get<N-1>(my_input).reset_receiver(f);
129 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 130 template<
typename InputTuple>
131 static inline void extract_inputs(InputTuple &my_input) {
133 tbb::flow::get<N-1>(my_input).extract_receiver();
141 template<
typename TupleType,
typename PortType >
143 tbb::flow::get<0>( my_input ).set_join_node_pointer(port);
146 template<
typename TupleType >
148 tbb::flow::get<0>( my_input ).consume();
151 template<
typename TupleType >
153 tbb::flow::get<0>( my_input ).release();
156 template<
typename TupleType>
161 template<
typename InputTuple,
typename OutputTuple >
162 static inline bool reserve( InputTuple &my_input, OutputTuple &out) {
163 return tbb::flow::get<0>( my_input ).reserve( tbb::flow::get<0>( out ) );
166 template<
typename InputTuple,
typename OutputTuple>
167 static inline bool get_my_item( InputTuple &my_input, OutputTuple &out) {
168 return tbb::flow::get<0>(my_input).get_item(tbb::flow::get<0>(out));
171 template<
typename InputTuple,
typename OutputTuple>
172 static inline bool get_items(InputTuple &my_input, OutputTuple &out) {
176 template<
typename InputTuple>
178 tbb::flow::get<0>(my_input).reset_port();
181 template<
typename InputTuple>
186 template<
typename InputTuple,
typename KeyFuncTuple>
188 tbb::flow::get<0>(my_input).set_my_key_func(tbb::flow::get<0>(my_key_funcs));
189 tbb::flow::get<0>(my_key_funcs) = NULL;
192 template<
typename KeyFuncTuple>
194 if(tbb::flow::get<0>(other_inputs).get_my_key_func()) {
195 tbb::flow::get<0>(my_inputs).set_my_key_func(tbb::flow::get<0>(other_inputs).get_my_key_func()->clone());
198 template<
typename InputTuple>
200 tbb::flow::get<0>(my_input).reset_receiver(f);
203 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 204 template<
typename InputTuple>
205 static inline void extract_inputs(InputTuple &my_input) {
206 tbb::flow::get<0>(my_input).extract_receiver();
212 template<
typename T >
217 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 218 typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
219 typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
224 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 225 , add_blt_pred, del_blt_pred, blt_pred_cnt, blt_pred_cpy
237 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 239 predecessor_list_type *plist;
249 typedef internal::aggregating_functor<class_type, reserving_port_operation>
handler_type;
255 bool no_predecessors;
258 op_list = op_list->next;
259 switch(current->
type) {
263 if ( no_predecessors ) {
297 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 385 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 388 reserving_port_operation op_data(src, add_blt_pred);
393 reserving_port_operation op_data(src, del_blt_pred);
398 reserving_port_operation op_data(blt_pred_cnt);
400 return op_data.cnt_val;
404 reserving_port_operation op_data(blt_pred_cpy);
409 void extract_receiver() {
436 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 437 typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
438 typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
444 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 445 , add_blt_pred, del_blt_pred, blt_pred_cnt, blt_pred_cpy
455 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 458 predecessor_list_type *plist;
477 typedef internal::aggregating_functor<class_type, queueing_port_operation>
handler_type;
486 op_list = op_list->next;
487 switch(current->
type) {
516 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 518 my_built_predecessors.add_edge(*(current->pred));
522 my_built_predecessors.delete_edge(*(current->pred));
526 current->cnt_val = my_built_predecessors.edge_count();
530 my_built_predecessors.copy_edges(*(current->plist));
588 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 589 built_predecessors_type &built_predecessors()
__TBB_override {
return my_built_predecessors; }
592 queueing_port_operation op_data(add_blt_pred);
598 queueing_port_operation op_data(del_blt_pred);
604 queueing_port_operation op_data(blt_pred_cnt);
606 return op_data.cnt_val;
610 queueing_port_operation op_data(blt_pred_cpy);
615 void extract_receiver() {
617 my_built_predecessors.receiver_extract(*
this);
624 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 626 my_built_predecessors.clear();
632 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 633 edge_container<predecessor_type> my_built_predecessors;
647 template<
typename K >
655 template<
class TraitsType >
657 public receiver<typename TraitsType::T>,
658 public hash_buffer< typename TraitsType::K, typename TraitsType::T, typename TraitsType::TtoK,
659 typename TraitsType::KHash > {
670 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 671 typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
672 typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
678 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 679 , add_blt_pred, del_blt_pred, blt_pred_cnt, blt_pred_cpy
689 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 692 predecessor_list_type *plist;
704 typedef internal::aggregating_functor<class_type, key_matching_port_operation>
handler_type;
712 op_list = op_list->next;
713 switch(current->
type) {
723 __TBB_ASSERT(
false,
"Failed to find item corresponding to current_key.");
732 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 734 my_built_predecessors.add_edge(*(current->pred));
738 my_built_predecessors.delete_edge(*(current->pred));
742 current->cnt_val = my_built_predecessors.edge_count();
746 my_built_predecessors.copy_edges(*(current->plist));
804 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 805 built_predecessors_type &built_predecessors()
__TBB_override {
return my_built_predecessors; }
808 key_matching_port_operation op_data(add_blt_pred);
814 key_matching_port_operation op_data(del_blt_pred);
820 key_matching_port_operation op_data(blt_pred_cnt);
822 return op_data.cnt_val;
826 key_matching_port_operation op_data(blt_pred_cpy);
840 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 841 void extract_receiver() {
843 my_built_predecessors.receiver_extract(*
this);
849 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 851 my_built_predecessors.clear();
859 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 860 edge_container<predecessor_type> my_built_predecessors;
864 using namespace graph_policy_namespace;
866 template<
typename JP,
typename InputTuple,
typename OutputTuple>
870 template<
typename JP,
typename InputTuple,
typename OutputTuple>
873 template<
typename InputTuple,
typename OutputTuple>
882 ports_with_no_inputs = N;
887 ports_with_no_inputs = N;
894 ++ports_with_no_inputs;
899 if(ports_with_no_inputs.fetch_and_decrement() == 1) {
901 task *rtask =
new ( task::allocate_additional_child_of( *(this->graph_ref.root_task()) ) )
903 if(!handle_task)
return rtask;
916 ports_with_no_inputs = N;
920 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 923 ports_with_no_inputs = N;
931 return !ports_with_no_inputs;
935 if(ports_with_no_inputs)
return false;
951 template<
typename InputTuple,
typename OutputTuple>
960 ports_with_no_items = N;
965 ports_with_no_items = N;
973 ports_with_no_items = N;
979 if(ports_with_no_items.fetch_and_decrement() == 1) {
981 task *rtask =
new ( task::allocate_additional_child_of( *(this->graph_ref.root_task()) ) )
983 if(!handle_task)
return rtask;
1001 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1010 return !ports_with_no_items;
1014 if(ports_with_no_items)
return false;
1032 template<
typename InputTuple,
typename OutputTuple,
typename K,
typename KHash>
1036 typename tbb::internal::strip<K>::type&,
1037 count_element<typename tbb::internal::strip<K>::type>,
1038 internal::type_to_key_function_body<
1039 count_element<typename tbb::internal::strip<K>::type>,
1040 typename tbb::internal::strip<K>::type& >,
1069 enum op_type { res_count, inc_count, may_succeed, try_make };
1073 class key_matching_FE_operation :
public aggregated_operation<key_matching_FE_operation> {
1082 my_output(NULL), bypass_t(NULL), enqueue_task(q_task) {}
1084 enqueue_task(true) {}
1089 typedef internal::aggregating_functor<class_type, key_matching_FE_operation>
handler_type;
1090 friend class internal::aggregating_functor<
class_type, key_matching_FE_operation>;
1100 this->current_key = t;
1101 this->delete_with_key(this->current_key);
1103 this->push_back(l_out);
1105 rtask =
new ( task::allocate_additional_child_of( *(this->graph_ref.root_task()) ) )
1117 __TBB_ASSERT(
false,
"should have had something to push");
1123 key_matching_FE_operation *current;
1126 op_list = op_list->next;
1127 switch(current->type) {
1130 this->destroy_front();
1137 bool do_enqueue = current->enqueue_task;
1138 if(!(this->find_ref_with_key(t,
p))) {
1142 this->insert_with_key(ev);
1143 if(!(this->find_ref_with_key(t,
p))) {
1144 __TBB_ASSERT(
false,
"should find key after inserting it");
1147 if(++(
p->my_value) ==
size_t(N)) {
1148 task *rtask = fill_output_buffer(t,
true, do_enqueue);
1149 __TBB_ASSERT(!rtask || !do_enqueue,
"task should not be returned");
1150 current->bypass_t = rtask;
1159 if(this->buffer_empty()) {
1163 *(current->my_output) = this->front();
1173 template<
typename FunctionTuple>
1179 this->set_key_func(cfb);
1189 this->set_key_func(cfb);
1196 key_matching_FE_operation op_data(res_count);
1197 my_aggregator.execute(&op_data);
1204 key_matching_FE_operation op_data(t, handle_task, inc_count);
1205 my_aggregator.execute(&op_data);
1206 return op_data.bypass_t;
1221 key_to_count_buffer_type::reset();
1222 output_buffer_type::reset();
1225 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1229 key_to_count_buffer_type::reset();
1230 output_buffer_type::reset();
1237 key_matching_FE_operation op_data(may_succeed);
1238 my_aggregator.execute(&op_data);
1245 key_matching_FE_operation op_data(&out,try_make);
1246 my_aggregator.execute(&op_data);
1263 template<
typename JP,
typename InputTuple,
typename OutputTuple>
1265 public sender<OutputTuple> {
1267 using graph_node::my_graph;
1273 using input_ports_type::tuple_build_may_succeed;
1274 using input_ports_type::try_to_make_tuple;
1275 using input_ports_type::tuple_accepted;
1276 using input_ports_type::tuple_rejected;
1277 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1278 typedef typename sender<output_type>::built_successors_type built_successors_type;
1279 typedef typename sender<output_type>::successor_list_type successor_list_type;
1285 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1286 , add_blt_succ, del_blt_succ, blt_succ_cnt, blt_succ_cpy
1298 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1300 successor_list_type *slist;
1305 my_arg(const_cast<
output_type*>(&e)), bypass_t(NULL) {}
1311 typedef internal::aggregating_functor<class_type, join_node_base_operation>
handler_type;
1320 op_list = op_list->next;
1321 switch(current->
type) {
1323 my_successors.register_successor(*(current->
my_succ));
1325 task *rtask =
new ( task::allocate_additional_child_of(*(my_graph.root_task())) )
1329 forwarder_busy =
true;
1335 my_successors.remove_successor(*(current->
my_succ));
1339 if(tuple_build_may_succeed()) {
1340 if(try_to_make_tuple(*(current->
my_arg))) {
1348 case do_fwrd_bypass: {
1349 bool build_succeeded;
1350 task *last_task = NULL;
1352 if(tuple_build_may_succeed()) {
1354 build_succeeded = try_to_make_tuple(out);
1355 if(build_succeeded) {
1356 task *new_task = my_successors.try_put_task(out);
1363 build_succeeded =
false;
1366 }
while(build_succeeded);
1370 forwarder_busy =
false;
1373 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1375 my_successors.internal_add_built_successor(*(current->
my_succ));
1379 my_successors.internal_delete_built_successor(*(current->
my_succ));
1383 current->cnt_val = my_successors.successor_count();
1387 my_successors.copy_successors(*(current->slist));
1397 my_successors.set_owner(
this);
1398 input_ports_type::set_my_node(
this);
1404 sender<OutputTuple>(), forwarder_busy(false), my_successors() {
1405 my_successors.set_owner(
this);
1406 input_ports_type::set_my_node(
this);
1410 template<
typename FunctionTuple>
1412 my_successors.set_owner(
this);
1413 input_ports_type::set_my_node(
this);
1419 my_aggregator.execute(&op_data);
1425 my_aggregator.execute(&op_data);
1431 my_aggregator.execute(&op_data);
1435 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1436 built_successors_type &built_successors()
__TBB_override {
return my_successors.built_successors(); }
1438 void internal_add_built_successor( successor_type &r)
__TBB_override {
1439 join_node_base_operation op_data(r, add_blt_succ);
1440 my_aggregator.execute(&op_data);
1443 void internal_delete_built_successor( successor_type &r)
__TBB_override {
1444 join_node_base_operation op_data(r, del_blt_succ);
1445 my_aggregator.execute(&op_data);
1449 join_node_base_operation op_data(blt_succ_cnt);
1450 my_aggregator.execute(&op_data);
1451 return op_data.cnt_val;
1455 join_node_base_operation op_data(blt_succ_cpy);
1457 my_aggregator.execute(&op_data);
1461 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1463 input_ports_type::extract();
1464 my_successors.built_successors().sender_extract(*
this);
1471 input_ports_type::reset(f);
1481 my_aggregator.execute(&op_data);
1488 template<
int N,
template<
class>
class PT,
typename OutputTuple,
typename JP>
1493 template<
int N,
typename OutputTuple,
typename K,
typename KHash>
1508 template<
int N,
template<
class>
class PT,
typename OutputTuple,
typename JP>
1520 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1521 template <
typename K,
typename T>
1522 struct key_from_message_body {
1523 K operator()(
const T& t)
const {
1525 return key_from_message<K>(t);
1529 template <
typename K,
typename T>
1530 struct key_from_message_body<K&,T> {
1531 const K& operator()(
const T& t)
const {
1533 return key_from_message<const K&>(t);
1540 template<
typename OutputTuple,
typename K,
typename KHash>
1542 join_base<2,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1554 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1562 template<
typename Body0,
typename Body1>
1573 template<
typename OutputTuple,
typename K,
typename KHash>
1575 join_base<3,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1589 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1598 template<
typename Body0,
typename Body1,
typename Body2>
1610 template<
typename OutputTuple,
typename K,
typename KHash>
1612 join_base<4,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1628 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1638 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3>
1651 template<
typename OutputTuple,
typename K,
typename KHash>
1653 join_base<5,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1671 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1682 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3,
typename Body4>
1696 #if __TBB_VARIADIC_MAX >= 6 1697 template<
typename OutputTuple,
typename K,
typename KHash>
1698 class unfolded_join_node<6,key_matching_port,OutputTuple,
key_matching<K,KHash> > :
public 1699 join_base<6,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1707 typedef typename wrap_key_tuple_elements<6,key_matching_port,key_matching<K,KHash>,OutputTuple>
::type input_ports_type;
1708 typedef OutputTuple output_type;
1710 typedef join_node_base<key_matching<K,KHash> , input_ports_type, output_type > base_type;
1717 typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p > func_initializer_type;
1719 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1720 unfolded_join_node(graph &g) : base_type(g,
1721 func_initializer_type(
1722 new internal::type_to_key_function_body_leaf<T0, K, key_from_message_body<K,T0> >(key_from_message_body<K,T0>()),
1723 new internal::type_to_key_function_body_leaf<T1, K, key_from_message_body<K,T1> >(key_from_message_body<K,T1>()),
1724 new internal::type_to_key_function_body_leaf<T2, K, key_from_message_body<K,T2> >(key_from_message_body<K,T2>()),
1725 new internal::type_to_key_function_body_leaf<T3, K, key_from_message_body<K,T3> >(key_from_message_body<K,T3>()),
1726 new internal::type_to_key_function_body_leaf<T4, K, key_from_message_body<K,T4> >(key_from_message_body<K,T4>()),
1727 new internal::type_to_key_function_body_leaf<T5, K, key_from_message_body<K,T5> >(key_from_message_body<K,T5>())
1731 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3,
typename Body4,
typename Body5>
1732 unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3, Body4 body4, Body5 body5)
1733 : base_type(g, func_initializer_type(
1734 new internal::type_to_key_function_body_leaf<T0, K, Body0>(body0),
1735 new internal::type_to_key_function_body_leaf<T1, K, Body1>(body1),
1736 new internal::type_to_key_function_body_leaf<T2, K, Body2>(body2),
1737 new internal::type_to_key_function_body_leaf<T3, K, Body3>(body3),
1738 new internal::type_to_key_function_body_leaf<T4, K, Body4>(body4),
1739 new internal::type_to_key_function_body_leaf<T5, K, Body5>(body5)
1743 unfolded_join_node(
const unfolded_join_node &other) : base_type(other) {}
1747 #if __TBB_VARIADIC_MAX >= 7 1748 template<
typename OutputTuple,
typename K,
typename KHash>
1749 class unfolded_join_node<7,key_matching_port,OutputTuple,
key_matching<K,KHash> > :
public 1750 join_base<7,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1759 typedef typename wrap_key_tuple_elements<7,key_matching_port,key_matching<K,KHash>,OutputTuple>
::type input_ports_type;
1760 typedef OutputTuple output_type;
1762 typedef join_node_base<key_matching<K,KHash> , input_ports_type, output_type > base_type;
1770 typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p > func_initializer_type;
1772 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1773 unfolded_join_node(graph &g) : base_type(g,
1774 func_initializer_type(
1775 new internal::type_to_key_function_body_leaf<T0, K, key_from_message_body<K,T0> >(key_from_message_body<K,T0>()),
1776 new internal::type_to_key_function_body_leaf<T1, K, key_from_message_body<K,T1> >(key_from_message_body<K,T1>()),
1777 new internal::type_to_key_function_body_leaf<T2, K, key_from_message_body<K,T2> >(key_from_message_body<K,T2>()),
1778 new internal::type_to_key_function_body_leaf<T3, K, key_from_message_body<K,T3> >(key_from_message_body<K,T3>()),
1779 new internal::type_to_key_function_body_leaf<T4, K, key_from_message_body<K,T4> >(key_from_message_body<K,T4>()),
1780 new internal::type_to_key_function_body_leaf<T5, K, key_from_message_body<K,T5> >(key_from_message_body<K,T5>()),
1781 new internal::type_to_key_function_body_leaf<T6, K, key_from_message_body<K,T6> >(key_from_message_body<K,T6>())
1785 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3,
typename Body4,
1786 typename Body5,
typename Body6>
1787 unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3, Body4 body4,
1788 Body5 body5, Body6 body6) : base_type(g, func_initializer_type(
1789 new internal::type_to_key_function_body_leaf<T0, K, Body0>(body0),
1790 new internal::type_to_key_function_body_leaf<T1, K, Body1>(body1),
1791 new internal::type_to_key_function_body_leaf<T2, K, Body2>(body2),
1792 new internal::type_to_key_function_body_leaf<T3, K, Body3>(body3),
1793 new internal::type_to_key_function_body_leaf<T4, K, Body4>(body4),
1794 new internal::type_to_key_function_body_leaf<T5, K, Body5>(body5),
1795 new internal::type_to_key_function_body_leaf<T6, K, Body6>(body6)
1799 unfolded_join_node(
const unfolded_join_node &other) : base_type(other) {}
1803 #if __TBB_VARIADIC_MAX >= 8 1804 template<
typename OutputTuple,
typename K,
typename KHash>
1805 class unfolded_join_node<8,key_matching_port,OutputTuple,
key_matching<K,KHash> > :
public 1806 join_base<8,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1816 typedef typename wrap_key_tuple_elements<8,key_matching_port,key_matching<K,KHash>,OutputTuple>
::type input_ports_type;
1817 typedef OutputTuple output_type;
1819 typedef join_node_base<key_matching<K,KHash> , input_ports_type, output_type > base_type;
1828 typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p, f7_p > func_initializer_type;
1830 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1831 unfolded_join_node(graph &g) : base_type(g,
1832 func_initializer_type(
1833 new internal::type_to_key_function_body_leaf<T0, K, key_from_message_body<K,T0> >(key_from_message_body<K,T0>()),
1834 new internal::type_to_key_function_body_leaf<T1, K, key_from_message_body<K,T1> >(key_from_message_body<K,T1>()),
1835 new internal::type_to_key_function_body_leaf<T2, K, key_from_message_body<K,T2> >(key_from_message_body<K,T2>()),
1836 new internal::type_to_key_function_body_leaf<T3, K, key_from_message_body<K,T3> >(key_from_message_body<K,T3>()),
1837 new internal::type_to_key_function_body_leaf<T4, K, key_from_message_body<K,T4> >(key_from_message_body<K,T4>()),
1838 new internal::type_to_key_function_body_leaf<T5, K, key_from_message_body<K,T5> >(key_from_message_body<K,T5>()),
1839 new internal::type_to_key_function_body_leaf<T6, K, key_from_message_body<K,T6> >(key_from_message_body<K,T6>()),
1840 new internal::type_to_key_function_body_leaf<T7, K, key_from_message_body<K,T7> >(key_from_message_body<K,T7>())
1844 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3,
typename Body4,
1845 typename Body5,
typename Body6,
typename Body7>
1846 unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3, Body4 body4,
1847 Body5 body5, Body6 body6, Body7 body7) : base_type(g, func_initializer_type(
1848 new internal::type_to_key_function_body_leaf<T0, K, Body0>(body0),
1849 new internal::type_to_key_function_body_leaf<T1, K, Body1>(body1),
1850 new internal::type_to_key_function_body_leaf<T2, K, Body2>(body2),
1851 new internal::type_to_key_function_body_leaf<T3, K, Body3>(body3),
1852 new internal::type_to_key_function_body_leaf<T4, K, Body4>(body4),
1853 new internal::type_to_key_function_body_leaf<T5, K, Body5>(body5),
1854 new internal::type_to_key_function_body_leaf<T6, K, Body6>(body6),
1855 new internal::type_to_key_function_body_leaf<T7, K, Body7>(body7)
1859 unfolded_join_node(
const unfolded_join_node &other) : base_type(other) {}
1863 #if __TBB_VARIADIC_MAX >= 9 1864 template<
typename OutputTuple,
typename K,
typename KHash>
1865 class unfolded_join_node<9,key_matching_port,OutputTuple,
key_matching<K,KHash> > :
public 1866 join_base<9,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1877 typedef typename wrap_key_tuple_elements<9,key_matching_port,key_matching<K,KHash>,OutputTuple>
::type input_ports_type;
1878 typedef OutputTuple output_type;
1880 typedef join_node_base<key_matching<K,KHash> , input_ports_type, output_type > base_type;
1890 typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p, f7_p, f8_p > func_initializer_type;
1892 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1893 unfolded_join_node(graph &g) : base_type(g,
1894 func_initializer_type(
1895 new internal::type_to_key_function_body_leaf<T0, K, key_from_message_body<K,T0> >(key_from_message_body<K,T0>()),
1896 new internal::type_to_key_function_body_leaf<T1, K, key_from_message_body<K,T1> >(key_from_message_body<K,T1>()),
1897 new internal::type_to_key_function_body_leaf<T2, K, key_from_message_body<K,T2> >(key_from_message_body<K,T2>()),
1898 new internal::type_to_key_function_body_leaf<T3, K, key_from_message_body<K,T3> >(key_from_message_body<K,T3>()),
1899 new internal::type_to_key_function_body_leaf<T4, K, key_from_message_body<K,T4> >(key_from_message_body<K,T4>()),
1900 new internal::type_to_key_function_body_leaf<T5, K, key_from_message_body<K,T5> >(key_from_message_body<K,T5>()),
1901 new internal::type_to_key_function_body_leaf<T6, K, key_from_message_body<K,T6> >(key_from_message_body<K,T6>()),
1902 new internal::type_to_key_function_body_leaf<T7, K, key_from_message_body<K,T7> >(key_from_message_body<K,T7>()),
1903 new internal::type_to_key_function_body_leaf<T8, K, key_from_message_body<K,T8> >(key_from_message_body<K,T8>())
1907 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3,
typename Body4,
1908 typename Body5,
typename Body6,
typename Body7,
typename Body8>
1909 unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3, Body4 body4,
1910 Body5 body5, Body6 body6, Body7 body7, Body8 body8) : base_type(g, func_initializer_type(
1911 new internal::type_to_key_function_body_leaf<T0, K, Body0>(body0),
1912 new internal::type_to_key_function_body_leaf<T1, K, Body1>(body1),
1913 new internal::type_to_key_function_body_leaf<T2, K, Body2>(body2),
1914 new internal::type_to_key_function_body_leaf<T3, K, Body3>(body3),
1915 new internal::type_to_key_function_body_leaf<T4, K, Body4>(body4),
1916 new internal::type_to_key_function_body_leaf<T5, K, Body5>(body5),
1917 new internal::type_to_key_function_body_leaf<T6, K, Body6>(body6),
1918 new internal::type_to_key_function_body_leaf<T7, K, Body7>(body7),
1919 new internal::type_to_key_function_body_leaf<T8, K, Body8>(body8)
1923 unfolded_join_node(
const unfolded_join_node &other) : base_type(other) {}
1927 #if __TBB_VARIADIC_MAX >= 10 1928 template<
typename OutputTuple,
typename K,
typename KHash>
1929 class unfolded_join_node<10,key_matching_port,OutputTuple,
key_matching<K,KHash> > :
public 1930 join_base<10,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1942 typedef typename wrap_key_tuple_elements<10,key_matching_port,key_matching<K,KHash>,OutputTuple>
::type input_ports_type;
1943 typedef OutputTuple output_type;
1945 typedef join_node_base<key_matching<K,KHash> , input_ports_type, output_type > base_type;
1956 typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p, f7_p, f8_p, f9_p > func_initializer_type;
1958 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1959 unfolded_join_node(graph &g) : base_type(g,
1960 func_initializer_type(
1961 new internal::type_to_key_function_body_leaf<T0, K, key_from_message_body<K,T0> >(key_from_message_body<K,T0>()),
1962 new internal::type_to_key_function_body_leaf<T1, K, key_from_message_body<K,T1> >(key_from_message_body<K,T1>()),
1963 new internal::type_to_key_function_body_leaf<T2, K, key_from_message_body<K,T2> >(key_from_message_body<K,T2>()),
1964 new internal::type_to_key_function_body_leaf<T3, K, key_from_message_body<K,T3> >(key_from_message_body<K,T3>()),
1965 new internal::type_to_key_function_body_leaf<T4, K, key_from_message_body<K,T4> >(key_from_message_body<K,T4>()),
1966 new internal::type_to_key_function_body_leaf<T5, K, key_from_message_body<K,T5> >(key_from_message_body<K,T5>()),
1967 new internal::type_to_key_function_body_leaf<T6, K, key_from_message_body<K,T6> >(key_from_message_body<K,T6>()),
1968 new internal::type_to_key_function_body_leaf<T7, K, key_from_message_body<K,T7> >(key_from_message_body<K,T7>()),
1969 new internal::type_to_key_function_body_leaf<T8, K, key_from_message_body<K,T8> >(key_from_message_body<K,T8>()),
1970 new internal::type_to_key_function_body_leaf<T9, K, key_from_message_body<K,T9> >(key_from_message_body<K,T9>())
1974 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3,
typename Body4,
1975 typename Body5,
typename Body6,
typename Body7,
typename Body8,
typename Body9>
1976 unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3, Body4 body4,
1977 Body5 body5, Body6 body6, Body7 body7, Body8 body8, Body9 body9) : base_type(g, func_initializer_type(
1978 new internal::type_to_key_function_body_leaf<T0, K, Body0>(body0),
1979 new internal::type_to_key_function_body_leaf<T1, K, Body1>(body1),
1980 new internal::type_to_key_function_body_leaf<T2, K, Body2>(body2),
1981 new internal::type_to_key_function_body_leaf<T3, K, Body3>(body3),
1982 new internal::type_to_key_function_body_leaf<T4, K, Body4>(body4),
1983 new internal::type_to_key_function_body_leaf<T5, K, Body5>(body5),
1984 new internal::type_to_key_function_body_leaf<T6, K, Body6>(body6),
1985 new internal::type_to_key_function_body_leaf<T7, K, Body7>(body7),
1986 new internal::type_to_key_function_body_leaf<T8, K, Body8>(body8),
1987 new internal::type_to_key_function_body_leaf<T9, K, Body9>(body9)
1991 unfolded_join_node(
const unfolded_join_node &other) : base_type(other) {}
1996 template<
size_t N,
typename JNT>
1998 return tbb::flow::get<N>(jn.input_ports());
2002 #endif // __TBB__flow_graph_join_impl_H
internal::type_to_key_function_body< T2, K > * f2_p
tbb::flow::tuple_element< 1, OutputTuple >::type T1
virtual void increment_port_count()=0
static tbb::task *const SUCCESSFULLY_ENQUEUED
friend class run_and_put_task
A task that calls a node's forward_task function.
void reset(reset_flags f)
unfolded_join_node : passes input_ports_type to join_node_base. We build the input port type
internal::type_to_key_function_body< T1, K > * f1_p
void reset(reset_flags f)
bool remove_successor(successor_type &r) __TBB_override
Removes a successor from this node.
type_to_key_func_type * get_my_key_func()
internal::type_to_key_function_body< T4, K > * f4_p
internal::type_to_key_function_body< T3, K > * f3_p
internal::type_to_key_function_body< count_element_type, unref_key_type & > TtoK_function_body_type
bool try_to_make_tuple(output_type &out)
tbb::flow::tuple_element< 4, OutputTuple >::type T4
atomic< size_t > ports_with_no_inputs
#define __TBB_STATIC_ASSERT(condition, msg)
join_node_base(graph &g, FunctionTuple f)
queueing_port()
Constructor.
void set_owner(successor_type *owner)
wrap_key_tuple_elements< 4, key_matching_port, key_matching< K, KHash >, OutputTuple >::type input_ports_type
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
TraitsType::KHash hash_compare_type
virtual ~forwarding_base()
hash_buffer< key_type, input_type, type_to_key_func_type, hash_compare_type > buffer_type
static bool reserve(InputTuple &my_input, OutputTuple &out)
static void reset_my_port(InputTuple &my_input)
graph & graph_reference() __TBB_override
aggregator< handler_type, reserving_port_operation > my_aggregator
void set_key_func(TraitsType::TtoK *vtk)
unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3, Body4 body4)
field of type K being used for matching.
reserving_port_operation(op_type t)
bool tuple_build_may_succeed()
task * fill_output_buffer(unref_key_type &t, bool should_enqueue, bool handle_task)
graph & graph_reference() __TBB_override
A cache of successors that are put in a round-robin fashion.
void handle_operations(key_matching_FE_operation *op_list)
internal::type_to_key_function_body< T2, K > * f2_p
static void copy_key_functors(KeyFuncTuple &my_inputs, KeyFuncTuple &other_inputs)
reservable_predecessor_cache< T, null_mutex > my_predecessors
bool my_item_valid(size_type i) const
void suppress_unused_warning(const T1 &)
Utility template function to prevent "unused" warnings by various compilers.
wrap_tuple_elements< N, PT, OutputTuple >::type input_ports_type
hash_buffer< unref_key_type &, count_element_type, TtoK_function_body_type, key_hash_compare > key_to_count_buffer_type
receiver< input_type >::predecessor_type predecessor_type
void reset_receiver(reset_flags f) __TBB_override
internal::aggregating_functor< class_type, queueing_port_operation > handler_type
static void reset_inputs(InputTuple &my_input, reset_flags f)
tbb::flow::tuple_element< N, typename JNT::input_ports_type >::type & input_port(JNT &jn)
templated function to refer to input ports of the join node
unfolded_join_node(const unfolded_join_node &other)
reserving_port< T > class_type
tbb::flow::tuple_element< 2, OutputTuple >::type T2
graph & graph_reference() __TBB_override
tbb::flow::tuple_element< 2, OutputTuple >::type T2
friend class run_and_put_task
bool insert_with_key(const value_type &v)
forwarding_base * my_join
internal::type_to_key_function_body< T0, K > * f0_p
tbb::flow::tuple_element< 1, OutputTuple >::type T1
tbb::flow::tuple< f0_p, f1_p > func_initializer_type
queueing_port_operation(op_type t)
void set_join_node_pointer(forwarding_base *join)
record parent for tallying available items
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type type
K key_from_message(const T &t)
key_matching_FE_operation(output_type *p, op_type t)
static void set_key_functors(InputTuple &my_input, KeyFuncTuple &my_key_funcs)
static bool get_my_item(InputTuple &my_input, OutputTuple &out)
bool remove_predecessor(predecessor_type &src) __TBB_override
Remove a predecessor.
void reset_receiver(reset_flags f) __TBB_override
static bool get_my_item(InputTuple &my_input, OutputTuple &out)
static void release_reservations(TupleType &my_input)
internal::join_node_base< key_traits_type, typename wrap_key_tuple_elements< N, key_matching_port, key_traits_type, OutputTuple >::type, OutputTuple > type
void set_join_node_pointer(forwarding_base *join)
input_type & input_ports()
bool get_item(input_type &v)
join_node_base< key_matching< K, KHash >, input_ports_type, output_type > base_type
queueing_port(const queueing_port &)
copy constructor
reserving_port_operation(const predecessor_type &s, op_type t)
bool find_with_key(const Knoref &k, value_type &v)
void delete_with_key(const Knoref &k)
aggregator< handler_type, join_node_base_operation > my_aggregator
void increment_port_count() __TBB_override
join_node_FE(graph &g, FunctionTuple &TtoK_funcs)
receiver< input_type >::predecessor_type predecessor_type
void consume()
Complete use of the port.
void const char const char int ITT_FORMAT __itt_group_sync p
receiver< input_type >::predecessor_type predecessor_type
void set_my_node(base_node_type *new_my_node)
Base class for types that should not be assigned.
static tbb::task * combine_tasks(graph &g, tbb::task *left, tbb::task *right)
key_matching_FE_operation(const unref_key_type &e, bool q_task, op_type t)
join_node_FE(const join_node_FE &other)
internal::type_to_key_function_body< T3, K > * f3_p
bool try_reserve(output_type &v)
unfolded_join_node(const unfolded_join_node &other)
void handle_operations(reserving_port_operation *op_list)
task * decrement_port_count(bool handle_task) __TBB_override
join_node_FE< key_matching< key_type, key_hash_compare >, InputTuple, OutputTuple > class_type
unfolded_join_node(graph &g, Body0 body0, Body1 body1)
bool tuple_build_may_succeed()
atomic< size_t > ports_with_no_items
reserving_port(const reserving_port &)
static void release_my_reservation(TupleType &my_input)
tbb::flow::tuple_element< 0, OutputTuple >::type T0
tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p > func_initializer_type
internal::type_to_key_function_body< T1, K > * f1_p
tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p > func_initializer_type
matching_forwarding_base< key_type > * my_join
item_buffer< output_type > output_buffer_type
count_element< unref_key_type > count_element_type
static void reset_ports(InputTuple &my_input)
tbb::flow::tuple_element< 1, OutputTuple >::type T1
tbb::flow::tuple_element< 3, OutputTuple >::type T3
queueing_port_operation(const T &e, op_type t)
internal::type_to_key_function_body< T0, K > * f0_p
bool register_predecessor(predecessor_type &src) __TBB_override
Add a predecessor.
static void set_join_node_pointer(TupleType &my_input, PortType *port)
unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2)
input_type & input_ports()
internal::aggregating_functor< class_type, reserving_port_operation > handler_type
tbb::flow::tuple_element< 0, OutputTuple >::type T0
static void reset_ports(InputTuple &my_input)
internal::join_node_base< JP, typename wrap_tuple_elements< N, PT, OutputTuple >::type, OutputTuple > type
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task * task
reserving_port()
Constructor.
void reset_node(reset_flags f) __TBB_override
join_node_base_operation(const successor_type &s, op_type t)
tbb::flow::tuple_element< 0, OutputTuple >::type T0
void release()
Release the port.
tbb::flow::tuple_element< 2, OutputTuple >::type T2
join_node_FE : implements input port policy
void increment_port_count() __TBB_override
static void reset_my_port(InputTuple &my_input)
tbb::internal::strip< key_type >::type unref_key_type
aggregator< handler_type, key_matching_FE_operation > my_aggregator
bool register_successor(successor_type &r) __TBB_override
Add a new successor to this node.
void set_join_node_pointer(forwarding_base *join)
virtual task * increment_key_count(current_key_type const &, bool)=0
join_node_base< key_matching< K, KHash >, input_ports_type, output_type > base_type
wrap_key_tuple_elements< 2, key_matching_port, key_matching< K, KHash >, OutputTuple >::type input_ports_type
unfolded_join_node(const unfolded_join_node &other)
virtual task * decrement_port_count(bool handle_task)=0
queueing_port< T > class_type
internal::aggregating_functor< class_type, key_matching_FE_operation > handler_type
bool try_get(output_type &v) __TBB_override
Request an item from the sender.
key_matching_port_operation(const input_type *p, op_type t)
void set_my_key_func(type_to_key_func_type *f)
void set_my_node(base_node_type *new_my_node)
key_to_count_functor< unref_key_type > key_to_count_func
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long value
tbb::flow::tuple_element< 1, OutputTuple >::type T1
static void consume_reservations(TupleType &my_input)
static void set_join_node_pointer(TupleType &my_input, PortType *port)
void reset_receiver(reset_flags f) __TBB_override
task * decrement_port_count(bool handle_task) __TBB_override
bool reserve(T &v)
Reserve an item from the port.
static bool get_items(InputTuple &my_input, OutputTuple &out)
const item_type & front() const
internal::type_to_key_function_body< T2, K > * f2_p
unfolded_join_node(const unfolded_join_node &other)
join_node_FE(const join_node_FE &other)
const K & operator()(const table_item_type &v)
join_node_base< key_matching< key_type, key_hash_compare >, InputTuple, OutputTuple > base_node_type
TraitsType::TtoK type_to_key_func_type
join_node_base< JP, input_ports_type, output_type > base_type
broadcast_cache< output_type, null_rw_mutex > my_successors
tbb::flow::tuple_element< 3, OutputTuple >::type T3
task * try_put_task(const input_type &v) __TBB_override
Put item to successor; return task to run the successor if possible.
void handle_operations(queueing_port_operation *op_list)
task * try_put_task(const T &v) __TBB_override
join_node_base< key_matching< K, KHash >, input_ports_type, output_type > base_type
wrap_key_tuple_elements< 5, key_matching_port, key_matching< K, KHash >, OutputTuple >::type input_ports_type
void handle_operations(key_matching_port_operation *op_list)
static void release_reservations(TupleType &my_input)
predecessor_type * my_pred
join_node_base(const join_node_base &other)
forwarding_base * my_join
void increment_port_count() __TBB_override
join_node_base< reserving, InputTuple, OutputTuple > base_node_type
join_node_base< key_matching< K, KHash >, input_ports_type, output_type > base_type
internal::type_to_key_function_body< T0, K > * f0_p
unfolded_join_node(const unfolded_join_node &other)
internal::type_to_key_function_body_leaf< count_element_type, unref_key_type &, key_to_count_func > TtoK_function_body_leaf_type
unfolded_join_node(graph &g)
tbb::internal::strip< KeyType >::type current_key_type
internal::type_to_key_function_body< T1, K > * f1_p
static void copy_key_functors(KeyFuncTuple &my_inputs, KeyFuncTuple &other_inputs)
void const char const char int ITT_FORMAT __itt_group_sync s
void handle_operations(join_node_base_operation *op_list)
unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3)
TraitsType::TtoK * get_key_func()
matching_forwarding_base< key_type > forwarding_base_type
static void reset_inputs(InputTuple &my_input, reset_flags f)
friend class run_and_put_task
task * decrement_port_count(bool) __TBB_override
key_matching_port(const key_matching_port &)
A cache of successors that are broadcast to.
join_node_FE< JP, InputTuple, OutputTuple > input_ports_type
join_node_base_operation(op_type t)
tbb::internal::strip< key_type >::type noref_key_type
bool tuple_build_may_succeed()
wrap_key_tuple_elements< 3, key_matching_port, key_matching< K, KHash >, OutputTuple >::type input_ports_type
sender< output_type >::successor_type successor_type
join_node_base< queueing, InputTuple, OutputTuple > base_node_type
join_node_base_operation(const output_type &e, op_type t)
reserving_port_operation(const T &e, op_type t)
aggregator< handler_type, queueing_port_operation > my_aggregator
bool push_back(item_type &v)
void spawn_in_graph_arena(graph &g, tbb::task &arena_task)
Spawns a task inside graph arena.
static void set_key_functors(InputTuple &my_input, KeyFuncTuple &my_key_funcs)
count_element< K > table_item_type
bool try_to_make_tuple(output_type &out)
task * try_put_task(const T &) __TBB_override
internal::type_to_key_function_body< T0, K > * f0_p
key_matching< K, KHash > key_traits_type
bool try_to_make_tuple(output_type &out)
internal::type_to_key_function_body< T1, K > * f1_p
join_node_base< JP, InputTuple, OutputTuple > class_type
void reset(reset_flags f)
bool is_graph_active(graph &g)
input_type & input_ports()
internal::aggregating_functor< class_type, join_node_base_operation > handler_type
static void release_my_reservation(TupleType &my_input)
key_matching_port_operation(op_type t)
tbb::flow::tuple< f0_p, f1_p, f2_p > func_initializer_type
matching_forwarding_base(graph &g)
task * increment_key_count(unref_key_type const &t, bool handle_task) __TBB_override
static bool get_items(InputTuple &my_input, OutputTuple &out)
internal::aggregating_functor< class_type, key_matching_port_operation > handler_type
tbb::flow::tuple_element< 0, OutputTuple >::type T0
key_matching_port< traits > class_type
void __TBB_store_with_release(volatile T &location, V value)
static void consume_reservations(TupleType &my_input)
current_key_type current_key
queueing_port_operation(const T *p, op_type t)
static bool reserve(InputTuple &my_input, OutputTuple &out)
key_matching_port_operation(const input_type &e, op_type t)
key_matching_FE_operation(op_type t)
aggregator< handler_type, key_matching_port_operation > my_aggregator
bool buffer_empty() const
void set_my_node(base_node_type *new_my_node)
join_node_FE(const join_node_FE &other)
forwarding_base(graph &g)