Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
internal::function_input_base< Input, Policy, A, ImplType > Class Template Reference

Input and scheduling for a function node that takes a type Input as input. More...

#include <_flow_graph_node_impl.h>

Inheritance diagram for internal::function_input_base< Input, Policy, A, ImplType >:
Collaboration diagram for internal::function_input_base< Input, Policy, A, ImplType >:

Classes

class  operation_type
 

Public Types

typedef Input input_type
 The input type of this receiver. More...
 
typedef receiver< input_type >::predecessor_type predecessor_type
 
typedef predecessor_cache< input_type, null_mutex > predecessor_cache_type
 
typedef function_input_queue< input_type, A > input_queue_type
 
typedef A::template rebind< input_queue_type >::other queue_allocator_type
 
- Public Types inherited from tbb::flow::interface10::receiver< Input >
typedef Input input_type
 The input type of this receiver. More...
 
typedef internal::async_helpers< Input >::filtered_type filtered_type
 
- Public Types inherited from tbb::flow::interface10::internal::untyped_receiver
typedef untyped_sender predecessor_type
 The predecessor type for this node. More...
 

Public Member Functions

 __TBB_STATIC_ASSERT (!((internal::has_policy< queueing, Policy >::value) &&(internal::has_policy< rejecting, Policy >::value)), "queueing and rejecting policies can't be specified simultaneously")
 
 function_input_base (graph &g, __TBB_FLOW_GRAPH_PRIORITY_ARG1(size_t max_concurrency, node_priority_t priority))
 Constructor for function_input_base. More...
 
 function_input_base (const function_input_base &src)
 Copy constructor. More...
 
virtual ~function_input_base ()
 Destructor. More...
 
tasktry_put_task (const input_type &t) __TBB_override
 Put item to successor; return task to run the successor if possible. More...
 
bool register_predecessor (predecessor_type &src) __TBB_override
 Adds src to the list of cached predecessors. More...
 
bool remove_predecessor (predecessor_type &src) __TBB_override
 Removes src from the list of cached predecessors. More...
 
- Public Member Functions inherited from tbb::flow::interface10::receiver< Input >
bool try_put (const typename internal::async_helpers< Input >::filtered_type &t)
 Put an item to the receiver. More...
 
bool try_put (const typename internal::async_helpers< Input >::async_type &t)
 
- Public Member Functions inherited from tbb::flow::interface10::internal::untyped_receiver
virtual ~untyped_receiver ()
 Destructor. More...
 
template<typename X >
bool try_put (const X &t)
 Put an item to the receiver. More...
 

Protected Member Functions

void reset_function_input_base (reset_flags f)
 
void reset_receiver (reset_flags f) __TBB_override
 
graph & graph_reference () __TBB_override
 
tasktry_get_postponed_task (const input_type &i)
 
- Protected Member Functions inherited from tbb::flow::interface10::receiver< Input >
virtual tasktry_put_task_wrapper (const void *p, bool is_async) __TBB_override
 
- Protected Member Functions inherited from tbb::flow::interface10::internal::untyped_receiver
template<typename X >
tasktry_put_task (const X &t)
 
virtual void reset_receiver (reset_flags f=rf_reset_protocol)=0
 put receiver back in initial state More...
 
virtual bool is_continue_receiver ()
 

Protected Attributes

graph & my_graph_ref
 
const size_t my_max_concurrency
 
size_t my_concurrency
 
input_queue_typemy_queue
 
predecessor_cache< input_type, null_mutex > my_predecessors
 

Private Types

enum  op_type {
  reg_pred, rem_pred, try_fwd, tryput_bypass,
  app_body_bypass, occupy_concurrency
}
 
typedef function_input_base< Input, Policy, A, ImplType > class_type
 
typedef internal::aggregating_functor< class_type, operation_typehandler_type
 

Private Member Functions

taskperform_queued_requests ()
 
void handle_operations (operation_type *op_list)
 
void internal_try_put_task (operation_type *op)
 Put to the node, but return the task instead of enqueueing it. More...
 
void internal_forward (operation_type *op)
 Creates tasks for postponed messages if available and if concurrency allows. More...
 
taskinternal_try_put_bypass (const input_type &t)
 
tasktry_put_task_impl (const input_type &t, tbb::internal::true_type)
 
tasktry_put_task_impl (const input_type &t, tbb::internal::false_type)
 
taskapply_body_bypass (const input_type &i)
 Applies the body to the provided input. More...
 
