Forwards messages in arbitrary order. More...

#include <flow_graph.h>

Inheritance diagram for tbb::flow::interface11::buffer_node< T, Allocator >:

Collaboration diagram for tbb::flow::interface11::buffer_node< T, Allocator >:

Classes
class	buffer_operation

Public Types
typedef T	input_type

typedef T	output_type

typedef receiver< input_type >::predecessor_type	predecessor_type

typedef sender< output_type >::successor_type	successor_type

typedef buffer_node< T, Allocator >	class_type

Public Types inherited from internal::item_buffer< T, cache_aligned_allocator< T > >
enum	buffer_item_state

typedef T	item_type

Public Member Functions
	__TBB_STATIC_ASSERT ((tbb::internal::is_same_type< Allocator, null_type >::value), "Allocator template parameter for flow graph nodes is deprecated and will be removed. " "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface.")

__TBB_NOINLINE_SYM	buffer_node (graph &g)
	Constructor. More...

__TBB_NOINLINE_SYM	buffer_node (const buffer_node &src)
	Copy constructor. More...

bool	register_successor (successor_type &r) __TBB_override
	Adds a new successor. More...

bool	remove_successor (successor_type &r) __TBB_override
	Removes a successor. More...

bool	try_get (T &v) __TBB_override
	Request an item from the buffer_node. More...

bool	try_reserve (T &v) __TBB_override
	Reserves an item. More...

bool	try_release () __TBB_override
	Release a reserved item. More...

bool	try_consume () __TBB_override
	Consumes a reserved item. More...

Public Member Functions inherited from tbb::flow::interface11::graph_node
	graph_node (graph &g)

virtual	~graph_node ()

Public Member Functions inherited from internal::reservable_item_buffer< T, cache_aligned_allocator< T > >
	reservable_item_buffer ()

void	reset ()

Public Member Functions inherited from internal::item_buffer< T, cache_aligned_allocator< T > >
	item_buffer ()
	Constructor. More...

	~item_buffer ()

void	reset ()

Public Member Functions inherited from tbb::flow::interface11::receiver< T >
virtual	~receiver ()
	Destructor. More...

bool	try_put (const T &t)
	Put an item to the receiver. More...

virtual __TBB_DEPRECATED bool	register_predecessor (predecessor_type &)
	Add a predecessor to the node. More...

virtual __TBB_DEPRECATED bool	remove_predecessor (predecessor_type &)
	Remove a predecessor from the node. More...

Public Member Functions inherited from tbb::flow::interface11::sender< T >
virtual	~sender ()

virtual __TBB_DEPRECATED bool	register_successor (successor_type &r)=0
	Add a new successor to this node. More...

virtual __TBB_DEPRECATED bool	remove_successor (successor_type &r)=0
	Removes a successor from this node. More...

Protected Types
enum	op_type { reg_succ, rem_succ, req_item, res_item, rel_res, con_res, put_item, try_fwd_task }

typedef size_t	size_type

typedef internal::aggregating_functor< class_type, buffer_operation >	handler_type

Protected Types inherited from internal::item_buffer< T, cache_aligned_allocator< T > >
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< T >, buffer_item_type >::type	allocator_type

Protected Member Functions
virtual void	handle_operations (buffer_operation *op_list)

template<typename derived_type >
void	handle_operations_impl (buffer_operation op_list, derived_type derived)

task *	grab_forwarding_task (buffer_operation &op_data)

bool	enqueue_forwarding_task (buffer_operation &op_data)

virtual task *	forward_task ()
	This is executed by an enqueued task, the "forwarder". More...

virtual void	internal_reg_succ (buffer_operation *op)
	Register successor. More...

virtual void	internal_rem_succ (buffer_operation *op)
	Remove successor. More...

virtual void	internal_forward_task (buffer_operation *op)
	Tries to forward valid items to successors. More...

template<typename derived_type >
void	internal_forward_task_impl (buffer_operation op, derived_type derived)

virtual bool	internal_push (buffer_operation *op)

virtual void	internal_pop (buffer_operation *op)

virtual void	internal_reserve (buffer_operation *op)

virtual void	internal_consume (buffer_operation *op)

virtual void	internal_release (buffer_operation *op)

task *	try_put_task (const T &t) __TBB_override
	receive an item, return a task *if possible More...

graph &	graph_reference () const __TBB_override

