Intel(R) Threading Building Blocks Doxygen Documentation version 4.2.3
Loading...
Searching...
No Matches
internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple > Class Template Reference

#include <_flow_graph_join_impl.h>

Inheritance diagram for internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >:
Collaboration diagram for internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >:

Classes

class  key_matching_FE_operation
 

Public Types

typedef OutputTuple output_type
 
typedef InputTuple input_type
 
typedef K key_type
 
typedef tbb::internal::strip< key_type >::type unref_key_type
 
typedef KHash key_hash_compare
 
typedef count_element< unref_key_typecount_element_type
 
typedef key_to_count_functor< unref_key_typekey_to_count_func
 
typedef internal::type_to_key_function_body< count_element_type, unref_key_type & > TtoK_function_body_type
 
typedef internal::type_to_key_function_body_leaf< count_element_type, unref_key_type &, key_to_count_funcTtoK_function_body_leaf_type
 
typedef hash_buffer< unref_key_type &, count_element_type, TtoK_function_body_type, key_hash_comparekey_to_count_buffer_type
 
typedef item_buffer< output_typeoutput_buffer_type
 
typedef join_node_base< key_matching< key_type, key_hash_compare >, InputTuple, OutputTuple > base_node_type
 
typedef matching_forwarding_base< key_typeforwarding_base_type
 
- Public Types inherited from internal::matching_forwarding_base< K >
typedef tbb::internal::strip< K >::type current_key_type
 
- Public Types inherited from hash_buffer< tbb::internal::strip< K >::type &, count_element< tbb::internal::strip< K >::type >, internal::type_to_key_function_body< count_element< tbb::internal::strip< K >::type >, tbb::internal::strip< K >::type & >, KHash >
typedef count_element< tbb::internal::strip< K >::typevalue_type
 
typedef buffer_element_type< value_type >::type element_type
 
typedef value_typepointer_type
 
typedef element_typelist_array_type
 
typedef list_array_typepointer_array_type
 
typedef Allocator::template rebind< list_array_type >::other pointer_array_allocator_type
 
typedef Allocator::template rebind< element_type >::other elements_array_allocator
 
typedef tbb::internal::strip< tbb::internal::strip< K >::type & >::type Knoref
 
- Public Types inherited from internal::item_buffer< OutputTuple >
enum  buffer_item_state
 
typedef OutputTuple item_type
 

Public Member Functions

template<typename FunctionTuple >
 join_node_FE (graph &g, FunctionTuple &TtoK_funcs)
 
 join_node_FE (const join_node_FE &other)
 
void set_my_node (base_node_type *new_my_node)
 
void reset_port_count ()
 
taskincrement_key_count (unref_key_type const &t, bool handle_task) __TBB_override
 
taskdecrement_port_count (bool) __TBB_override
 
void increment_port_count () __TBB_override
 
input_typeinput_ports ()
 
- Public Member Functions inherited from internal::matching_forwarding_base< K >
 matching_forwarding_base (graph &g)
 
virtual taskincrement_key_count (current_key_type const &, bool)=0
 
- Public Member Functions inherited from internal::forwarding_base
 forwarding_base (graph &g)
 
virtual ~forwarding_base ()
 
virtual taskdecrement_port_count (bool handle_task)=0
 
virtual void increment_port_count ()=0
 
- Public Member Functions inherited from tbb::internal::no_assign
void operator= (const no_assign &)=delete
 
 no_assign (const no_assign &)=default
 
 no_assign ()=default
 
- Public Member Functions inherited from hash_buffer< tbb::internal::strip< K >::type &, count_element< tbb::internal::strip< K >::type >, internal::type_to_key_function_body< count_element< tbb::internal::strip< K >::type >, tbb::internal::strip< K >::type & >, KHash >
 hash_buffer ()
 
 ~hash_buffer ()
 
void reset ()
 
void set_key_func (internal::type_to_key_function_body< count_element< tbb::internal::strip< K >::type >, tbb::internal::strip< K >::type & > *vtk)
 
internal::type_to_key_function_body< count_element< tbb::internal::strip< K >::type >, tbb::internal::strip< K >::type & > * get_key_func ()
 
bool insert_with_key (const value_type &v)
 
bool find_ref_with_key (const Knoref &k, pointer_type &v)
 