taskcreate_body_task (const input_type &input)
 allocates a task to apply a body More...
 
taskforward_task ()
 This is executed by an enqueued task, the "forwarder". More...
 
taskcreate_forward_task ()
 
void spawn_forward_task ()
 Spawns a task that calls forward() More...
 

Private Attributes

bool forwarder_busy
 
aggregator< handler_type, operation_typemy_aggregator
 

Friends

class apply_body_task_bypass< class_type, input_type >
 
class forward_task_bypass< class_type >
 
class internal::aggregating_functor< class_type, operation_type >
 

Detailed Description

template<typename Input, typename Policy, typename A, typename ImplType>
class internal::function_input_base< Input, Policy, A, ImplType >

Input and scheduling for a function node that takes a type Input as input.

Definition at line 65 of file _flow_graph_node_impl.h.

Member Typedef Documentation

◆ class_type

template<typename Input, typename Policy, typename A, typename ImplType>
typedef function_input_base<Input, Policy, A, ImplType> internal::function_input_base< Input, Policy, A, ImplType >::class_type
private

Definition at line 72 of file _flow_graph_node_impl.h.

◆ handler_type

template<typename Input, typename Policy, typename A, typename ImplType>
typedef internal::aggregating_functor<class_type, operation_type> internal::function_input_base< Input, Policy, A, ImplType >::handler_type
private

Definition at line 231 of file _flow_graph_node_impl.h.

◆ input_queue_type

template<typename Input, typename Policy, typename A, typename ImplType>
typedef function_input_queue<input_type, A> internal::function_input_base< Input, Policy, A, ImplType >::input_queue_type

Definition at line 80 of file _flow_graph_node_impl.h.

◆ input_type

template<typename Input, typename Policy, typename A, typename ImplType>
typedef Input internal::function_input_base< Input, Policy, A, ImplType >::input_type

The input type of this receiver.

Definition at line 77 of file _flow_graph_node_impl.h.

◆ predecessor_cache_type

template<typename Input, typename Policy, typename A, typename ImplType>
typedef predecessor_cache<input_type, null_mutex > internal::function_input_base< Input, Policy, A, ImplType >::predecessor_cache_type

Definition at line 79 of file _flow_graph_node_impl.h.

◆ predecessor_type

template<typename Input, typename Policy, typename A, typename ImplType>
typedef receiver<input_type>::predecessor_type internal::function_input_base< Input, Policy, A, ImplType >::predecessor_type

Definition at line 78 of file _flow_graph_node_impl.h.

◆ queue_allocator_type

template<typename Input, typename Policy, typename A, typename ImplType>
typedef A::template rebind< input_queue_type >::other internal::function_input_base< Input, Policy, A, ImplType >::queue_allocator_type

Definition at line 81 of file _flow_graph_node_impl.h.

Member Enumeration Documentation

◆ op_type

template<typename Input, typename Policy, typename A, typename ImplType>
enum internal::function_input_base::op_type
private
Enumerator
reg_pred 
rem_pred 
try_fwd 
tryput_bypass 
app_body_bypass 
occupy_concurrency 

Definition at line 66 of file _flow_graph_node_impl.h.

Constructor & Destructor Documentation

◆ function_input_base() [1/2]

template<typename Input, typename Policy, typename A, typename ImplType>
internal::function_input_base< Input, Policy, A, ImplType >::function_input_base ( graph &  g,
__TBB_FLOW_GRAPH_PRIORITY_ARG1(size_t max_concurrency, node_priority_t priority)   
)
inline

Constructor for function_input_base.

Definition at line 91 of file _flow_graph_node_impl.h.

94  , __TBB_FLOW_GRAPH_PRIORITY_ARG1(my_concurrency(0), my_priority(priority))
96  , forwarder_busy(false)
97  {
99  my_aggregator.initialize_handler(handler_type(this));
100  }
internal::aggregating_functor< class_type, operation_type > handler_type
void set_owner(successor_type *owner)
int max_concurrency()
Returns the maximal number of threads that can work inside the arena.
Definition: task_arena.h:412
function_input_queue< input_type, A > input_queue_type
#define __TBB_FLOW_GRAPH_PRIORITY_ARG1(arg1, priority)
aggregator< handler_type, operation_type > my_aggregator
predecessor_cache< input_type, null_mutex > my_predecessors

◆ function_input_base() [2/2]

