Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
internal::reserving_port< T > Class Template Reference

The two-phase join port. More...

#include <_flow_graph_join_impl.h>

Inheritance diagram for internal::reserving_port< T >:
Collaboration diagram for internal::reserving_port< T >:

Classes

class  reserving_port_operation
 

Public Types

typedef T input_type
 
typedef receiver< input_type >::predecessor_type predecessor_type
 

Public Member Functions

 reserving_port ()
 Constructor. More...
 
 reserving_port (const reserving_port &)
 
void set_join_node_pointer (forwarding_base *join)
 
bool register_predecessor (predecessor_type &src) __TBB_override
 Add a predecessor. More...
 
bool remove_predecessor (predecessor_type &src) __TBB_override
 Remove a predecessor. More...
 
bool reserve (T &v)
 Reserve an item from the port. More...
 
void release ()
 Release the port. More...
 
void consume ()
 Complete use of the port. More...
 
void reset_receiver (reset_flags f) __TBB_override
 

Protected Member Functions

tasktry_put_task (const T &) __TBB_override
 
graph & graph_reference () __TBB_override
 

Private Types

enum  op_type {
  reg_pred, rem_pred, res_item, rel_res,
  con_res
}
 
enum  op_stat { WAIT =0, SUCCEEDED, FAILED }
 
typedef reserving_port< T > class_type
 
typedef internal::aggregating_functor< class_type, reserving_port_operationhandler_type
 

Private Member Functions

void handle_operations (reserving_port_operation *op_list)
 

Private Attributes

aggregator< handler_type, reserving_port_operationmy_aggregator
 
forwarding_basemy_join
 
reservable_predecessor_cache< T, null_mutex > my_predecessors
 
bool reserved
 

Friends

class internal::aggregating_functor< class_type, reserving_port_operation >
 
template<typename R , typename B >
class run_and_put_task
 
template<typename X , typename Y >
class internal::broadcast_cache
 
template<typename X , typename Y >
class internal::round_robin_cache
 

Detailed Description

template<typename T>
class internal::reserving_port< T >

The two-phase join port.

Definition at line 213 of file _flow_graph_join_impl.h.

Member Typedef Documentation

◆ class_type

template<typename T >
typedef reserving_port<T> internal::reserving_port< T >::class_type
private

Definition at line 229 of file _flow_graph_join_impl.h.

◆ handler_type

template<typename T >
typedef internal::aggregating_functor<class_type, reserving_port_operation> internal::reserving_port< T >::handler_type
private

Definition at line 249 of file _flow_graph_join_impl.h.

◆ input_type

template<typename T >
typedef T internal::reserving_port< T >::input_type

Definition at line 215 of file _flow_graph_join_impl.h.

◆ predecessor_type

template<typename T >
typedef receiver<input_type>::predecessor_type internal::reserving_port< T >::predecessor_type

Definition at line 216 of file _flow_graph_join_impl.h.

Member Enumeration Documentation

◆ op_stat

◆ op_type

template<typename T >
enum internal::reserving_port::op_type
private
Enumerator
reg_pred 
rem_pred 
res_item 
rel_res 
con_res 

Definition at line 223 of file _flow_graph_join_impl.h.

Constructor & Destructor Documentation

◆ reserving_port() [1/2]

template<typename T >
internal::reserving_port< T >::reserving_port ( )
inline

Constructor.

Definition at line 334 of file _flow_graph_join_impl.h.

334  : reserved(false) {
335  my_join = NULL;
336  my_predecessors.set_owner( this );
337  my_aggregator.initialize_handler(handler_type(this));
338  }
void set_owner(successor_type *owner)
aggregator< handler_type, reserving_port_operation > my_aggregator
reservable_predecessor_cache< T, null_mutex > my_predecessors
internal::aggregating_functor< class_type, reserving_port_operation > handler_type

References internal::reserving_port< T >::my_aggregator, internal::reserving_port< T >::my_join, internal::reserving_port< T >::my_predecessors, and internal::predecessor_cache< T, M >::set_owner().

Here is the call graph for this function:

◆ reserving_port() [2/2]

template<typename T >
internal::reserving_port< T >::reserving_port ( const reserving_port< T > &  )
inline

Definition at line 341 of file _flow_graph_join_impl.h.

341  : receiver<T>() {
342  reserved = false;
343  my_join = NULL;
344  my_predecessors.set_owner( this );
345  my_aggregator.initialize_handler(handler_type(this));
346  }
void set_owner(successor_type *owner)
aggregator< handler_type, reserving_port_operation > my_aggregator
reservable_predecessor_cache< T, null_mutex > my_predecessors
internal::aggregating_functor< class_type, reserving_port_operation > handler_type