bool find_with_key (const Knoref &k, value_type &v)
 
void delete_with_key (const Knoref &k)
 
- Public Member Functions inherited from internal::item_buffer< OutputTuple >
 item_buffer ()
 Constructor. More...
 
 ~item_buffer ()
 
void reset ()
 

Static Public Attributes

static const int N = tbb::flow::tuple_size<OutputTuple>::value
 
- Static Public Attributes inherited from hash_buffer< tbb::internal::strip< K >::type &, count_element< tbb::internal::strip< K >::type >, internal::type_to_key_function_body< count_element< tbb::internal::strip< K >::type >, tbb::internal::strip< K >::type & >, KHash >
static const size_t INITIAL_SIZE
 

Protected Member Functions

void reset (reset_flags f)
 
bool tuple_build_may_succeed ()
 
bool try_to_make_tuple (output_type &out)
 
void tuple_accepted ()
 
void tuple_rejected ()
 
- Protected Member Functions inherited from internal::item_buffer< OutputTuple >
bool buffer_empty () const
 
buffer_item_typeitem (size_type i)
 
const buffer_item_typeitem (size_type i) const
 
bool my_item_valid (size_type i) const
 
bool my_item_reserved (size_type i) const
 
const item_typeget_my_item (size_t i) const
 
void set_my_item (size_t i, const item_type &o)
 
void fetch_item (size_t i, item_type &o)
 
void move_item (size_t to, size_t from)
 
bool place_item (size_t here, const item_type &me)
 
void swap_items (size_t i, size_t j)
 
void destroy_item (size_type i)
 
const item_typefront () const
 
const item_typeback () const
 
void reserve_item (size_type i)
 
void release_item (size_type i)
 
void destroy_front ()
 
void destroy_back ()
 
size_type size (size_t new_tail=0)
 
size_type capacity ()
 
bool buffer_full ()
 
void grow_my_array (size_t minimum_size)
 Grows the internal array. More...
 
bool push_back (item_type &v)
 
bool pop_back (item_type &v)
 
bool pop_front (item_type &v)
 
void clean_up_buffer (bool reset_pointers)
 

Protected Attributes

input_type my_inputs
 
base_node_typemy_node
 
- Protected Attributes inherited from internal::item_buffer< OutputTuple >
buffer_item_typemy_array
 
size_type my_array_size
 
size_type my_head
 
size_type my_tail
 

Private Types

enum  op_type { res_count , inc_count , may_succeed , try_make }
 
typedef join_node_FE< key_matching< key_type, key_hash_compare >, InputTuple, OutputTuple > class_type
 
typedef internal::aggregating_functor< class_type, key_matching_FE_operation > handler_type
 

Private Member Functions

taskfill_output_buffer (unref_key_type &t, bool should_enqueue, bool handle_task)
 
void handle_operations (key_matching_FE_operation *op_list)
 

Private Attributes

aggregator< handler_type, key_matching_FE_operation > my_aggregator
 

Friends

class internal::aggregating_functor< class_type, key_matching_FE_operation >
 

Additional Inherited Members

- Public Attributes inherited from internal::matching_forwarding_base< K >
current_key_type current_key
 
- Public Attributes inherited from internal::forwarding_base
graph & graph_ref
 
- Protected Types inherited from internal::item_buffer< OutputTuple >
typedef size_t size_type
 
typedef aligned_pair< item_type, buffer_item_state >::type buffer_item_type
 
typedef tbb::internal::allocator_rebind< cache_aligned_allocator< OutputTuple >, buffer_item_type >::type allocator_type
 
- Static Protected Attributes inherited from internal::item_buffer< OutputTuple >
static const size_type initial_buffer_size
 

Detailed Description

template<typename InputTuple, typename OutputTuple, typename K, typename KHash>
class internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >

Definition at line 1034 of file _flow_graph_join_impl.h.

Member Typedef Documentation

◆ base_node_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef join_node_base<key_matching<key_type,key_hash_compare>, InputTuple, OutputTuple> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::base_node_type

Definition at line 1063 of file _flow_graph_join_impl.h.

◆ class_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef join_node_FE<key_matching<key_type,key_hash_compare>, InputTuple, OutputTuple> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::class_type
private

Definition at line 1071 of file _flow_graph_join_impl.h.