template<typename Input, typename Policy, typename A, typename ImplType>
internal::function_input_base< Input, Policy, A, ImplType >::function_input_base ( const function_input_base< Input, Policy, A, ImplType > &  src)
inline

Copy constructor.

Definition at line 103 of file _flow_graph_node_impl.h.

104  : receiver<Input>(), tbb::internal::no_assign()
105  , my_graph_ref(src.my_graph_ref), my_max_concurrency(src.my_max_concurrency)
106  , __TBB_FLOW_GRAPH_PRIORITY_ARG1(my_concurrency(0), my_priority(src.my_priority))
107  , my_queue(src.my_queue ? new input_queue_type() : NULL), forwarder_busy(false)
108  {
110  my_aggregator.initialize_handler(handler_type(this));
111  }
internal::aggregating_functor< class_type, operation_type > handler_type
void set_owner(successor_type *owner)
Base class for types that should not be assigned.
Definition: tbb_stddef.h:324
function_input_queue< input_type, A > input_queue_type
#define __TBB_FLOW_GRAPH_PRIORITY_ARG1(arg1, priority)
aggregator< handler_type, operation_type > my_aggregator
predecessor_cache< input_type, null_mutex > my_predecessors

◆ ~function_input_base()

template<typename Input, typename Policy, typename A, typename ImplType>
virtual internal::function_input_base< Input, Policy, A, ImplType >::~function_input_base ( )
inlinevirtual

Destructor.

Definition at line 117 of file _flow_graph_node_impl.h.

117  {
118  if ( my_queue ) delete my_queue;
119  }

Member Function Documentation

◆ __TBB_STATIC_ASSERT()

template<typename Input, typename Policy, typename A, typename ImplType>
internal::function_input_base< Input, Policy, A, ImplType >::__TBB_STATIC_ASSERT ( (internal::has_policy< queueing, Policy >::value) &&(internal::has_policy< rejecting, Policy >::value),
"queueing and rejecting policies can't be specified simultaneously"   
)

◆ apply_body_bypass()

template<typename Input, typename Policy, typename A, typename ImplType>
task* internal::function_input_base< Input, Policy, A, ImplType >::apply_body_bypass ( const input_type i)
inlineprivate

Applies the body to the provided input.

Definition at line 377 of file _flow_graph_node_impl.h.

377  {
378  return static_cast<ImplType *>(this)->apply_body_impl_bypass(i);
379  }

Referenced by internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >::try_put_task_impl().

Here is the caller graph for this function:

◆ create_body_task()

template<typename Input, typename Policy, typename A, typename ImplType>
task* internal::function_input_base< Input, Policy, A, ImplType >::create_body_task ( const input_type input)
inlineprivate

◆ create_forward_task()

template<typename Input, typename Policy, typename A, typename ImplType>
task* internal::function_input_base< Input, Policy, A, ImplType >::create_forward_task ( )
inlineprivate

Definition at line 406 of file _flow_graph_node_impl.h.

406  {
408  new( task::allocate_additional_child_of(*(my_graph_ref.root_task())) )
410  : NULL;
411  }
#define __TBB_FLOW_GRAPH_PRIORITY_ARG1(arg1, priority)

Referenced by internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >::spawn_forward_task().

Here is the caller graph for this function:

◆ forward_task()

template<typename Input, typename Policy, typename A, typename ImplType>
task* internal::function_input_base< Input, Policy, A, ImplType >::forward_task ( )
inlineprivate

This is executed by an enqueued task, the "forwarder".

Definition at line 391 of file _flow_graph_node_impl.h.

391  {
392  operation_type op_data(try_fwd);
393  task* rval = NULL;
394  do {
395  op_data.status = WAIT;
396  my_aggregator.execute(&op_data);
397  if(op_data.status == SUCCEEDED) {
398  task* ttask = op_data.bypass_t;
399  __TBB_ASSERT( ttask && ttask != SUCCESSFULLY_ENQUEUED, NULL );
400  rval = combine_tasks(my_graph_ref, rval, ttask);
401  }
402  } while (op_data.status == SUCCEEDED);
403  return rval;
404  }
static tbb::task *const SUCCESSFULLY_ENQUEUED
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
static tbb::task * combine_tasks(graph &g, tbb::task *left, tbb::task *right)
Definition: flow_graph.h:171
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
aggregator< handler_type, operation_type > my_aggregator

◆ graph_reference()