void	reset_receiver (reset_flags) __TBB_override
	put receiver back in initial state More...

void	reset_node (reset_flags f) __TBB_override

Protected Member Functions inherited from internal::reservable_item_buffer< T, cache_aligned_allocator< T > >
bool	reserve_front (T &v)

void	consume_front ()

void	release_front ()

Protected Member Functions inherited from internal::item_buffer< T, cache_aligned_allocator< T > >
bool	buffer_empty () const

buffer_item_type &	item (size_type i)

const buffer_item_type &	item (size_type i) const

bool	my_item_valid (size_type i) const

bool	my_item_reserved (size_type i) const

const item_type &	get_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_type &	front () const

const item_type &	back () 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 Member Functions inherited from tbb::flow::interface11::receiver< T >
virtual bool	is_continue_receiver ()

Protected Attributes
internal::round_robin_cache< T, null_rw_mutex >	my_successors

bool	forwarder_busy

internal::aggregator< handler_type, buffer_operation >	my_aggregator

Protected Attributes inherited from tbb::flow::interface11::graph_node
graph &	my_graph

graph_node *	next

graph_node *	prev

Protected Attributes inherited from internal::reservable_item_buffer< T, cache_aligned_allocator< T > >
bool	my_reserved

Protected Attributes inherited from internal::item_buffer< T, cache_aligned_allocator< T > >
buffer_item_type *	my_array

size_type	my_array_size

size_type	my_head

size_type	my_tail

Private Types
typedef cache_aligned_allocator< T >	internals_allocator

Private Member Functions
void	order ()

bool	is_item_valid ()

void	try_put_and_add_task (task *&last_task)

Friends
class	internal::forward_task_bypass< class_type >

class	internal::aggregating_functor< class_type, buffer_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

Additional Inherited Members
Public Attributes inherited from tbb::flow::interface11::receiver< T >
__TBB_DEPRECATED typedef T	input_type
	The input type of this receiver. More...

__TBB_DEPRECATED typedef sender< T >	predecessor_type
	The predecessor type for this node. More...

Public Attributes inherited from tbb::flow::interface11::sender< T >
__TBB_DEPRECATED typedef T	output_type
	The output type of this sender. More...

__TBB_DEPRECATED typedef receiver< T >	successor_type
	The successor type for this node. More...

Static Protected Attributes inherited from internal::item_buffer< T, cache_aligned_allocator< T > >
static const size_type	initial_buffer_size

Detailed Description

template<typename T, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>
class tbb::flow::interface11::buffer_node< T, Allocator >

Forwards messages in arbitrary order.

Definition at line 2036 of file flow_graph.h.

Member Typedef Documentation

◆ class_type

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

typedef buffer_node<T, Allocator> tbb::flow::interface11::buffer_node< T, Allocator >::class_type

Definition at line 2054 of file flow_graph.h.

◆ handler_type

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

typedef internal::aggregating_functor<class_type, buffer_operation> tbb::flow::interface11::buffer_node< T, Allocator >::handler_type

protected

Definition at line 2117 of file flow_graph.h.

◆ input_type

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

typedef T tbb::flow::interface11::buffer_node< T, Allocator >::input_type

Definition at line 2050 of file flow_graph.h.

◆ internals_allocator

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

typedef cache_aligned_allocator<T> tbb::flow::interface11::buffer_node< T, Allocator >::internals_allocator

private

Definition at line 2047 of file flow_graph.h.

◆ output_type

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

typedef T tbb::flow::interface11::buffer_node< T, Allocator >::output_type

Definition at line 2051 of file flow_graph.h.

◆ predecessor_type

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

typedef receiver<input_type>::predecessor_type tbb::flow::interface11::buffer_node< T, Allocator >::predecessor_type

Definition at line 2052 of file flow_graph.h.

◆ size_type

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

typedef size_t tbb::flow::interface11::buffer_node< T, Allocator >::size_type

protected

Definition at line 2068 of file flow_graph.h.

◆ successor_type

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

typedef sender<output_type>::successor_type tbb::flow::interface11::buffer_node< T, Allocator >::successor_type

Definition at line 2053 of file flow_graph.h.

Member Enumeration Documentation

◆ op_type

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

enum tbb::flow::interface11::buffer_node::op_type

protected

Enumerator
reg_succ
rem_succ
req_item
res_item
rel_res
con_res
put_item
try_fwd_task

