17 #ifndef __TBB__flow_graph_join_impl_H 18 #define __TBB__flow_graph_join_impl_H 20 #ifndef __TBB_flow_graph_H 21 #error Do not #include this internal file directly; use public TBB headers instead. 39 template<
typename KeyType>
50 template<
typename TupleType,
typename PortType >
55 template<
typename TupleType >
57 tbb::flow::get<N-1>( my_input ).consume();
61 template<
typename TupleType >
63 tbb::flow::get<N-1>( my_input ).
release();
66 template <
typename TupleType>
72 template<
typename InputTuple,
typename OutputTuple >
73 static inline bool reserve( InputTuple &my_input, OutputTuple &out) {
74 if ( !tbb::flow::get<N-1>( my_input ).
reserve( tbb::flow::get<N-1>( out ) ) )
return false;
82 template<
typename InputTuple,
typename OutputTuple>
83 static inline bool get_my_item( InputTuple &my_input, OutputTuple &out) {
84 bool res = tbb::flow::get<N-1>(my_input).get_item(tbb::flow::get<N-1>(out) );
88 template<
typename InputTuple,
typename OutputTuple>
89 static inline bool get_items(InputTuple &my_input, OutputTuple &out) {
93 template<
typename InputTuple>
96 tbb::flow::get<N-1>(my_input).reset_port();
99 template<
typename InputTuple>
104 template<
typename InputTuple,
typename KeyFuncTuple>
106 tbb::flow::get<N-1>(my_input).set_my_key_func(tbb::flow::get<N-1>(my_key_funcs));
107 tbb::flow::get<N-1>(my_key_funcs) = NULL;
111 template<
typename KeyFuncTuple>
113 if(tbb::flow::get<N-1>(other_inputs).get_my_key_func()) {
114 tbb::flow::get<N-1>(my_inputs).set_my_key_func(tbb::flow::get<N-1>(other_inputs).get_my_key_func()->clone());
119 template<
typename InputTuple>
122 tbb::flow::get<N-1>(my_input).reset_receiver(f);
125 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 126 template<
typename InputTuple>
127 static inline void extract_inputs(InputTuple &my_input) {
129 tbb::flow::get<N-1>(my_input).extract_receiver();
137 template<
typename TupleType,
typename PortType >
139 tbb::flow::get<0>( my_input ).set_join_node_pointer(port);
142 template<
typename TupleType >
144 tbb::flow::get<0>( my_input ).consume();
147 template<
typename TupleType >
149 tbb::flow::get<0>( my_input ).release();
152 template<
typename TupleType>
157 template<
typename InputTuple,
typename OutputTuple >
158 static inline bool reserve( InputTuple &my_input, OutputTuple &out) {
159 return tbb::flow::get<0>( my_input ).reserve( tbb::flow::get<0>( out ) );
162 template<
typename InputTuple,
typename OutputTuple>
163 static inline bool get_my_item( InputTuple &my_input, OutputTuple &out) {
164 return tbb::flow::get<0>(my_input).get_item(tbb::flow::get<0>(out));
167 template<
typename InputTuple,
typename OutputTuple>
168 static inline bool get_items(InputTuple &my_input, OutputTuple &out) {
172 template<
typename InputTuple>
174 tbb::flow::get<0>(my_input).reset_port();
177 template<
typename InputTuple>
182 template<
typename InputTuple,
typename KeyFuncTuple>
184 tbb::flow::get<0>(my_input).set_my_key_func(tbb::flow::get<0>(my_key_funcs));
185 tbb::flow::get<0>(my_key_funcs) = NULL;
188 template<
typename KeyFuncTuple>
190 if(tbb::flow::get<0>(other_inputs).get_my_key_func()) {
191 tbb::flow::get<0>(my_inputs).set_my_key_func(tbb::flow::get<0>(other_inputs).get_my_key_func()->clone());
194 template<
typename InputTuple>
196 tbb::flow::get<0>(my_input).reset_receiver(f);
199 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 200 template<
typename InputTuple>
201 static inline void extract_inputs(InputTuple &my_input) {
202 tbb::flow::get<0>(my_input).extract_receiver();
208 template<
typename T >
213 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 214 typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
215 typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
220 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 221 , add_blt_pred, del_blt_pred, blt_pred_cnt, blt_pred_cpy
233 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 235 predecessor_list_type *plist;
245 typedef internal::aggregating_functor<class_type, reserving_port_operation>
handler_type;
251 bool no_predecessors;
254 op_list = op_list->next;
255 switch(current->
type) {
259 if ( no_predecessors ) {
293 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 381 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 384 reserving_port_operation op_data(src, add_blt_pred);
389 reserving_port_operation op_data(src, del_blt_pred);
394 reserving_port_operation op_data(blt_pred_cnt);
396 return op_data.cnt_val;
400 reserving_port_operation op_data(blt_pred_cpy);
405 void extract_receiver() {
432 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 433 typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
434 typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
440 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 441 , add_blt_pred, del_blt_pred, blt_pred_cnt, blt_pred_cpy
451 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 454 predecessor_list_type *plist;
473 typedef internal::aggregating_functor<class_type, queueing_port_operation>
handler_type;
482 op_list = op_list->next;
483 switch(current->
type) {
512 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 514 my_built_predecessors.add_edge(*(current->pred));
518 my_built_predecessors.delete_edge(*(current->pred));
522 current->cnt_val = my_built_predecessors.edge_count();
526 my_built_predecessors.copy_edges(*(current->plist));
584 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 585 built_predecessors_type &built_predecessors()
__TBB_override {
return my_built_predecessors; }
588 queueing_port_operation op_data(add_blt_pred);
594 queueing_port_operation op_data(del_blt_pred);
600 queueing_port_operation op_data(blt_pred_cnt);
602 return op_data.cnt_val;
606 queueing_port_operation op_data(blt_pred_cpy);
611 void extract_receiver() {
613 my_built_predecessors.receiver_extract(*
this);
620 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 622 my_built_predecessors.clear();
628 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 629 edge_container<predecessor_type> my_built_predecessors;
643 template<
typename K >
651 template<
class TraitsType >
653 public receiver<typename TraitsType::T>,
654 public hash_buffer< typename TraitsType::K, typename TraitsType::T, typename TraitsType::TtoK,
655 typename TraitsType::KHash > {
666 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 667 typedef typename receiver<input_type>::built_predecessors_type built_predecessors_type;
668 typedef typename receiver<input_type>::predecessor_list_type predecessor_list_type;
674 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 675 , add_blt_pred, del_blt_pred, blt_pred_cnt, blt_pred_cpy
685 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 688 predecessor_list_type *plist;
700 typedef internal::aggregating_functor<class_type, key_matching_port_operation>
handler_type;
708 op_list = op_list->next;
709 switch(current->
type) {
719 __TBB_ASSERT(
false,
"Failed to find item corresponding to current_key.");
728 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 730 my_built_predecessors.add_edge(*(current->pred));
734 my_built_predecessors.delete_edge(*(current->pred));
738 current->cnt_val = my_built_predecessors.edge_count();
742 my_built_predecessors.copy_edges(*(current->plist));
800 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 801 built_predecessors_type &built_predecessors()
__TBB_override {
return my_built_predecessors; }
804 key_matching_port_operation op_data(add_blt_pred);
810 key_matching_port_operation op_data(del_blt_pred);
816 key_matching_port_operation op_data(blt_pred_cnt);
818 return op_data.cnt_val;
822 key_matching_port_operation op_data(blt_pred_cpy);
836 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 837 void extract_receiver() {
839 my_built_predecessors.receiver_extract(*
this);
845 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 847 my_built_predecessors.clear();
855 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 856 edge_container<predecessor_type> my_built_predecessors;
860 using namespace graph_policy_namespace;
862 template<
typename JP,
typename InputTuple,
typename OutputTuple>
866 template<
typename JP,
typename InputTuple,
typename OutputTuple>
869 template<
typename InputTuple,
typename OutputTuple>
878 ports_with_no_inputs = N;
883 ports_with_no_inputs = N;
890 ++ports_with_no_inputs;
895 if(ports_with_no_inputs.fetch_and_decrement() == 1) {
897 task *rtask =
new ( task::allocate_additional_child_of( *(this->graph_ref.root_task()) ) )
899 if(!handle_task)
return rtask;
912 ports_with_no_inputs = N;
916 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 919 ports_with_no_inputs = N;
927 return !ports_with_no_inputs;
931 if(ports_with_no_inputs)
return false;
947 template<
typename InputTuple,
typename OutputTuple>
956 ports_with_no_items = N;
961 ports_with_no_items = N;
969 ports_with_no_items = N;
975 if(ports_with_no_items.fetch_and_decrement() == 1) {
977 task *rtask =
new ( task::allocate_additional_child_of( *(this->graph_ref.root_task()) ) )
979 if(!handle_task)
return rtask;
997 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1006 return !ports_with_no_items;
1010 if(ports_with_no_items)
return false;
1028 template<
typename InputTuple,
typename OutputTuple,
typename K,
typename KHash>
1032 typename tbb::internal::strip<K>::type&,
1033 count_element<typename tbb::internal::strip<K>::type>,
1034 internal::type_to_key_function_body<
1035 count_element<typename tbb::internal::strip<K>::type>,
1036 typename tbb::internal::strip<K>::type& >,
1065 enum op_type { res_count, inc_count, may_succeed, try_make };
1069 class key_matching_FE_operation :
public aggregated_operation<key_matching_FE_operation> {
1078 my_output(NULL), bypass_t(NULL), enqueue_task(q_task) {}
1080 enqueue_task(true) {}
1085 typedef internal::aggregating_functor<class_type, key_matching_FE_operation>
handler_type;
1086 friend class internal::aggregating_functor<
class_type, key_matching_FE_operation>;
1096 this->current_key = t;
1097 this->delete_with_key(this->current_key);
1099 this->push_back(l_out);
1101 rtask =
new ( task::allocate_additional_child_of( *(this->graph_ref.root_task()) ) )
1113 __TBB_ASSERT(
false,
"should have had something to push");
1119 key_matching_FE_operation *current;
1122 op_list = op_list->next;
1123 switch(current->type) {
1126 this->destroy_front();
1133 bool do_enqueue = current->enqueue_task;
1134 if(!(this->find_ref_with_key(t,
p))) {
1138 this->insert_with_key(ev);
1139 if(!(this->find_ref_with_key(t,
p))) {
1140 __TBB_ASSERT(
false,
"should find key after inserting it");
1143 if(++(
p->my_value) ==
size_t(N)) {
1144 task *rtask = fill_output_buffer(t,
true, do_enqueue);
1145 __TBB_ASSERT(!rtask || !do_enqueue,
"task should not be returned");
1146 current->bypass_t = rtask;
1155 if(this->buffer_empty()) {
1159 *(current->my_output) = this->front();
1169 template<
typename FunctionTuple>
1175 this->set_key_func(cfb);
1185 this->set_key_func(cfb);
1192 key_matching_FE_operation op_data(res_count);
1193 my_aggregator.execute(&op_data);
1200 key_matching_FE_operation op_data(t, handle_task, inc_count);
1201 my_aggregator.execute(&op_data);
1202 return op_data.bypass_t;
1217 key_to_count_buffer_type::reset();
1218 output_buffer_type::reset();
1221 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1225 key_to_count_buffer_type::reset();
1226 output_buffer_type::reset();
1233 key_matching_FE_operation op_data(may_succeed);
1234 my_aggregator.execute(&op_data);
1241 key_matching_FE_operation op_data(&out,try_make);
1242 my_aggregator.execute(&op_data);
1259 template<
typename JP,
typename InputTuple,
typename OutputTuple>
1261 public sender<OutputTuple> {
1263 using graph_node::my_graph;
1269 using input_ports_type::tuple_build_may_succeed;
1270 using input_ports_type::try_to_make_tuple;
1271 using input_ports_type::tuple_accepted;
1272 using input_ports_type::tuple_rejected;
1273 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1274 typedef typename sender<output_type>::built_successors_type built_successors_type;
1275 typedef typename sender<output_type>::successor_list_type successor_list_type;
1281 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1282 , add_blt_succ, del_blt_succ, blt_succ_cnt, blt_succ_cpy
1294 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1296 successor_list_type *slist;
1301 my_arg(const_cast<
output_type*>(&e)), bypass_t(NULL) {}
1307 typedef internal::aggregating_functor<class_type, join_node_base_operation>
handler_type;
1316 op_list = op_list->next;
1317 switch(current->
type) {
1319 my_successors.register_successor(*(current->
my_succ));
1321 task *rtask =
new ( task::allocate_additional_child_of(*(my_graph.root_task())) )
1325 forwarder_busy =
true;
1331 my_successors.remove_successor(*(current->
my_succ));
1335 if(tuple_build_may_succeed()) {
1336 if(try_to_make_tuple(*(current->
my_arg))) {
1344 case do_fwrd_bypass: {
1345 bool build_succeeded;
1346 task *last_task = NULL;
1348 if(tuple_build_may_succeed()) {
1350 build_succeeded = try_to_make_tuple(out);
1351 if(build_succeeded) {
1352 task *new_task = my_successors.try_put_task(out);
1359 build_succeeded =
false;
1362 }
while(build_succeeded);
1366 forwarder_busy =
false;
1369 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1371 my_successors.internal_add_built_successor(*(current->
my_succ));
1375 my_successors.internal_delete_built_successor(*(current->
my_succ));
1379 current->cnt_val = my_successors.successor_count();
1383 my_successors.copy_successors(*(current->slist));
1393 my_successors.set_owner(
this);
1394 input_ports_type::set_my_node(
this);
1400 sender<OutputTuple>(), forwarder_busy(false), my_successors() {
1401 my_successors.set_owner(
this);
1402 input_ports_type::set_my_node(
this);
1406 template<
typename FunctionTuple>
1408 my_successors.set_owner(
this);
1409 input_ports_type::set_my_node(
this);
1415 my_aggregator.execute(&op_data);
1421 my_aggregator.execute(&op_data);
1427 my_aggregator.execute(&op_data);
1431 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1432 built_successors_type &built_successors()
__TBB_override {
return my_successors.built_successors(); }
1434 void internal_add_built_successor( successor_type &r)
__TBB_override {
1435 join_node_base_operation op_data(r, add_blt_succ);
1436 my_aggregator.execute(&op_data);
1439 void internal_delete_built_successor( successor_type &r)
__TBB_override {
1440 join_node_base_operation op_data(r, del_blt_succ);
1441 my_aggregator.execute(&op_data);
1445 join_node_base_operation op_data(blt_succ_cnt);
1446 my_aggregator.execute(&op_data);
1447 return op_data.cnt_val;
1451 join_node_base_operation op_data(blt_succ_cpy);
1453 my_aggregator.execute(&op_data);
1457 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION 1459 input_ports_type::extract();
1460 my_successors.built_successors().sender_extract(*
this);
1467 input_ports_type::reset(f);
1477 my_aggregator.execute(&op_data);
1484 template<
int N,
template<
class>
class PT,
typename OutputTuple,
typename JP>
1489 template<
int N,
typename OutputTuple,
typename K,
typename KHash>
1504 template<
int N,
template<
class>
class PT,
typename OutputTuple,
typename JP>
1516 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1517 template <
typename K,
typename T>
1518 struct key_from_message_body {
1519 K operator()(
const T& t)
const {
1521 return key_from_message<K>(t);
1525 template <
typename K,
typename T>
1526 struct key_from_message_body<K&,T> {
1527 const K& operator()(
const T& t)
const {
1529 return key_from_message<const K&>(t);
1536 template<
typename OutputTuple,
typename K,
typename KHash>
1538 join_base<2,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1550 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1558 template<
typename Body0,
typename Body1>
1569 template<
typename OutputTuple,
typename K,
typename KHash>
1571 join_base<3,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1585 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1594 template<
typename Body0,
typename Body1,
typename Body2>
1606 template<
typename OutputTuple,
typename K,
typename KHash>
1608 join_base<4,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1624 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1634 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3>
1647 template<
typename OutputTuple,
typename K,
typename KHash>
1649 join_base<5,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1667 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1678 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3,
typename Body4>
1692 #if __TBB_VARIADIC_MAX >= 6 1693 template<
typename OutputTuple,
typename K,
typename KHash>
1694 class unfolded_join_node<6,key_matching_port,OutputTuple,
key_matching<K,KHash> > :
public 1695 join_base<6,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1703 typedef typename wrap_key_tuple_elements<6,key_matching_port,key_matching<K,KHash>,OutputTuple>
::type input_ports_type;
1704 typedef OutputTuple output_type;
1706 typedef join_node_base<key_matching<K,KHash> , input_ports_type, output_type > base_type;
1713 typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p > func_initializer_type;
1715 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1716 unfolded_join_node(graph &g) : base_type(g,
1717 func_initializer_type(
1718 new internal::type_to_key_function_body_leaf<T0, K, key_from_message_body<K,T0> >(key_from_message_body<K,T0>()),
1719 new internal::type_to_key_function_body_leaf<T1, K, key_from_message_body<K,T1> >(key_from_message_body<K,T1>()),
1720 new internal::type_to_key_function_body_leaf<T2, K, key_from_message_body<K,T2> >(key_from_message_body<K,T2>()),
1721 new internal::type_to_key_function_body_leaf<T3, K, key_from_message_body<K,T3> >(key_from_message_body<K,T3>()),
1722 new internal::type_to_key_function_body_leaf<T4, K, key_from_message_body<K,T4> >(key_from_message_body<K,T4>()),
1723 new internal::type_to_key_function_body_leaf<T5, K, key_from_message_body<K,T5> >(key_from_message_body<K,T5>())
1727 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3,
typename Body4,
typename Body5>
1728 unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3, Body4 body4, Body5 body5)
1729 : base_type(g, func_initializer_type(
1730 new internal::type_to_key_function_body_leaf<T0, K, Body0>(body0),
1731 new internal::type_to_key_function_body_leaf<T1, K, Body1>(body1),
1732 new internal::type_to_key_function_body_leaf<T2, K, Body2>(body2),
1733 new internal::type_to_key_function_body_leaf<T3, K, Body3>(body3),
1734 new internal::type_to_key_function_body_leaf<T4, K, Body4>(body4),
1735 new internal::type_to_key_function_body_leaf<T5, K, Body5>(body5)
1739 unfolded_join_node(
const unfolded_join_node &other) : base_type(other) {}
1743 #if __TBB_VARIADIC_MAX >= 7 1744 template<
typename OutputTuple,
typename K,
typename KHash>
1745 class unfolded_join_node<7,key_matching_port,OutputTuple,
key_matching<K,KHash> > :
public 1746 join_base<7,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1755 typedef typename wrap_key_tuple_elements<7,key_matching_port,key_matching<K,KHash>,OutputTuple>
::type input_ports_type;
1756 typedef OutputTuple output_type;
1758 typedef join_node_base<key_matching<K,KHash> , input_ports_type, output_type > base_type;
1766 typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p > func_initializer_type;
1768 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1769 unfolded_join_node(graph &g) : base_type(g,
1770 func_initializer_type(
1771 new internal::type_to_key_function_body_leaf<T0, K, key_from_message_body<K,T0> >(key_from_message_body<K,T0>()),
1772 new internal::type_to_key_function_body_leaf<T1, K, key_from_message_body<K,T1> >(key_from_message_body<K,T1>()),
1773 new internal::type_to_key_function_body_leaf<T2, K, key_from_message_body<K,T2> >(key_from_message_body<K,T2>()),
1774 new internal::type_to_key_function_body_leaf<T3, K, key_from_message_body<K,T3> >(key_from_message_body<K,T3>()),
1775 new internal::type_to_key_function_body_leaf<T4, K, key_from_message_body<K,T4> >(key_from_message_body<K,T4>()),
1776 new internal::type_to_key_function_body_leaf<T5, K, key_from_message_body<K,T5> >(key_from_message_body<K,T5>()),
1777 new internal::type_to_key_function_body_leaf<T6, K, key_from_message_body<K,T6> >(key_from_message_body<K,T6>())
1781 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3,
typename Body4,
1782 typename Body5,
typename Body6>
1783 unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3, Body4 body4,
1784 Body5 body5, Body6 body6) : base_type(g, func_initializer_type(
1785 new internal::type_to_key_function_body_leaf<T0, K, Body0>(body0),
1786 new internal::type_to_key_function_body_leaf<T1, K, Body1>(body1),
1787 new internal::type_to_key_function_body_leaf<T2, K, Body2>(body2),
1788 new internal::type_to_key_function_body_leaf<T3, K, Body3>(body3),
1789 new internal::type_to_key_function_body_leaf<T4, K, Body4>(body4),
1790 new internal::type_to_key_function_body_leaf<T5, K, Body5>(body5),
1791 new internal::type_to_key_function_body_leaf<T6, K, Body6>(body6)
1795 unfolded_join_node(
const unfolded_join_node &other) : base_type(other) {}
1799 #if __TBB_VARIADIC_MAX >= 8 1800 template<
typename OutputTuple,
typename K,
typename KHash>
1801 class unfolded_join_node<8,key_matching_port,OutputTuple,
key_matching<K,KHash> > :
public 1802 join_base<8,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1812 typedef typename wrap_key_tuple_elements<8,key_matching_port,key_matching<K,KHash>,OutputTuple>
::type input_ports_type;
1813 typedef OutputTuple output_type;
1815 typedef join_node_base<key_matching<K,KHash> , input_ports_type, output_type > base_type;
1824 typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p, f7_p > func_initializer_type;
1826 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1827 unfolded_join_node(graph &g) : base_type(g,
1828 func_initializer_type(
1829 new internal::type_to_key_function_body_leaf<T0, K, key_from_message_body<K,T0> >(key_from_message_body<K,T0>()),
1830 new internal::type_to_key_function_body_leaf<T1, K, key_from_message_body<K,T1> >(key_from_message_body<K,T1>()),
1831 new internal::type_to_key_function_body_leaf<T2, K, key_from_message_body<K,T2> >(key_from_message_body<K,T2>()),
1832 new internal::type_to_key_function_body_leaf<T3, K, key_from_message_body<K,T3> >(key_from_message_body<K,T3>()),
1833 new internal::type_to_key_function_body_leaf<T4, K, key_from_message_body<K,T4> >(key_from_message_body<K,T4>()),
1834 new internal::type_to_key_function_body_leaf<T5, K, key_from_message_body<K,T5> >(key_from_message_body<K,T5>()),
1835 new internal::type_to_key_function_body_leaf<T6, K, key_from_message_body<K,T6> >(key_from_message_body<K,T6>()),
1836 new internal::type_to_key_function_body_leaf<T7, K, key_from_message_body<K,T7> >(key_from_message_body<K,T7>())
1840 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3,
typename Body4,
1841 typename Body5,
typename Body6,
typename Body7>
1842 unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3, Body4 body4,
1843 Body5 body5, Body6 body6, Body7 body7) : base_type(g, func_initializer_type(
1844 new internal::type_to_key_function_body_leaf<T0, K, Body0>(body0),
1845 new internal::type_to_key_function_body_leaf<T1, K, Body1>(body1),
1846 new internal::type_to_key_function_body_leaf<T2, K, Body2>(body2),
1847 new internal::type_to_key_function_body_leaf<T3, K, Body3>(body3),
1848 new internal::type_to_key_function_body_leaf<T4, K, Body4>(body4),
1849 new internal::type_to_key_function_body_leaf<T5, K, Body5>(body5),
1850 new internal::type_to_key_function_body_leaf<T6, K, Body6>(body6),
1851 new internal::type_to_key_function_body_leaf<T7, K, Body7>(body7)
1855 unfolded_join_node(
const unfolded_join_node &other) : base_type(other) {}
1859 #if __TBB_VARIADIC_MAX >= 9 1860 template<
typename OutputTuple,
typename K,
typename KHash>
1861 class unfolded_join_node<9,key_matching_port,OutputTuple,
key_matching<K,KHash> > :
public 1862 join_base<9,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1873 typedef typename wrap_key_tuple_elements<9,key_matching_port,key_matching<K,KHash>,OutputTuple>
::type input_ports_type;
1874 typedef OutputTuple output_type;
1876 typedef join_node_base<key_matching<K,KHash> , input_ports_type, output_type > base_type;
1886 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;
1888 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1889 unfolded_join_node(graph &g) : base_type(g,
1890 func_initializer_type(
1891 new internal::type_to_key_function_body_leaf<T0, K, key_from_message_body<K,T0> >(key_from_message_body<K,T0>()),
1892 new internal::type_to_key_function_body_leaf<T1, K, key_from_message_body<K,T1> >(key_from_message_body<K,T1>()),
1893 new internal::type_to_key_function_body_leaf<T2, K, key_from_message_body<K,T2> >(key_from_message_body<K,T2>()),
1894 new internal::type_to_key_function_body_leaf<T3, K, key_from_message_body<K,T3> >(key_from_message_body<K,T3>()),
1895 new internal::type_to_key_function_body_leaf<T4, K, key_from_message_body<K,T4> >(key_from_message_body<K,T4>()),
1896 new internal::type_to_key_function_body_leaf<T5, K, key_from_message_body<K,T5> >(key_from_message_body<K,T5>()),
1897 new internal::type_to_key_function_body_leaf<T6, K, key_from_message_body<K,T6> >(key_from_message_body<K,T6>()),
1898 new internal::type_to_key_function_body_leaf<T7, K, key_from_message_body<K,T7> >(key_from_message_body<K,T7>()),
1899 new internal::type_to_key_function_body_leaf<T8, K, key_from_message_body<K,T8> >(key_from_message_body<K,T8>())
1903 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3,
typename Body4,
1904 typename Body5,
typename Body6,
typename Body7,
typename Body8>
1905 unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3, Body4 body4,
1906 Body5 body5, Body6 body6, Body7 body7, Body8 body8) : base_type(g, func_initializer_type(
1907 new internal::type_to_key_function_body_leaf<T0, K, Body0>(body0),
1908 new internal::type_to_key_function_body_leaf<T1, K, Body1>(body1),
1909 new internal::type_to_key_function_body_leaf<T2, K, Body2>(body2),
1910 new internal::type_to_key_function_body_leaf<T3, K, Body3>(body3),
1911 new internal::type_to_key_function_body_leaf<T4, K, Body4>(body4),
1912 new internal::type_to_key_function_body_leaf<T5, K, Body5>(body5),
1913 new internal::type_to_key_function_body_leaf<T6, K, Body6>(body6),
1914 new internal::type_to_key_function_body_leaf<T7, K, Body7>(body7),
1915 new internal::type_to_key_function_body_leaf<T8, K, Body8>(body8)
1919 unfolded_join_node(
const unfolded_join_node &other) : base_type(other) {}
1923 #if __TBB_VARIADIC_MAX >= 10 1924 template<
typename OutputTuple,
typename K,
typename KHash>
1925 class unfolded_join_node<10,key_matching_port,OutputTuple,
key_matching<K,KHash> > :
public 1926 join_base<10,key_matching_port,OutputTuple,key_matching<K,KHash> >
::type {
1938 typedef typename wrap_key_tuple_elements<10,key_matching_port,key_matching<K,KHash>,OutputTuple>
::type input_ports_type;
1939 typedef OutputTuple output_type;
1941 typedef join_node_base<key_matching<K,KHash> , input_ports_type, output_type > base_type;
1952 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;
1954 #if __TBB_PREVIEW_MESSAGE_BASED_KEY_MATCHING 1955 unfolded_join_node(graph &g) : base_type(g,
1956 func_initializer_type(
1957 new internal::type_to_key_function_body_leaf<T0, K, key_from_message_body<K,T0> >(key_from_message_body<K,T0>()),
1958 new internal::type_to_key_function_body_leaf<T1, K, key_from_message_body<K,T1> >(key_from_message_body<K,T1>()),
1959 new internal::type_to_key_function_body_leaf<T2, K, key_from_message_body<K,T2> >(key_from_message_body<K,T2>()),
1960 new internal::type_to_key_function_body_leaf<T3, K, key_from_message_body<K,T3> >(key_from_message_body<K,T3>()),
1961 new internal::type_to_key_function_body_leaf<T4, K, key_from_message_body<K,T4> >(key_from_message_body<K,T4>()),
1962 new internal::type_to_key_function_body_leaf<T5, K, key_from_message_body<K,T5> >(key_from_message_body<K,T5>()),
1963 new internal::type_to_key_function_body_leaf<T6, K, key_from_message_body<K,T6> >(key_from_message_body<K,T6>()),
1964 new internal::type_to_key_function_body_leaf<T7, K, key_from_message_body<K,T7> >(key_from_message_body<K,T7>()),
1965 new internal::type_to_key_function_body_leaf<T8, K, key_from_message_body<K,T8> >(key_from_message_body<K,T8>()),
1966 new internal::type_to_key_function_body_leaf<T9, K, key_from_message_body<K,T9> >(key_from_message_body<K,T9>())
1970 template<
typename Body0,
typename Body1,
typename Body2,
typename Body3,
typename Body4,
1971 typename Body5,
typename Body6,
typename Body7,
typename Body8,
typename Body9>
1972 unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3, Body4 body4,
1973 Body5 body5, Body6 body6, Body7 body7, Body8 body8, Body9 body9) : base_type(g, func_initializer_type(
1974 new internal::type_to_key_function_body_leaf<T0, K, Body0>(body0),
1975 new internal::type_to_key_function_body_leaf<T1, K, Body1>(body1),
1976 new internal::type_to_key_function_body_leaf<T2, K, Body2>(body2),
1977 new internal::type_to_key_function_body_leaf<T3, K, Body3>(body3),
1978 new internal::type_to_key_function_body_leaf<T4, K, Body4>(body4),
1979 new internal::type_to_key_function_body_leaf<T5, K, Body5>(body5),
1980 new internal::type_to_key_function_body_leaf<T6, K, Body6>(body6),
1981 new internal::type_to_key_function_body_leaf<T7, K, Body7>(body7),
1982 new internal::type_to_key_function_body_leaf<T8, K, Body8>(body8),
1983 new internal::type_to_key_function_body_leaf<T9, K, Body9>(body9)
1987 unfolded_join_node(
const unfolded_join_node &other) : base_type(other) {}
1992 template<
size_t N,
typename JNT>
1994 return tbb::flow::get<N>(jn.input_ports());
1998 #endif // __TBB__flow_graph_join_impl_H void set_owner(successor_type *owner)
forwarding_base * my_join
static void reset_my_port(InputTuple &my_input)
aggregator< handler_type, join_node_base_operation > my_aggregator
tbb::flow::tuple_element< 1, OutputTuple >::type T1
static void consume_reservations(TupleType &my_input)
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
internal::type_to_key_function_body< T1, K > * f1_p
tbb::internal::strip< KeyType >::type current_key_type
bool remove_successor(successor_type &r) __TBB_override
Removes a successor from this node.
A task that calls a node's forward_task function.
unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2)
unfolded_join_node : passes input_ports_type to join_node_base. We build the input port type
aggregator< handler_type, queueing_port_operation > my_aggregator
key_matching_FE_operation(output_type *p, op_type t)
TraitsType::TtoK * get_key_func()
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
tbb::flow::tuple< f0_p, f1_p > func_initializer_type
unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3)
bool reserve(T &v)
Reserve an item from the port.
static void reset_my_port(InputTuple &my_input)
receiver< input_type >::predecessor_type predecessor_type
static bool get_my_item(InputTuple &my_input, OutputTuple &out)
tbb::flow::tuple_element< 4, OutputTuple >::type T4
tbb::flow::tuple_element< 3, OutputTuple >::type T3
bool insert_with_key(const value_type &v)
void handle_operations(reserving_port_operation *op_list)
virtual ~forwarding_base()
void consume()
Complete use of the port.
void release()
Release the port.
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
internal::join_node_base< JP, typename wrap_tuple_elements< N, PT, OutputTuple >::type, OutputTuple > type
key_matching_FE_operation(const unref_key_type &e, bool q_task, op_type t)
void set_my_node(base_node_type *new_my_node)
void delete_with_key(const Knoref &k)
void const char const char int ITT_FORMAT __itt_group_sync s
static void set_key_functors(InputTuple &my_input, KeyFuncTuple &my_key_funcs)
key_matching< K, KHash > key_traits_type
bool get_item(input_type &v)
graph & graph_reference() __TBB_override
tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p > func_initializer_type
void increment_port_count() __TBB_override
join_node_base< JP, input_ports_type, output_type > base_type
join_node_FE(const join_node_FE &other)
join_node_FE(graph &g, FunctionTuple &TtoK_funcs)
friend class run_and_put_task
key_matching_port_operation(const input_type *p, op_type t)
void set_my_key_func(type_to_key_func_type *f)
tbb::flow::tuple_element< 3, OutputTuple >::type T3
void reset_node(reset_flags f) __TBB_override
void reset_receiver(reset_flags f) __TBB_override
bool buffer_empty() const
forwarding_base * my_join
task * decrement_port_count(bool handle_task) __TBB_override
join_node_base< key_matching< K, KHash >, input_ports_type, output_type > base_type
internal::type_to_key_function_body< T2, K > * f2_p
void __TBB_store_with_release(volatile T &location, V value)
join_node_base< key_matching< K, KHash >, input_ports_type, output_type > base_type
sender< output_type >::successor_type successor_type
const K & operator()(const table_item_type &v)
bool try_to_make_tuple(output_type &out)
tbb::flow::tuple_element< 0, OutputTuple >::type T0
static void release_my_reservation(TupleType &my_input)
A cache of successors that are broadcast to.
TraitsType::TtoK type_to_key_func_type
static bool get_my_item(InputTuple &my_input, OutputTuple &out)
void reset(reset_flags f)
task * try_put_task(const T &v) __TBB_override
internal::type_to_key_function_body< T0, K > * f0_p
tbb::flow::tuple_element< 2, OutputTuple >::type T2
void handle_operations(key_matching_port_operation *op_list)
void handle_operations(key_matching_FE_operation *op_list)
receiver< input_type >::predecessor_type predecessor_type
task * increment_key_count(unref_key_type const &t, bool handle_task) __TBB_override
atomic< size_t > ports_with_no_items
join_node_base(graph &g, FunctionTuple f)
internal::type_to_key_function_body< T1, K > * f1_p
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
key_matching_FE_operation(op_type t)
join_node_base< reserving, InputTuple, OutputTuple > base_node_type
void set_join_node_pointer(forwarding_base *join)
unfolded_join_node(const unfolded_join_node &other)
void reset(reset_flags f)
join_node_FE(const join_node_FE &other)
join_node_base< JP, InputTuple, OutputTuple > class_type
count_element< K > table_item_type
join_node_FE(const join_node_FE &other)
reserving_port_operation(const predecessor_type &s, op_type t)
unfolded_join_node(const unfolded_join_node &other)
bool remove_predecessor(predecessor_type &src) __TBB_override
Remove a predecessor.
broadcast_cache< output_type, null_rw_mutex > my_successors
tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p > func_initializer_type
join_node_base_operation(op_type t)
atomic< size_t > ports_with_no_inputs
bool tuple_build_may_succeed()
reservable_predecessor_cache< T, null_mutex > my_predecessors
join_node_base_operation(const output_type &e, op_type t)
static bool reserve(InputTuple &my_input, OutputTuple &out)
input_type & input_ports()
static void set_key_functors(InputTuple &my_input, KeyFuncTuple &my_key_funcs)
Base class for types that should not be assigned.
task * decrement_port_count(bool) __TBB_override
void spawn_in_graph_arena(graph &g, tbb::task &arena_task)
Spawns a task inside graph arena.
void set_join_node_pointer(forwarding_base *join)
unfolded_join_node(const unfolded_join_node &other)
tbb::flow::tuple< f0_p, f1_p, f2_p > func_initializer_type
tbb::flow::tuple_element< 1, OutputTuple >::type T1
bool register_predecessor(predecessor_type &src) __TBB_override
Add a predecessor.
void increment_port_count() __TBB_override
wrap_key_tuple_elements< 2, key_matching_port, key_matching< K, KHash >, OutputTuple >::type input_ports_type
static bool get_items(InputTuple &my_input, OutputTuple &out)
internal::aggregating_functor< class_type, queueing_port_operation > handler_type
static tbb::task *const SUCCESSFULLY_ENQUEUED
wrap_key_tuple_elements< 4, key_matching_port, key_matching< K, KHash >, OutputTuple >::type input_ports_type
join_node_base< key_matching< key_type, key_hash_compare >, InputTuple, OutputTuple > base_node_type
key_matching_port_operation(const input_type &e, op_type t)
key_matching_port_operation(op_type t)
internal::type_to_key_function_body< T0, K > * f0_p
aggregator< handler_type, key_matching_FE_operation > my_aggregator
matching_forwarding_base< key_type > forwarding_base_type
wrap_key_tuple_elements< 3, key_matching_port, key_matching< K, KHash >, OutputTuple >::type input_ports_type
task * try_put_task(const T &) __TBB_override
queueing_port< T > class_type
input_type & input_ports()
bool is_graph_active(graph &g)
bool push_back(item_type &v)
internal::join_node_base< key_traits_type, typename wrap_key_tuple_elements< N, key_matching_port, key_traits_type, OutputTuple >::type, OutputTuple > type
reserving_port< T > class_type
unfolded_join_node(const unfolded_join_node &other)
task * fill_output_buffer(unref_key_type &t, bool should_enqueue, bool handle_task)
internal::type_to_key_function_body< T4, K > * f4_p
aggregator< handler_type, reserving_port_operation > my_aggregator
friend class run_and_put_task
matching_forwarding_base< key_type > * my_join
void reset_receiver(reset_flags f) __TBB_override
unfolded_join_node(graph &g, Body0 body0, Body1 body1)
current_key_type current_key
internal::type_to_key_function_body< T1, K > * f1_p
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 set_key_func(TraitsType::TtoK *vtk)
bool try_reserve(output_type &v)
bool tuple_build_may_succeed()
join_node_FE : implements input port policy
bool my_item_valid(size_type i) const
void suppress_unused_warning(const T1 &)
Utility template function to prevent "unused" warnings by various compilers.
bool tuple_build_may_succeed()
internal::type_to_key_function_body< T0, K > * f0_p
matching_forwarding_base(graph &g)
bool register_successor(successor_type &r) __TBB_override
Add a new successor to this node.
static void release_my_reservation(TupleType &my_input)
join_node_base(const join_node_base &other)
join_node_base_operation(const successor_type &s, op_type t)
count_element< unref_key_type > count_element_type
forwarding_base(graph &g)
static void set_join_node_pointer(TupleType &my_input, PortType *port)
queueing_port_operation(const T *p, op_type t)
tbb::flow::tuple_element< 0, OutputTuple >::type T0
A cache of successors that are put in a round-robin fashion.
friend class run_and_put_task
field of type K being used for matching.
queueing_port_operation(op_type t)
predecessor_type * my_pred
tbb::internal::strip< key_type >::type unref_key_type
bool find_with_key(const Knoref &k, value_type &v)
aggregator< handler_type, key_matching_port_operation > my_aggregator
void set_join_node_pointer(forwarding_base *join)
record parent for tallying available items
K key_from_message(const T &t)
hash_buffer< unref_key_type &, count_element_type, TtoK_function_body_type, key_hash_compare > key_to_count_buffer_type
void set_my_node(base_node_type *new_my_node)
bool try_to_make_tuple(output_type &out)
task * decrement_port_count(bool handle_task) __TBB_override
item_buffer< output_type > output_buffer_type
TraitsType::KHash hash_compare_type
void increment_port_count() __TBB_override
type_to_key_func_type * get_my_key_func()
queueing_port()
Constructor.
reserving_port()
Constructor.
tbb::flow::tuple_element< 1, OutputTuple >::type T1
internal::aggregating_functor< class_type, key_matching_FE_operation > handler_type
queueing_port_operation(const T &e, op_type t)
graph & graph_reference() __TBB_override
key_to_count_functor< unref_key_type > key_to_count_func
void handle_operations(join_node_base_operation *op_list)
static bool reserve(InputTuple &my_input, OutputTuple &out)
virtual void increment_port_count()=0
void reset_receiver(reset_flags f) __TBB_override
internal::aggregating_functor< class_type, reserving_port_operation > handler_type
join_node_FE< key_matching< key_type, key_hash_compare >, InputTuple, OutputTuple > class_type
internal::type_to_key_function_body< T2, K > * f2_p
static void copy_key_functors(KeyFuncTuple &my_inputs, KeyFuncTuple &other_inputs)
void const char const char int ITT_FORMAT __itt_group_sync p
virtual task * decrement_port_count(bool handle_task)=0
reserving_port_operation(op_type t)
hash_buffer< key_type, input_type, type_to_key_func_type, hash_compare_type > buffer_type
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
graph & graph_reference() __TBB_override
reserving_port(const reserving_port &)
bool try_to_make_tuple(output_type &out)
input_type & input_ports()
static void release_reservations(TupleType &my_input)
tbb::flow::tuple_element< 2, OutputTuple >::type T2
void set_my_node(base_node_type *new_my_node)
tbb::flow::tuple_element< 0, OutputTuple >::type T0
join_node_base< queueing, InputTuple, OutputTuple > base_node_type
static void reset_ports(InputTuple &my_input)
internal::type_to_key_function_body< T0, K > * f0_p
internal::type_to_key_function_body< T2, K > * f2_p
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
join_node_base< key_matching< K, KHash >, input_ports_type, output_type > base_type
tbb::internal::strip< key_type >::type noref_key_type
tbb::flow::tuple_element< 0, OutputTuple >::type T0
const item_type & front() const
internal::aggregating_functor< class_type, join_node_base_operation > handler_type
queueing_port(const queueing_port &)
copy constructor
wrap_tuple_elements< N, PT, OutputTuple >::type input_ports_type
reserving_port_operation(const T &e, op_type t)
internal::type_to_key_function_body< T1, K > * f1_p
key_matching_port< traits > class_type
internal::type_to_key_function_body_leaf< count_element_type, unref_key_type &, key_to_count_func > TtoK_function_body_leaf_type
task * try_put_task(const input_type &v) __TBB_override
Put item to successor; return task to run the successor if possible.
internal::aggregating_functor< class_type, key_matching_port_operation > handler_type
static tbb::task * combine_tasks(graph &g, tbb::task *left, tbb::task *right)
virtual task * increment_key_count(current_key_type const &, bool)=0
static void reset_inputs(InputTuple &my_input, reset_flags f)
unfolded_join_node(graph &g, Body0 body0, Body1 body1, Body2 body2, Body3 body3, Body4 body4)
tbb::flow::tuple_element< 2, OutputTuple >::type T2
internal::type_to_key_function_body< T3, K > * f3_p
receiver< input_type >::predecessor_type predecessor_type
unfolded_join_node(const unfolded_join_node &other)
unfolded_join_node(graph &g)
bool try_get(output_type &v) __TBB_override
Request an item from the sender.
void reset(reset_flags f)
join_node_FE< JP, InputTuple, OutputTuple > input_ports_type
static void set_join_node_pointer(TupleType &my_input, PortType *port)
static bool get_items(InputTuple &my_input, OutputTuple &out)
key_matching_port(const key_matching_port &)
static void copy_key_functors(KeyFuncTuple &my_inputs, KeyFuncTuple &other_inputs)
static void consume_reservations(TupleType &my_input)
#define __TBB_STATIC_ASSERT(condition, msg)
static void reset_inputs(InputTuple &my_input, reset_flags f)
void handle_operations(queueing_port_operation *op_list)
static void reset_ports(InputTuple &my_input)
tbb::flow::tuple_element< 1, OutputTuple >::type T1
static void release_reservations(TupleType &my_input)