template<typename Input, typename Policy, typename A, typename ImplType>
graph& internal::function_input_base< Input, Policy, A, ImplType >::graph_reference ( )
inlineprotectedvirtual

◆ handle_operations()

template<typename Input, typename Policy, typename A, typename ImplType>
void internal::function_input_base< Input, Policy, A, ImplType >::handle_operations ( operation_type op_list)
inlineprivate

Definition at line 254 of file _flow_graph_node_impl.h.

254  {
255  operation_type *tmp;
256  while (op_list) {
257  tmp = op_list;
258  op_list = op_list->next;
259  switch (tmp->type) {
260  case reg_pred:
261  my_predecessors.add(*(tmp->r));
262  __TBB_store_with_release(tmp->status, SUCCEEDED);
263  if (!forwarder_busy) {
264  forwarder_busy = true;
266  }
267  break;
268  case rem_pred:
269  my_predecessors.remove(*(tmp->r));
270  __TBB_store_with_release(tmp->status, SUCCEEDED);
271  break;
272  case app_body_bypass: {
273  tmp->bypass_t = NULL;
274  __TBB_ASSERT(my_max_concurrency != 0, NULL);
275  --my_concurrency;
277  tmp->bypass_t = perform_queued_requests();
278 
279  __TBB_store_with_release(tmp->status, SUCCEEDED);
280  }
281  break;
282  case tryput_bypass: internal_try_put_task(tmp); break;
283  case try_fwd: internal_forward(tmp); break;
284  case occupy_concurrency:
286  ++my_concurrency;
287  __TBB_store_with_release(tmp->status, SUCCEEDED);
288  } else {
289  __TBB_store_with_release(tmp->status, FAILED);
290  }
291  break;
292 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
293  case add_blt_pred: {
294  my_predecessors.internal_add_built_predecessor(*(tmp->r));
295  __TBB_store_with_release(tmp->status, SUCCEEDED);
296  }
297  break;
298  case del_blt_pred:
299  my_predecessors.internal_delete_built_predecessor(*(tmp->r));
300  __TBB_store_with_release(tmp->status, SUCCEEDED);
301  break;
302  case blt_pred_cnt:
303  tmp->cnt_val = my_predecessors.predecessor_count();
304  __TBB_store_with_release(tmp->status, SUCCEEDED);
305  break;
306  case blt_pred_cpy:
307  my_predecessors.copy_predecessors( *(tmp->predv) );
308  __TBB_store_with_release(tmp->status, SUCCEEDED);
309  break;
310 #endif /* TBB_DEPRECATED_FLOW_NODE_EXTRACTION */
311  }
312  }
313  }
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
void spawn_forward_task()
Spawns a task that calls forward()
void internal_try_put_task(operation_type *op)
Put to the node, but return the task instead of enqueueing it.
void __TBB_store_with_release(volatile T &location, V value)
Definition: tbb_machine.h:717
predecessor_cache< input_type, null_mutex > my_predecessors
void internal_forward(operation_type *op)
Creates tasks for postponed messages if available and if concurrency allows.

◆ internal_forward()

template<typename Input, typename Policy, typename A, typename ImplType>
void internal::function_input_base< Input, Policy, A, ImplType >::internal_forward ( operation_type op)
inlineprivate

Creates tasks for postponed messages if available and if concurrency allows.

Definition at line 333 of file _flow_graph_node_impl.h.

333  {
334  op->bypass_t = NULL;
336  op->bypass_t = perform_queued_requests();
337  if(op->bypass_t)
338  __TBB_store_with_release(op->status, SUCCEEDED);
339  else {
340  forwarder_busy = false;
341  __TBB_store_with_release(op->status, FAILED);
342  }
343  }
void __TBB_store_with_release(volatile T &location, V value)
Definition: tbb_machine.h:717

Referenced by internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >::handle_operations().

Here is the caller graph for this function:

◆ internal_try_put_bypass()

template<typename Input, typename Policy, typename A, typename ImplType>
task* internal::function_input_base< Input, Policy, A, ImplType >::internal_try_put_bypass ( const input_type t)
inlineprivate

Definition at line 345 of file _flow_graph_node_impl.h.

345  {
346  operation_type op_data(t, tryput_bypass);
347  my_aggregator.execute(&op_data);
348  if( op_data.status == internal::SUCCEEDED ) {
349  return op_data.bypass_t;
350  }
351  return NULL;
352  }
aggregator< handler_type, operation_type > my_aggregator