◆ count_element_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef count_element<unref_key_type> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::count_element_type

Definition at line 1053 of file _flow_graph_join_impl.h.

◆ forwarding_base_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef matching_forwarding_base<key_type> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::forwarding_base_type

Definition at line 1064 of file _flow_graph_join_impl.h.

◆ handler_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef internal::aggregating_functor<class_type, key_matching_FE_operation> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::handler_type
private

Definition at line 1089 of file _flow_graph_join_impl.h.

◆ input_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef InputTuple internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::input_type

Definition at line 1048 of file _flow_graph_join_impl.h.

◆ key_hash_compare

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef KHash internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::key_hash_compare

Definition at line 1051 of file _flow_graph_join_impl.h.

◆ key_to_count_buffer_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef hash_buffer< unref_key_type&, count_element_type, TtoK_function_body_type, key_hash_compare > internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::key_to_count_buffer_type

Definition at line 1061 of file _flow_graph_join_impl.h.

◆ key_to_count_func

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef key_to_count_functor<unref_key_type> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::key_to_count_func

Definition at line 1055 of file _flow_graph_join_impl.h.

◆ key_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef K internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::key_type

Definition at line 1049 of file _flow_graph_join_impl.h.

◆ output_buffer_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef item_buffer<output_type> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::output_buffer_type

Definition at line 1062 of file _flow_graph_join_impl.h.

◆ output_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef OutputTuple internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::output_type

Definition at line 1047 of file _flow_graph_join_impl.h.

◆ TtoK_function_body_leaf_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef internal::type_to_key_function_body_leaf<count_element_type, unref_key_type&, key_to_count_func> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::TtoK_function_body_leaf_type

Definition at line 1057 of file _flow_graph_join_impl.h.

◆ TtoK_function_body_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef internal::type_to_key_function_body< count_element_type, unref_key_type&> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::TtoK_function_body_type

Definition at line 1056 of file _flow_graph_join_impl.h.

◆ unref_key_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
typedef tbb::internal::strip<key_type>::type internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::unref_key_type

Definition at line 1050 of file _flow_graph_join_impl.h.

Member Enumeration Documentation

◆ op_type

Constructor & Destructor Documentation

◆ join_node_FE() [1/2]

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
template<typename FunctionTuple >
internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::join_node_FE ( graph &  g,
FunctionTuple &  TtoK_funcs 
)
inline

Definition at line 1174 of file _flow_graph_join_impl.h.

1174 : forwarding_base_type(g), my_node(NULL) {
1177 my_aggregator.initialize_handler(handler_type(this));
1179 this->set_key_func(cfb);
1180 }
static void set_join_node_pointer(TupleType &my_input, PortType *port)
static void set_key_functors(InputTuple &my_input, KeyFuncTuple &my_key_funcs)
aggregator< handler_type, key_matching_FE_operation > my_aggregator
internal::type_to_key_function_body< count_element_type, unref_key_type & > TtoK_function_body_type
internal::aggregating_functor< class_type, key_matching_FE_operation > handler_type
internal::type_to_key_function_body_leaf< count_element_type, unref_key_type &, key_to_count_func > TtoK_function_body_leaf_type

References tbb::interface6::internal::aggregator< handler_type, operation_type >::initialize_handler(), internal::join_helper< N >::set_join_node_pointer(), and internal::join_helper< N >::set_key_functors().

Here is the call graph for this function:

◆ join_node_FE() [2/2]

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::join_node_FE ( const join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple > &  other)
inline

Definition at line 1182 of file _flow_graph_join_impl.h.

1182 : forwarding_base_type((other.forwarding_base_type::graph_ref)), key_to_count_buffer_type(),
1184 my_node = NULL;
1186 join_helper<N>::copy_key_functors(my_inputs, const_cast<input_type &>(other.my_inputs));
1187 my_aggregator.initialize_handler(handler_type(this));
1189 this->set_key_func(cfb);
1190 }
static void copy_key_functors(KeyFuncTuple &my_inputs, KeyFuncTuple &other_inputs)
hash_buffer< unref_key_type &, count_element_type, TtoK_function_body_type, key_hash_compare > key_to_count_buffer_type

References internal::join_helper< N >::copy_key_functors(), tbb::interface6::internal::aggregator< handler_type, operation_type >::initialize_handler(), and internal::join_helper< N >::set_join_node_pointer().