Definition at line 2077 of file flow_graph.h.

                  {reg_succ, rem_succ, req_item, res_item, rel_res, con_res, put_item, try_fwd_task
 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
         , add_blt_succ, del_blt_succ,
         add_blt_pred, del_blt_pred,
         blt_succ_cnt, blt_pred_cnt,
         blt_succ_cpy, blt_pred_cpy   // create vector copies of preds and succs
 #endif
     };

Constructor & Destructor Documentation

◆ buffer_node() [1/2]

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

__TBB_NOINLINE_SYM tbb::flow::interface11::buffer_node< T, Allocator >::buffer_node ( graph & g )

inlineexplicit

Constructor.

Definition at line 2351 of file flow_graph.h.

         : graph_node(g), internal::reservable_item_buffer<T, internals_allocator>(), receiver<T>(),
           sender<T>(), forwarder_busy(false)
     {
         my_successors.set_owner(this);
         my_aggregator.initialize_handler(handler_type(this));
         tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_BUFFER_NODE, &this->my_graph,
                                  static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
     }

◆ buffer_node() [2/2]

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

__TBB_NOINLINE_SYM tbb::flow::interface11::buffer_node< T, Allocator >::buffer_node ( const buffer_node< T, Allocator > & src )

inline

Copy constructor.

Definition at line 2369 of file flow_graph.h.

         : graph_node(src.my_graph), internal::reservable_item_buffer<T, internals_allocator>(),
           receiver<T>(), sender<T>(), forwarder_busy(false)
     {
         my_successors.set_owner(this);
         my_aggregator.initialize_handler(handler_type(this));
         tbb::internal::fgt_node( CODEPTR(), tbb::internal::FLOW_BUFFER_NODE, &this->my_graph,
                                  static_cast<receiver<input_type> *>(this), static_cast<sender<output_type> *>(this) );
     }

Member Function Documentation

◆ __TBB_STATIC_ASSERT()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

tbb::flow::interface11::buffer_node< T, Allocator >::__TBB_STATIC_ASSERT	(	(tbb::internal::is_same_type< Allocator, null_type >::value)	,
		"Allocator template parameter for flow graph nodes is deprecated and will be removed. " "Specify TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to temporary enable the deprecated interface."
	)

◆ enqueue_forwarding_task()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

bool tbb::flow::interface11::buffer_node< T, Allocator >::enqueue_forwarding_task ( buffer_operation & op_data )

inlineprotected

Definition at line 2178 of file flow_graph.h.

                                                                    {
         task *ft = grab_forwarding_task(op_data);
         if(ft) {
             internal::spawn_in_graph_arena(graph_reference(), *ft);
             return true;
         }
         return false;
     }

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::register_successor(), tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::remove_successor(), tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::try_consume(), tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::try_get(), tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::try_release(), and tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::try_reserve().

Here is the caller graph for this function:

◆ forward_task()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

virtual task* tbb::flow::interface11::buffer_node< T, Allocator >::forward_task ( )

inlineprotectedvirtual

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

Definition at line 2188 of file flow_graph.h.

                                  {
         buffer_operation op_data(try_fwd_task);
         task *last_task = NULL;
         do {
             op_data.status = internal::WAIT;
             op_data.ltask = NULL;
             my_aggregator.execute(&op_data);
  
             // workaround for icc bug
             tbb::task *xtask = op_data.ltask;
             graph& g = this->my_graph;
             last_task = combine_tasks(g, last_task, xtask);
         } while (op_data.status ==internal::SUCCEEDED);
         return last_task;
     }

◆ grab_forwarding_task()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

task* tbb::flow::interface11::buffer_node< T, Allocator >::grab_forwarding_task ( buffer_operation & op_data )

inlineprotected

Definition at line 2174 of file flow_graph.h.

                                                                   {
         return op_data.ltask;
     }

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::enqueue_forwarding_task(), and tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::try_put_task().

Here is the caller graph for this function:

◆ graph_reference()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

graph& tbb::flow::interface11::buffer_node< T, Allocator >::graph_reference ( ) const

inlineprotectedvirtual

Implements tbb::flow::interface11::receiver< T >.

Definition at line 2530 of file flow_graph.h.

                                                   {
         return my_graph;
     }

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::enqueue_forwarding_task(), and tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::try_put_task().

