Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
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< KeyType >
typedef tbb::internal::strip< KeyType >::type current_key_type
 
- Public Types inherited from hash_buffer< Key, ValueType, ValueToKey, HashCompare, Allocator >
typedef ValueType value_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< Key >::type Knoref
 
- Public Types inherited from internal::item_buffer< T, A >
enum  buffer_item_state { no_item =0, has_item =1, reserved_item =2 }
 
typedef T 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< KeyType >
 matching_forwarding_base (graph &g)
 
- Public Member Functions inherited from internal::forwarding_base
 forwarding_base (graph &g)
 
virtual ~forwarding_base ()
 
- Public Member Functions inherited from hash_buffer< Key, ValueType, ValueToKey, HashCompare, Allocator >
 hash_buffer ()
 
 ~hash_buffer ()
 
void reset ()
 
void set_key_func (ValueToKey *vtk)
 
ValueToKey * 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< T, A >
 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< Key, ValueType, ValueToKey, HashCompare, Allocator >
static const size_t INITIAL_SIZE = 8
 

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< T, A >
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< T, A >
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< KeyType >
current_key_type current_key
 
- Public Attributes inherited from internal::forwarding_base
graph & graph_ref
 
- Protected Types inherited from internal::item_buffer< T, A >
typedef size_t size_type
 
typedef aligned_pair< item_type, buffer_item_state >::type buffer_item_type
 
typedef A::template rebind< buffer_item_type >::other allocator_type
 
- Static Protected Attributes inherited from internal::item_buffer< T, A >
static const size_type initial_buffer_size = 4
 

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 1026 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 1055 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 1063 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 1045 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 1056 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 1081 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 1040 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 1043 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 1053 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 1047 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 1041 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 1054 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 1039 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 1049 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 1048 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 1042 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 1166 of file _flow_graph_join_impl.h.

References internal::join_helper< N >::set_join_node_pointer(), and internal::join_helper< N >::set_key_functors().

1166  : forwarding_base_type(g), my_node(NULL) {
1169  my_aggregator.initialize_handler(handler_type(this));
1171  this->set_key_func(cfb);
1172  }
static void set_key_functors(InputTuple &my_input, KeyFuncTuple &my_key_funcs)
static void set_join_node_pointer(TupleType &my_input, PortType *port)
internal::type_to_key_function_body_leaf< count_element_type, unref_key_type &, key_to_count_func > TtoK_function_body_leaf_type
internal::aggregating_functor< class_type, key_matching_FE_operation > handler_type
aggregator< handler_type, key_matching_FE_operation > my_aggregator
void set_key_func(ValueToKey *vtk)
internal::type_to_key_function_body< count_element_type, unref_key_type & > TtoK_function_body_type
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 1174 of file _flow_graph_join_impl.h.

References internal::join_helper< N >::copy_key_functors(), and internal::join_helper< N >::set_join_node_pointer().

1174  : forwarding_base_type((other.forwarding_base_type::graph_ref)), key_to_count_buffer_type(),
1175  output_buffer_type() {
1176  my_node = NULL;
1178  join_helper<N>::copy_key_functors(my_inputs, const_cast<input_type &>(other.my_inputs));
1179  my_aggregator.initialize_handler(handler_type(this));
1181  this->set_key_func(cfb);
1182  }
hash_buffer< unref_key_type &, count_element_type, TtoK_function_body_type, key_hash_compare > key_to_count_buffer_type
static void set_join_node_pointer(TupleType &my_input, PortType *port)
internal::type_to_key_function_body_leaf< count_element_type, unref_key_type &, key_to_count_func > TtoK_function_body_leaf_type
internal::aggregating_functor< class_type, key_matching_FE_operation > handler_type
aggregator< handler_type, key_matching_FE_operation > my_aggregator
static void copy_key_functors(KeyFuncTuple &my_inputs, KeyFuncTuple &other_inputs)
void set_key_func(ValueToKey *vtk)
internal::type_to_key_function_body< count_element_type, unref_key_type & > TtoK_function_body_type
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 1201 of file _flow_graph_join_impl.h.

References __TBB_ASSERT.

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

◆ 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 1088 of file _flow_graph_join_impl.h.

References __TBB_ASSERT, internal::forwarding_base::graph_ref, tbb::flow::interface10::internal::is_graph_active(), internal::join_helper< N >::reset_ports(), tbb::flow::interface10::internal::spawn_in_graph_arena(), and task.

1088  {
1089  output_type l_out;
1090  task *rtask = NULL;
1091  bool do_fwd = should_enqueue && this->buffer_empty() && internal::is_graph_active(this->graph_ref);
1092  this->current_key = t;
1093  this->delete_with_key(this->current_key); // remove the key
1094  if(join_helper<N>::get_items(my_inputs, l_out)) { // <== call back
1095  this->push_back(l_out);
1096  if(do_fwd) { // we enqueue if receiving an item from predecessor, not if successor asks for item
1097  rtask = new ( task::allocate_additional_child_of( *(this->graph_ref.root_task()) ) )
1098  forward_task_bypass<base_node_type>(*my_node);
1099  if(handle_task) {
1101  rtask = NULL;
1102  }
1103  do_fwd = false;
1104  }
1105  // retire the input values
1106  join_helper<N>::reset_ports(my_inputs); // <== call back
1107  }
1108  else {
1109  __TBB_ASSERT(false, "should have had something to push");
1110  }
1111  return rtask;
1112  }
void delete_with_key(const Knoref &k)
static bool get_items(InputTuple &my_input, OutputTuple &out)
void spawn_in_graph_arena(graph &g, tbb::task &arena_task)
Spawns a task inside graph arena.
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
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 void reset_ports(InputTuple &my_input)
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 1114 of file _flow_graph_join_impl.h.

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