Here is the call graph for this function:

Member Function Documentation

◆ decrement_port_count()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
task * internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::decrement_port_count ( bool  )
inlinevirtual

Implements internal::forwarding_base.

Definition at line 1209 of file _flow_graph_join_impl.h.

1209{ __TBB_ASSERT(false, NULL); return NULL; }
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165

References __TBB_ASSERT.

◆ fill_output_buffer()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
task * internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::fill_output_buffer ( unref_key_type t,
bool  should_enqueue,
bool  handle_task 
)
inlineprivate

Definition at line 1096 of file _flow_graph_join_impl.h.

1096 {
1097 output_type l_out;
1098 task *rtask = NULL;
1099 bool do_fwd = should_enqueue && this->buffer_empty() && internal::is_graph_active(this->graph_ref);
1100 this->current_key = t;
1101 this->delete_with_key(this->current_key); // remove the key
1102 if(join_helper<N>::get_items(my_inputs, l_out)) { // <== call back
1103 this->push_back(l_out);
1104 if(do_fwd) { // we enqueue if receiving an item from predecessor, not if successor asks for item
1105 rtask = new ( task::allocate_additional_child_of( *(this->graph_ref.root_task()) ) )
1106 forward_task_bypass<base_node_type>(*my_node);
1107 if(handle_task) {
1108 internal::spawn_in_graph_arena(this->graph_ref, *rtask);
1109 rtask = NULL;
1110 }
1111 do_fwd = false;
1112 }
1113 // retire the input values
1114 join_helper<N>::reset_ports(my_inputs); // <== call back
1115 }
1116 else {
1117 __TBB_ASSERT(false, "should have had something to push");
1118 }
1119 return rtask;
1120 }
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
static bool get_items(InputTuple &my_input, OutputTuple &out)
static void reset_ports(InputTuple &my_input)

References __TBB_ASSERT, internal::join_helper< N >::reset_ports(), and task.

Here is the call graph for this function:

◆ handle_operations()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::handle_operations ( key_matching_FE_operation *  op_list)
inlineprivate

Definition at line 1122 of file _flow_graph_join_impl.h.

1122 {
1123 key_matching_FE_operation *current;
1124 while(op_list) {
1125 current = op_list;
1126 op_list = op_list->next;
1127 switch(current->type) {
1128 case res_count: // called from BE
1129 {
1130 this->destroy_front();
1131 __TBB_store_with_release(current->status, SUCCEEDED);
1132 }
1133 break;
1134 case inc_count: { // called from input ports
1135 count_element_type *p = 0;
1136 unref_key_type &t = current->my_val;
1137 bool do_enqueue = current->enqueue_task;
1138 if(!(this->find_ref_with_key(t,p))) {
1140 ev.my_key = t;
1141 ev.my_value = 0;
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");
1145 }
1146 }
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;
1151 }
1152 }
1153 __TBB_store_with_release(current->status, SUCCEEDED);
1154 break;
1155 case may_succeed: // called from BE
1156 __TBB_store_with_release(current->status, this->buffer_empty() ? FAILED : SUCCEEDED);
1157 break;
1158 case try_make: // called from BE
1159 if(this->buffer_empty()) {
1160 __TBB_store_with_release(current->status, FAILED);
1161 }
1162 else {
1163 *(current->my_output) = this->front();
1164 __TBB_store_with_release(current->status, SUCCEEDED);
1165 }
1166 break;
1167 }
1168 }
1169 }
void const char const char int ITT_FORMAT __itt_group_sync p
void __TBB_store_with_release(volatile T &location, V value)
Definition: tbb_machine.h:713
task * fill_output_buffer(unref_key_type &t, bool should_enqueue, bool handle_task)

References __TBB_ASSERT, internal::FAILED, internal::count_element< K >::my_key, internal::count_element< K >::my_value, p, internal::SUCCEEDED, and task.

◆ increment_key_count()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
task * internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::increment_key_count ( unref_key_type const &  t,
bool  handle_task 
)
inlinevirtual

Implements internal::matching_forwarding_base< K >.

Definition at line 1203 of file _flow_graph_join_impl.h.