Here is the caller graph for this function:

◆ handle_operations()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

virtual void tbb::flow::interface11::buffer_node< T, Allocator >::handle_operations ( buffer_operation * op_list )

inlineprotectedvirtual

Definition at line 2121 of file flow_graph.h.

                                                               {
         handle_operations_impl(op_list, this);
     }

◆ handle_operations_impl()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

template<typename derived_type >

void tbb::flow::interface11::buffer_node< T, Allocator >::handle_operations_impl	(	buffer_operation *	op_list,
		derived_type *	derived
	)

inlineprotected

Definition at line 2126 of file flow_graph.h.

                                                                                   {
         __TBB_ASSERT(static_cast<class_type*>(derived) == this, "'this' is not a base class for derived");
  
         buffer_operation *tmp = NULL;
         bool try_forwarding = false;
         while (op_list) {
             tmp = op_list;
             op_list = op_list->next;
             switch (tmp->type) {
             case reg_succ: internal_reg_succ(tmp); try_forwarding = true; break;
             case rem_succ: internal_rem_succ(tmp); break;
             case req_item: internal_pop(tmp); break;
             case res_item: internal_reserve(tmp); break;
             case rel_res:  internal_release(tmp); try_forwarding = true; break;
             case con_res:  internal_consume(tmp); try_forwarding = true; break;
             case put_item: try_forwarding = internal_push(tmp); break;
             case try_fwd_task: internal_forward_task(tmp); break;
 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             // edge recording
             case add_blt_succ: internal_add_built_succ(tmp); break;
             case del_blt_succ: internal_del_built_succ(tmp); break;
             case add_blt_pred: internal_add_built_pred(tmp); break;
             case del_blt_pred: internal_del_built_pred(tmp); break;
             case blt_succ_cnt: internal_succ_cnt(tmp); break;
             case blt_pred_cnt: internal_pred_cnt(tmp); break;
             case blt_succ_cpy: internal_copy_succs(tmp); break;
             case blt_pred_cpy: internal_copy_preds(tmp); break;
 #endif
             }
         }
  
         derived->order();
  
         if (try_forwarding && !forwarder_busy) {
             if(internal::is_graph_active(this->my_graph)) {
                 forwarder_busy = true;
                 task *new_task = new(task::allocate_additional_child_of(*(this->my_graph.root_task()))) internal::
                     forward_task_bypass<class_type>(*this);
                 // tmp should point to the last item handled by the aggregator.  This is the operation
                 // the handling thread enqueued.  So modifying that record will be okay.
                 // workaround for icc bug
                 tbb::task *z = tmp->ltask;
                 graph &g = this->my_graph;
                 tmp->ltask = combine_tasks(g, z, new_task);  // in case the op generated a task
             }
         }
     }  // handle_operations

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::handle_operations().

Here is the caller graph for this function:

◆ internal_consume()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

virtual void tbb::flow::interface11::buffer_node< T, Allocator >::internal_consume ( buffer_operation * op )

inlineprotectedvirtual

Definition at line 2339 of file flow_graph.h.

                                                         {
         this->consume_front();
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
     }

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::handle_operations_impl().

Here is the caller graph for this function:

◆ internal_forward_task()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

virtual void tbb::flow::interface11::buffer_node< T, Allocator >::internal_forward_task ( buffer_operation * op )

inlineprotectedvirtual

Tries to forward valid items to successors.

Definition at line 2286 of file flow_graph.h.

                                                              {
         internal_forward_task_impl(op, this);
     }

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::handle_operations_impl().

Here is the caller graph for this function:

◆ internal_forward_task_impl()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

template<typename derived_type >

void tbb::flow::interface11::buffer_node< T, Allocator >::internal_forward_task_impl	(	buffer_operation *	op,
		derived_type *	derived
	)

inlineprotected

Definition at line 2291 of file flow_graph.h.

                                                                                  {
         __TBB_ASSERT(static_cast<class_type*>(derived) == this, "'this' is not a base class for derived");
  
         if (this->my_reserved || !derived->is_item_valid()) {
             __TBB_store_with_release(op->status, internal::FAILED);
             this->forwarder_busy = false;
             return;
         }
         // Try forwarding, giving each successor a chance
         task * last_task = NULL;
         size_type counter = my_successors.size();
         for (; counter > 0 && derived->is_item_valid(); --counter)
             derived->try_put_and_add_task(last_task);
  
         op->ltask = last_task;  // return task
         if (last_task && !counter) {
             __TBB_store_with_release(op->status, internal::SUCCEEDED);
         }
         else {
             __TBB_store_with_release(op->status, internal::FAILED);
             forwarder_busy = false;
         }
     }

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::internal_forward_task().