References internal::reserving_port< T >::my_aggregator, internal::reserving_port< T >::my_join, internal::reserving_port< T >::my_predecessors, internal::reserving_port< T >::reserved, and internal::predecessor_cache< T, M >::set_owner().

Here is the call graph for this function:

Member Function Documentation

◆ consume()

template<typename T >
void internal::reserving_port< T >::consume ( )
inline

Complete use of the port.

Definition at line 380 of file _flow_graph_join_impl.h.

380  {
381  reserving_port_operation op_data(con_res);
382  my_aggregator.execute(&op_data);
383  }
aggregator< handler_type, reserving_port_operation > my_aggregator

References internal::reserving_port< T >::con_res, and internal::reserving_port< T >::my_aggregator.

◆ graph_reference()

template<typename T >
graph& internal::reserving_port< T >::graph_reference ( )
inlineprotected

◆ handle_operations()

template<typename T >
void internal::reserving_port< T >::handle_operations ( reserving_port_operation op_list)
inlineprivate

Definition at line 253 of file _flow_graph_join_impl.h.

253  {
254  reserving_port_operation *current;
255  bool no_predecessors;
256  while(op_list) {
257  current = op_list;
258  op_list = op_list->next;
259  switch(current->type) {
260  case reg_pred:
261  no_predecessors = my_predecessors.empty();
262  my_predecessors.add(*(current->my_pred));
263  if ( no_predecessors ) {
264  (void) my_join->decrement_port_count(true); // may try to forward
265  }
266  __TBB_store_with_release(current->status, SUCCEEDED);
267  break;
268  case rem_pred:
269  my_predecessors.remove(*(current->my_pred));
271  __TBB_store_with_release(current->status, SUCCEEDED);
272  break;
273  case res_item:
274  if ( reserved ) {
275  __TBB_store_with_release(current->status, FAILED);
276  }
277  else if ( my_predecessors.try_reserve( *(current->my_arg) ) ) {
278  reserved = true;
279  __TBB_store_with_release(current->status, SUCCEEDED);
280  } else {
281  if ( my_predecessors.empty() ) {
283  }
284  __TBB_store_with_release(current->status, FAILED);
285  }
286  break;
287  case rel_res:
288  reserved = false;
290  __TBB_store_with_release(current->status, SUCCEEDED);
291  break;
292  case con_res:
293  reserved = false;
295  __TBB_store_with_release(current->status, SUCCEEDED);
296  break;
297 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
298  case add_blt_pred:
299  my_predecessors.internal_add_built_predecessor(*(current->my_pred));
300  __TBB_store_with_release(current->status, SUCCEEDED);
301  break;
302  case del_blt_pred:
303  my_predecessors.internal_delete_built_predecessor(*(current->my_pred));
304  __TBB_store_with_release(current->status, SUCCEEDED);
305  break;
306  case blt_pred_cnt:
307  current->cnt_val = my_predecessors.predecessor_count();
308  __TBB_store_with_release(current->status, SUCCEEDED);
309  break;
310  case blt_pred_cpy:
311  my_predecessors.copy_predecessors(*(current->plist));
312  __TBB_store_with_release(current->status, SUCCEEDED);
313  break;
314 #endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
315  }
316  }
317  }
virtual void increment_port_count()=0
reservable_predecessor_cache< T, null_mutex > my_predecessors
virtual task * decrement_port_count(bool handle_task)=0
void __TBB_store_with_release(volatile T &location, V value)
Definition: tbb_machine.h:717

References tbb::internal::__TBB_store_with_release(), internal::node_cache< T, M >::add(), internal::reserving_port< T >::con_res, internal::forwarding_base::decrement_port_count(), internal::node_cache< T, M >::empty(), internal::reserving_port< T >::FAILED, internal::forwarding_base::increment_port_count(), internal::reserving_port< T >::reserving_port_operation::my_arg, internal::reserving_port< T >::my_join, internal::reserving_port< T >::reserving_port_operation::my_pred, internal::reserving_port< T >::my_predecessors, internal::reserving_port< T >::reg_pred, internal::reserving_port< T >::rel_res, internal::reserving_port< T >::rem_pred, internal::node_cache< T, M >::remove(), internal::reserving_port< T >::res_item, internal::reserving_port< T >::reserved, internal::reserving_port< T >::SUCCEEDED, internal::reservable_predecessor_cache< T, M >::try_consume(), internal::reservable_predecessor_cache< T, M >::try_release(), internal::reservable_predecessor_cache< T, M >::try_reserve(), internal::reserving_port< T >::reserving_port_operation::type, and void.