1203 { // called from input_ports
1204 key_matching_FE_operation op_data(t, handle_task, inc_count);
1205 my_aggregator.execute(&op_data);
1206 return op_data.bypass_t;
1207 }

References tbb::interface6::internal::aggregator< handler_type, operation_type >::execute().

Here is the call graph for this function:

◆ increment_port_count()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::increment_port_count ( )
inlinevirtual

Implements internal::forwarding_base.

Definition at line 1211 of file _flow_graph_join_impl.h.

1211{ __TBB_ASSERT(false, NULL); } // should never be called

References __TBB_ASSERT.

◆ input_ports()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
input_type & internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::input_ports ( )
inline

Definition at line 1213 of file _flow_graph_join_impl.h.

1213{ return my_inputs; }

◆ reset()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::reset ( reset_flags  f)
inlineprotected

Definition at line 1217 of file _flow_graph_join_impl.h.

1217 {
1218 // called outside of parallel contexts
1220
1223 }
static void reset_inputs(InputTuple &my_input, reset_flags f)

References internal::join_helper< N >::reset_inputs().

Here is the call graph for this function:

◆ reset_port_count()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::reset_port_count ( )
inline

Definition at line 1195 of file _flow_graph_join_impl.h.

1195 { // called from BE
1196 key_matching_FE_operation op_data(res_count);
1197 my_aggregator.execute(&op_data);
1198 return;
1199 }

References tbb::interface6::internal::aggregator< handler_type, operation_type >::execute().

Here is the call graph for this function:

◆ set_my_node()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::set_my_node ( base_node_type new_my_node)
inline

Definition at line 1193 of file _flow_graph_join_impl.h.

1193{ my_node = new_my_node; }

◆ try_to_make_tuple()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
bool internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::try_to_make_tuple ( output_type out)
inlineprotected

Definition at line 1244 of file _flow_graph_join_impl.h.

1244 {
1245 key_matching_FE_operation op_data(&out,try_make);
1246 my_aggregator.execute(&op_data);
1247 return op_data.status == SUCCEEDED;
1248 }

References tbb::interface6::internal::aggregator< handler_type, operation_type >::execute(), and internal::SUCCEEDED.

Here is the call graph for this function:

◆ tuple_accepted()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::tuple_accepted ( )
inlineprotected

Definition at line 1250 of file _flow_graph_join_impl.h.

1250 {
1251 reset_port_count(); // reset current_key after ports reset.
1252 }

◆ tuple_build_may_succeed()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
bool internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::tuple_build_may_succeed ( )
inlineprotected

Definition at line 1236 of file _flow_graph_join_impl.h.

1236 { // called from back-end
1237 key_matching_FE_operation op_data(may_succeed);
1238 my_aggregator.execute(&op_data);
1239 return op_data.status == SUCCEEDED;
1240 }

References tbb::interface6::internal::aggregator< handler_type, operation_type >::execute(), and internal::SUCCEEDED.

Here is the call graph for this function:

◆ tuple_rejected()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::tuple_rejected ( )
inlineprotected

Definition at line 1254 of file _flow_graph_join_impl.h.

1254 {
1255 // nothing to do.
1256 }

Friends And Related Function Documentation

◆ internal::aggregating_functor< class_type, key_matching_FE_operation >

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
friend class internal::aggregating_functor< class_type, key_matching_FE_operation >
friend

Definition at line 1089 of file _flow_graph_join_impl.h.

Member Data Documentation

◆ my_aggregator

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
aggregator<handler_type, key_matching_FE_operation> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::my_aggregator
private

Definition at line 1091 of file _flow_graph_join_impl.h.

◆ my_inputs

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
input_type internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::my_inputs
protected

Definition at line 1258 of file _flow_graph_join_impl.h.

◆ my_node

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
base_node_type* internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::my_node
protected

Definition at line 1259 of file _flow_graph_join_impl.h.

◆ N

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >
const int internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::N = tbb::flow::tuple_size<OutputTuple>::value
static

Definition at line 1046 of file _flow_graph_join_impl.h.


The documentation for this class was generated from the following file:

Copyright © 2005-2020 Intel Corporation. All Rights Reserved.

Intel, Pentium, Intel Xeon, Itanium, Intel XScale and VTune are registered trademarks or trademarks of Intel Corporation or its subsidiaries in the United States and other countries.

* Other names and brands may be claimed as the property of others.