Here is the caller graph for this function:

◆ internal_pop()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

virtual void tbb::flow::interface11::buffer_node< T, Allocator >::internal_pop ( buffer_operation * op )

inlineprotectedvirtual

Definition at line 2321 of file flow_graph.h.

                                                     {
         if(this->pop_back(*(op->elem))) {
             __TBB_store_with_release(op->status, internal::SUCCEEDED);
         }
         else {
             __TBB_store_with_release(op->status, internal::FAILED);
         }
     }

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::handle_operations_impl().

Here is the caller graph for this function:

◆ internal_push()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

virtual bool tbb::flow::interface11::buffer_node< T, Allocator >::internal_push ( buffer_operation * op )

inlineprotectedvirtual

Definition at line 2315 of file flow_graph.h.

                                                      {
         this->push_back(*(op->elem));
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
         return true;
     }

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::handle_operations_impl().

Here is the caller graph for this function:

◆ internal_reg_succ()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

virtual void tbb::flow::interface11::buffer_node< T, Allocator >::internal_reg_succ ( buffer_operation * op )

inlineprotectedvirtual

Register successor.

Definition at line 2205 of file flow_graph.h.

                                                          {
         my_successors.register_successor(*(op->r));
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
     }

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::handle_operations_impl().

Here is the caller graph for this function:

◆ internal_release()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

virtual void tbb::flow::interface11::buffer_node< T, Allocator >::internal_release ( buffer_operation * op )

inlineprotectedvirtual

Definition at line 2344 of file flow_graph.h.

                                                         {
         this->release_front();
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
     }

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::handle_operations_impl().

Here is the caller graph for this function:

◆ internal_rem_succ()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

virtual void tbb::flow::interface11::buffer_node< T, Allocator >::internal_rem_succ ( buffer_operation * op )

inlineprotectedvirtual

Remove successor.

Definition at line 2211 of file flow_graph.h.

                                                          {
         my_successors.remove_successor(*(op->r));
         __TBB_store_with_release(op->status, internal::SUCCEEDED);
     }

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::handle_operations_impl().

Here is the caller graph for this function:

◆ internal_reserve()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

virtual void tbb::flow::interface11::buffer_node< T, Allocator >::internal_reserve ( buffer_operation * op )

inlineprotectedvirtual

Definition at line 2330 of file flow_graph.h.

                                                         {
         if(this->reserve_front(*(op->elem))) {
             __TBB_store_with_release(op->status, internal::SUCCEEDED);
         }
         else {
             __TBB_store_with_release(op->status, internal::FAILED);
         }
     }

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::handle_operations_impl().

Here is the caller graph for this function:

◆ is_item_valid()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

bool tbb::flow::interface11::buffer_node< T, Allocator >::is_item_valid ( )

inlineprivate

Definition at line 2270 of file flow_graph.h.

                          {
         return this->my_item_valid(this->my_tail - 1);
     }

◆ order()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

void tbb::flow::interface11::buffer_node< T, Allocator >::order ( )

inlineprivate

Definition at line 2268 of file flow_graph.h.

2268 {}

◆ register_successor()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

bool tbb::flow::interface11::buffer_node< T, Allocator >::register_successor ( successor_type & r )

inline

Adds a new successor.

Adds successor r to the list of successors; may forward tasks.

Definition at line 2391 of file flow_graph.h.

                                                                 {
         buffer_operation op_data(reg_succ);
         op_data.r = &r;
         my_aggregator.execute(&op_data);
         (void)enqueue_forwarding_task(op_data);
         return true;
     }

◆ remove_successor()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

bool tbb::flow::interface11::buffer_node< T, Allocator >::remove_successor ( successor_type & r )

inline

Removes a successor.

Removes successor r from the list of successors. It also calls r.remove_predecessor(*this) to remove this node as a predecessor.