1114  {
1115  key_matching_FE_operation *current;
1116  while(op_list) {
1117  current = op_list;
1118  op_list = op_list->next;
1119  switch(current->type) {
1120  case res_count: // called from BE
1121  {
1122  this->destroy_front();
1123  __TBB_store_with_release(current->status, SUCCEEDED);
1124  }
1125  break;
1126  case inc_count: { // called from input ports
1127  count_element_type *p = 0;
1128  unref_key_type &t = current->my_val;
1129  bool do_enqueue = current->enqueue_task;
1130  if(!(this->find_ref_with_key(t,p))) {
1131  count_element_type ev;
1132  ev.my_key = t;
1133  ev.my_value = 0;
1134  this->insert_with_key(ev);
1135  if(!(this->find_ref_with_key(t,p))) {
1136  __TBB_ASSERT(false, "should find key after inserting it");
1137  }
1138  }
1139  if(++(p->my_value) == size_t(N)) {
1140  task *rtask = fill_output_buffer(t, true, do_enqueue);
1141  __TBB_ASSERT(!rtask || !do_enqueue, "task should not be returned");
1142  current->bypass_t = rtask;
1143  }
1144  }
1145  __TBB_store_with_release(current->status, SUCCEEDED);
1146  break;
1147  case may_succeed: // called from BE
1148  __TBB_store_with_release(current->status, this->buffer_empty() ? FAILED : SUCCEEDED);
1149  break;
1150  case try_make: // called from BE
1151  if(this->buffer_empty()) {
1152  __TBB_store_with_release(current->status, FAILED);
1153  }
1154  else {
1155  *(current->my_output) = this->front();
1156  __TBB_store_with_release(current->status, SUCCEEDED);
1157  }
1158  break;
1159  }
1160  }
1161  }
const item_type & front() const
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
bool find_ref_with_key(const Knoref &k, pointer_type &v)
void __TBB_store_with_release(volatile T &location, V value)
Definition: tbb_machine.h:716
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
bool insert_with_key(const value_type &v)
void const char const char int ITT_FORMAT __itt_group_sync p
task * fill_output_buffer(unref_key_type &t, bool should_enqueue, bool handle_task)
Here is the call graph for this function:

◆ 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< KeyType >.

Definition at line 1195 of file _flow_graph_join_impl.h.

1195  { // called from input_ports
1196  key_matching_FE_operation op_data(t, handle_task, inc_count);
1197  my_aggregator.execute(&op_data);
1198  return op_data.bypass_t;
1199  }
aggregator< handler_type, key_matching_FE_operation > my_aggregator

◆ 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 1203 of file _flow_graph_join_impl.h.

References __TBB_ASSERT.

1203 { __TBB_ASSERT(false, NULL); } // should never be called
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165

◆ 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

◆ 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 1209 of file _flow_graph_join_impl.h.

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

1209  {
1210  // called outside of parallel contexts
1212 
1213  key_to_count_buffer_type::reset();
1214  output_buffer_type::reset();
1215  }
static void reset_inputs(InputTuple &my_input, reset_flags f)
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 1187 of file _flow_graph_join_impl.h.

1187  { // called from BE
1188  key_matching_FE_operation op_data(res_count);
1189  my_aggregator.execute(&op_data);
1190  return;
1191  }
aggregator< handler_type, key_matching_FE_operation > my_aggregator

◆ 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

◆ 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 1236 of file _flow_graph_join_impl.h.

References SUCCEEDED.

1236  {
1237  key_matching_FE_operation op_data(&out,try_make);
1238  my_aggregator.execute(&op_data);
1239  return op_data.status == SUCCEEDED;
1240  }
aggregator< handler_type, key_matching_FE_operation > my_aggregator

◆ 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 1242 of file _flow_graph_join_impl.h.

1242  {
1243  reset_port_count(); // reset current_key after ports reset.
1244  }

◆ 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 1228 of file _flow_graph_join_impl.h.

References SUCCEEDED.

1228  { // called from back-end
1229  key_matching_FE_operation op_data(may_succeed);
1230  my_aggregator.execute(&op_data);
1231  return op_data.status == SUCCEEDED;
1232  }
aggregator< handler_type, key_matching_FE_operation > my_aggregator

◆ 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 1246 of file _flow_graph_join_impl.h.

1246  {
1247  // nothing to do.
1248  }

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 1082 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 1083 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 1250 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 1251 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 1038 of file _flow_graph_join_impl.h.


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

Copyright © 2005-2019 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.