Referenced by internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >::try_put_task_impl().

Here is the caller graph for this function:

◆ internal_try_put_task()

template<typename Input, typename Policy, typename A, typename ImplType>
void internal::function_input_base< Input, Policy, A, ImplType >::internal_try_put_task ( operation_type op)
inlineprivate

Put to the node, but return the task instead of enqueueing it.

Definition at line 316 of file _flow_graph_node_impl.h.

316  {
317  __TBB_ASSERT(my_max_concurrency != 0, NULL);
319  ++my_concurrency;
320  task * new_task = create_body_task(*(op->elem));
321  op->bypass_t = new_task;
322  __TBB_store_with_release(op->status, SUCCEEDED);
323  } else if ( my_queue && my_queue->push(*(op->elem)) ) {
324  op->bypass_t = SUCCESSFULLY_ENQUEUED;
325  __TBB_store_with_release(op->status, SUCCEEDED);
326  } else {
327  op->bypass_t = NULL;
328  __TBB_store_with_release(op->status, FAILED);
329  }
330  }
static tbb::task *const SUCCESSFULLY_ENQUEUED
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
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
task * create_body_task(const input_type &input)
allocates a task to apply a body
void __TBB_store_with_release(volatile T &location, V value)
Definition: tbb_machine.h:717

Referenced by internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >::handle_operations().

Here is the caller graph for this function:

◆ perform_queued_requests()

template<typename Input, typename Policy, typename A, typename ImplType>
task* internal::function_input_base< Input, Policy, A, ImplType >::perform_queued_requests ( )
inlineprivate

Definition at line 235 of file _flow_graph_node_impl.h.

235  {
236  task* new_task = NULL;
237  if(my_queue) {
238  if(!my_queue->empty()) {
239  ++my_concurrency;
240  new_task = create_body_task(my_queue->front());
241 
242  my_queue->pop();
243  }
244  }
245  else {
246  input_type i;
247  if(my_predecessors.get_item(i)) {
248  ++my_concurrency;
249  new_task = create_body_task(i);
250  }
251  }
252  return new_task;
253  }
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
task * create_body_task(const input_type &input)
allocates a task to apply a body
Input input_type
The input type of this receiver.
predecessor_cache< input_type, null_mutex > my_predecessors

Referenced by internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >::handle_operations(), and internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >::internal_forward().

Here is the caller graph for this function:

◆ register_predecessor()

template<typename Input, typename Policy, typename A, typename ImplType>
bool internal::function_input_base< Input, Policy, A, ImplType >::register_predecessor ( predecessor_type src)
inlinevirtual

Adds src to the list of cached predecessors.

Reimplemented from tbb::flow::interface10::internal::untyped_receiver.

Definition at line 126 of file _flow_graph_node_impl.h.

126  {
127  operation_type op_data(reg_pred);
128  op_data.r = &src;
129  my_aggregator.execute(&op_data);
130  return true;
131  }
aggregator< handler_type, operation_type > my_aggregator

◆ remove_predecessor()

template<typename Input, typename Policy, typename A, typename ImplType>
bool internal::function_input_base< Input, Policy, A, ImplType >::remove_predecessor ( predecessor_type src)
inlinevirtual

Removes src from the list of cached predecessors.

Reimplemented from tbb::flow::interface10::internal::untyped_receiver.

Definition at line 134 of file _flow_graph_node_impl.h.

134  {
135  operation_type op_data(rem_pred);
136  op_data.r = &src;
137  my_aggregator.execute(&op_data);
138  return true;
139  }
aggregator< handler_type, operation_type > my_aggregator

◆ reset_function_input_base()

template<typename Input, typename Policy, typename A, typename ImplType>
void internal::function_input_base< Input, Policy, A, ImplType >::reset_function_input_base ( reset_flags  f)
inlineprotected

◆ reset_receiver()

template<typename Input, typename Policy, typename A, typename ImplType>
void internal::function_input_base< Input, Policy, A, ImplType >::reset_receiver ( reset_flags  f)
inlineprotected

Definition at line 191 of file _flow_graph_node_impl.h.

191  {
193  else
195  __TBB_ASSERT(!(f & rf_clear_edges) || my_predecessors.empty(), "function_input_base reset failed");
196  }
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
predecessor_cache< input_type, null_mutex > my_predecessors

Referenced by internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >::reset_function_input_base().

Here is the caller graph for this function:

◆ spawn_forward_task()

template<typename Input, typename Policy, typename A, typename ImplType>
void internal::function_input_base< Input, Policy, A, ImplType >::spawn_forward_task ( )
inlineprivate

Spawns a task that calls forward()

Definition at line 414 of file _flow_graph_node_impl.h.

414  {
415  task* tp = create_forward_task();
416  if(tp) {
418  }
419  }
graph & graph_reference() __TBB_override
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
void spawn_in_graph_arena(graph &g, tbb::task &arena_task)
Spawns a task inside graph arena.

Referenced by internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >::handle_operations().

Here is the caller graph for this function:

◆ try_get_postponed_task()

template<typename Input, typename Policy, typename A, typename ImplType>
task* internal::function_input_base< Input, Policy, A, ImplType >::try_get_postponed_task ( const input_type i)
inlineprotected

Definition at line 202 of file _flow_graph_node_impl.h.

202  {
203  operation_type op_data(i, app_body_bypass); // tries to pop an item or get_item
204  my_aggregator.execute(&op_data);
205  return op_data.bypass_t;
206  }
aggregator< handler_type, operation_type > my_aggregator

Referenced by internal::function_input< Input, Output, Policy, A >::apply_body_impl_bypass(), and internal::multifunction_input< Input, OutputPortSet, Policy, A >::apply_body_impl_bypass().

Here is the caller graph for this function:

◆ try_put_task()

template<typename Input, typename Policy, typename A, typename ImplType>
task* internal::function_input_base< Input, Policy, A, ImplType >::try_put_task ( const input_type t)
inlinevirtual

Put item to successor; return task to run the successor if possible.

Implements tbb::flow::interface10::receiver< Input >.

Definition at line 121 of file _flow_graph_node_impl.h.

121  {
123  }
task * try_put_task_impl(const input_type &t, tbb::internal::true_type)

◆ try_put_task_impl() [1/2]

template<typename Input, typename Policy, typename A, typename ImplType>
task* internal::function_input_base< Input, Policy, A, ImplType >::try_put_task_impl ( const input_type t,
tbb::internal::true_type   
)
inlineprivate

Definition at line 354 of file _flow_graph_node_impl.h.

354  {
355  if( my_max_concurrency == 0 ) {
356  return apply_body_bypass(t);
357  } else {
358  operation_type check_op(t, occupy_concurrency);
359  my_aggregator.execute(&check_op);
360  if( check_op.status == internal::SUCCEEDED ) {
361  return apply_body_bypass(t);
362  }
363  return internal_try_put_bypass(t);
364  }
365  }
task * internal_try_put_bypass(const input_type &t)
task * apply_body_bypass(const input_type &i)
Applies the body to the provided input.
aggregator< handler_type, operation_type > my_aggregator

Referenced by internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >::try_put_task().

Here is the caller graph for this function:

◆ try_put_task_impl() [2/2]

template<typename Input, typename Policy, typename A, typename ImplType>
task* internal::function_input_base< Input, Policy, A, ImplType >::try_put_task_impl ( const input_type t,
tbb::internal::false_type   
)
inlineprivate

Definition at line 367 of file _flow_graph_node_impl.h.

367  {
368  if( my_max_concurrency == 0 ) {
369  return create_body_task(t);
370  } else {
371  return internal_try_put_bypass(t);
372  }
373  }
task * internal_try_put_bypass(const input_type &t)
task * create_body_task(const input_type &input)
allocates a task to apply a body

Friends And Related Function Documentation

◆ apply_body_task_bypass< class_type, input_type >

template<typename Input, typename Policy, typename A, typename ImplType>
friend class apply_body_task_bypass< class_type, input_type >
friend

Definition at line 210 of file _flow_graph_node_impl.h.

◆ forward_task_bypass< class_type >

template<typename Input, typename Policy, typename A, typename ImplType>
friend class forward_task_bypass< class_type >
friend

Definition at line 211 of file _flow_graph_node_impl.h.

◆ internal::aggregating_functor< class_type, operation_type >

template<typename Input, typename Policy, typename A, typename ImplType>
friend class internal::aggregating_functor< class_type, operation_type >
friend

Definition at line 232 of file _flow_graph_node_impl.h.

Member Data Documentation

◆ forwarder_busy

◆ my_aggregator

◆ my_concurrency

◆ my_graph_ref

◆ my_max_concurrency

◆ my_predecessors

◆ my_queue


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.