Definition at line 2453 of file flow_graph.h.

                                                               {
         r.remove_predecessor(*this);
         buffer_operation op_data(rem_succ);
         op_data.r = &r;
         my_aggregator.execute(&op_data);
         // even though this operation does not cause a forward, if we are the handler, and
         // a forward is scheduled, we may be the first to reach this point after the aggregator,
         // and so should check for the task.
         (void)enqueue_forwarding_task(op_data);
         return true;
     }

◆ reset_node()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

void tbb::flow::interface11::buffer_node< T, Allocator >::reset_node ( reset_flags f )

inlineprotectedvirtual

Implements tbb::flow::interface11::graph_node.

Reimplemented in tbb::flow::interface11::queue_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >.

Definition at line 2545 of file flow_graph.h.

                                                    {
         internal::reservable_item_buffer<T, internals_allocator>::reset();
         // TODO: just clear structures
         if (f&rf_clear_edges) {
             my_successors.clear();
 #if TBB_DEPRECATED_FLOW_NODE_EXTRACTION
             my_built_predecessors.clear();
 #endif
         }
         forwarder_busy = false;
     }

Referenced by tbb::flow::interface11::queue_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::reset_node(), and tbb::flow::interface11::priority_queue_node< T, Compare, Allocator >::reset_node().

Here is the caller graph for this function:

◆ reset_receiver()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

void tbb::flow::interface11::buffer_node< T, Allocator >::reset_receiver ( reset_flags f )

inlineprotectedvirtual

put receiver back in initial state

Implements tbb::flow::interface11::receiver< T >.

Definition at line 2534 of file flow_graph.h.

2534 { }

◆ try_consume()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

bool tbb::flow::interface11::buffer_node< T, Allocator >::try_consume ( )

inlinevirtual

Consumes a reserved item.

true = item is removed from sender and reservation removed

Reimplemented from tbb::flow::interface11::sender< T >.

Definition at line 2498 of file flow_graph.h.

                                       {
         buffer_operation op_data(con_res);
         my_aggregator.execute(&op_data);
         (void)enqueue_forwarding_task(op_data);
         return true;
     }

◆ try_get()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

bool tbb::flow::interface11::buffer_node< T, Allocator >::try_get ( T & v )

inlinevirtual

Request an item from the buffer_node.

true = v contains the returned item
false = no item has been returned

Reimplemented from tbb::flow::interface11::sender< T >.

Definition at line 2468 of file flow_graph.h.

                                         {
         buffer_operation op_data(req_item);
         op_data.elem = &v;
         my_aggregator.execute(&op_data);
         (void)enqueue_forwarding_task(op_data);
         return (op_data.status==internal::SUCCEEDED);
     }

◆ try_put_and_add_task()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

void tbb::flow::interface11::buffer_node< T, Allocator >::try_put_and_add_task ( task *& last_task )

inlineprivate

Definition at line 2274 of file flow_graph.h.

                                                 {
         task *new_task = my_successors.try_put_task(this->back());
         if (new_task) {
             // workaround for icc bug
             graph& g = this->my_graph;
             last_task = combine_tasks(g, last_task, new_task);
             this->destroy_back();
         }
     }

◆ try_put_task()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

task* tbb::flow::interface11::buffer_node< T, Allocator >::try_put_task ( const T & t )

inlineprotectedvirtual

receive an item, return a task *if possible

Implements tbb::flow::interface11::receiver< T >.

Definition at line 2511 of file flow_graph.h.

                                                   {
         buffer_operation op_data(t, put_item);
         my_aggregator.execute(&op_data);
         task *ft = grab_forwarding_task(op_data);
         // sequencer_nodes can return failure (if an item has been previously inserted)
         // We have to spawn the returned task if our own operation fails.
  
         if(ft && op_data.status ==internal::FAILED) {
             // we haven't succeeded queueing the item, but for some reason the
             // call returned a task (if another request resulted in a successful
             // forward this could happen.)  Queue the task and reset the pointer.
             internal::spawn_in_graph_arena(graph_reference(), *ft); ft = NULL;
         }
         else if(!ft && op_data.status ==internal::SUCCEEDED) {
             ft = SUCCESSFULLY_ENQUEUED;
         }
         return ft;
     }

◆ try_release()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

bool tbb::flow::interface11::buffer_node< T, Allocator >::try_release ( )

inlinevirtual

Release a reserved item.

true = item has been released and so remains in sender

Reimplemented from tbb::flow::interface11::sender< T >.