Here is the call graph for this function:

◆ register_predecessor()

template<typename T >
bool internal::reserving_port< T >::register_predecessor ( predecessor_type src)
inline

Add a predecessor.

Definition at line 353 of file _flow_graph_join_impl.h.

353  {
354  reserving_port_operation op_data(src, reg_pred);
355  my_aggregator.execute(&op_data);
356  return op_data.status == SUCCEEDED;
357  }
aggregator< handler_type, reserving_port_operation > my_aggregator

References internal::reserving_port< T >::my_aggregator, internal::reserving_port< T >::reg_pred, and internal::reserving_port< T >::SUCCEEDED.

◆ release()

template<typename T >
void internal::reserving_port< T >::release ( )
inline

Release the port.

Definition at line 374 of file _flow_graph_join_impl.h.

374  {
375  reserving_port_operation op_data(rel_res);
376  my_aggregator.execute(&op_data);
377  }
aggregator< handler_type, reserving_port_operation > my_aggregator

References internal::reserving_port< T >::my_aggregator, and internal::reserving_port< T >::rel_res.

◆ remove_predecessor()

template<typename T >
bool internal::reserving_port< T >::remove_predecessor ( predecessor_type src)
inline

Remove a predecessor.

Definition at line 360 of file _flow_graph_join_impl.h.

360  {
361  reserving_port_operation op_data(src, rem_pred);
362  my_aggregator.execute(&op_data);
363  return op_data.status == SUCCEEDED;
364  }
aggregator< handler_type, reserving_port_operation > my_aggregator

References internal::reserving_port< T >::my_aggregator, internal::reserving_port< T >::rem_pred, and internal::reserving_port< T >::SUCCEEDED.

◆ reserve()

template<typename T >
bool internal::reserving_port< T >::reserve ( T &  v)
inline

Reserve an item from the port.

Definition at line 367 of file _flow_graph_join_impl.h.

367  {
368  reserving_port_operation op_data(v, res_item);
369  my_aggregator.execute(&op_data);
370  return op_data.status == SUCCEEDED;
371  }
aggregator< handler_type, reserving_port_operation > my_aggregator

References internal::reserving_port< T >::my_aggregator, internal::reserving_port< T >::res_item, and internal::reserving_port< T >::SUCCEEDED.

◆ reset_receiver()

template<typename T >
void internal::reserving_port< T >::reset_receiver ( reset_flags  f)
inline

Definition at line 415 of file _flow_graph_join_impl.h.

415  {
417  else
419  reserved = false;
420  __TBB_ASSERT(!(f&rf_clear_edges) || my_predecessors.empty(), "port edges not removed");
421  }
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
reservable_predecessor_cache< T, null_mutex > my_predecessors

References __TBB_ASSERT, internal::reservable_predecessor_cache< T, M >::clear(), internal::node_cache< T, M >::empty(), internal::reserving_port< T >::my_predecessors, internal::reserving_port< T >::reserved, internal::reservable_predecessor_cache< T, M >::reset(), and tbb::flow::interface10::rf_clear_edges.

Here is the call graph for this function:

◆ set_join_node_pointer()

template<typename T >
void internal::reserving_port< T >::set_join_node_pointer ( forwarding_base join)
inline

Definition at line 348 of file _flow_graph_join_impl.h.

348  {
349  my_join = join;
350  }

References internal::reserving_port< T >::my_join.

◆ try_put_task()

template<typename T >
task* internal::reserving_port< T >::try_put_task ( const T &  )
inlineprotected

Definition at line 323 of file _flow_graph_join_impl.h.

323  {
324  return NULL;
325  }

Friends And Related Function Documentation

◆ internal::aggregating_functor< class_type, reserving_port_operation >

template<typename T >
friend class internal::aggregating_functor< class_type, reserving_port_operation >
friend

Definition at line 250 of file _flow_graph_join_impl.h.

◆ internal::broadcast_cache

template<typename T >
template<typename X , typename Y >
friend class internal::broadcast_cache
friend

Definition at line 321 of file _flow_graph_join_impl.h.

◆ internal::round_robin_cache

template<typename T >
template<typename X , typename Y >
friend class internal::round_robin_cache
friend

Definition at line 322 of file _flow_graph_join_impl.h.

◆ run_and_put_task

template<typename T >
template<typename R , typename B >
friend class run_and_put_task
friend

Definition at line 320 of file _flow_graph_join_impl.h.

Member Data Documentation

◆ my_aggregator

◆ my_join

◆ my_predecessors

◆ reserved


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.