Definition at line 2489 of file flow_graph.h.

                                       {
         buffer_operation op_data(rel_res);
         my_aggregator.execute(&op_data);
         (void)enqueue_forwarding_task(op_data);
         return true;
     }

◆ try_reserve()

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

bool tbb::flow::interface11::buffer_node< T, Allocator >::try_reserve ( T & v )

inlinevirtual

Reserves an item.

false = no item can be reserved
true = an item is reserved

Reimplemented from tbb::flow::interface11::sender< T >.

Definition at line 2479 of file flow_graph.h.

                                             {
         buffer_operation op_data(res_item);
         op_data.elem = &v;
         my_aggregator.execute(&op_data);
         (void)enqueue_forwarding_task(op_data);
         return (op_data.status==internal::SUCCEEDED);
     }

Friends And Related Function Documentation

◆ internal::aggregating_functor< class_type, buffer_operation >

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

friend class internal::aggregating_functor< class_type, buffer_operation >

friend

Definition at line 2118 of file flow_graph.h.

◆ internal::broadcast_cache

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

template<typename X , typename Y >

friend class internal::broadcast_cache

friend

Definition at line 2508 of file flow_graph.h.

◆ internal::forward_task_bypass< class_type >

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

friend class internal::forward_task_bypass< class_type >

friend

Definition at line 2075 of file flow_graph.h.

◆ internal::round_robin_cache

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

template<typename X , typename Y >

friend class internal::round_robin_cache

friend

Definition at line 2509 of file flow_graph.h.

◆ run_and_put_task

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

template<typename R , typename B >

friend class run_and_put_task

friend

Definition at line 2507 of file flow_graph.h.

Member Data Documentation

◆ forwarder_busy

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

bool tbb::flow::interface11::buffer_node< T, Allocator >::forwarder_busy

protected

Definition at line 2116 of file flow_graph.h.

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::handle_operations_impl(), tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::internal_forward_task_impl(), and tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::reset_node().

◆ my_aggregator

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

internal::aggregator< handler_type, buffer_operation> tbb::flow::interface11::buffer_node< T, Allocator >::my_aggregator

protected

Definition at line 2119 of file flow_graph.h.

◆ my_successors

template<typename T , typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>

internal::round_robin_cache< T, null_rw_mutex > tbb::flow::interface11::buffer_node< T, Allocator >::my_successors

protected

Definition at line 2069 of file flow_graph.h.

Referenced by tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::buffer_node(), tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::internal_forward_task_impl(), tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::internal_reg_succ(), tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::internal_rem_succ(), tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::reset_node(), and tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) >::try_put_and_add_task().

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

flow_graph.h

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

template<typename T, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)> class tbb::flow::interface11::buffer_node< T, Allocator >

Member Typedef Documentation

◆ class_type

◆ handler_type

◆ input_type

◆ internals_allocator

◆ output_type

◆ predecessor_type

◆ size_type

◆ successor_type

Member Enumeration Documentation

◆ op_type

Constructor & Destructor Documentation

◆ buffer_node() [1/2]

◆ buffer_node() [2/2]

Member Function Documentation

◆ __TBB_STATIC_ASSERT()

◆ enqueue_forwarding_task()

◆ forward_task()

◆ grab_forwarding_task()

◆ graph_reference()

◆ handle_operations()

◆ handle_operations_impl()

◆ internal_consume()

◆ internal_forward_task()

◆ internal_forward_task_impl()

◆ internal_pop()

◆ internal_push()

◆ internal_reg_succ()

◆ internal_release()

◆ internal_rem_succ()

◆ internal_reserve()

◆ is_item_valid()

◆ order()

◆ register_successor()

◆ remove_successor()

◆ reset_node()

◆ reset_receiver()

◆ try_consume()

◆ try_get()

◆ try_put_and_add_task()

◆ try_put_task()

◆ try_release()

◆ try_reserve()

Friends And Related Function Documentation

◆ internal::aggregating_functor< class_type, buffer_operation >

◆ internal::broadcast_cache

◆ internal::forward_task_bypass< class_type >

◆ internal::round_robin_cache

◆ run_and_put_task

Member Data Documentation

◆ forwarder_busy

◆ my_aggregator

◆ my_successors

template<typename T, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(T)>
class tbb::flow::interface11::buffer_node< T, Allocator >