tbb::flow::interface10::buffer_node< T, A > Class Template Reference

Forwards messages in arbitrary order. More...

#include <flow_graph.h>

Inheritance diagram for tbb::flow::interface10::buffer_node< T, A >:

Collaboration diagram for tbb::flow::interface10::buffer_node< T, A >:

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, A >	class_type
Public Types inherited from tbb::flow::interface10::internal::item_buffer< T, A >
enum	buffer_item_state { no_item =0, has_item =1, reserved_item =2 }
typedef T	item_type
Public Types inherited from tbb::flow::interface10::receiver< T >
typedef T	input_type
	The input type of this receiver. More...
typedef internal::async_helpers< T >::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 Types inherited from tbb::flow::interface10::sender< T >
typedef T	output_type
	The output type of this sender. More...
typedef internal::async_helpers< T >::filtered_type	filtered_type
Public Types inherited from tbb::flow::interface10::internal::untyped_sender
typedef untyped_receiver	successor_type
	The successor type for this node. More...

Public Member Functions
	buffer_node (graph &g)
	Constructor. More...
	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::interface10::graph_node
	graph_node (graph &g)
virtual	~graph_node ()
Public Member Functions inherited from tbb::flow::interface10::internal::reservable_item_buffer< T, A >
	reservable_item_buffer ()
void	reset ()
Public Member Functions inherited from tbb::flow::interface10::internal::item_buffer< T, A >
	item_buffer ()
	Constructor. More...
	~item_buffer ()
void	reset ()
Public Member Functions inherited from tbb::flow::interface10::receiver< T >
bool	try_put (const typename internal::async_helpers< T >::filtered_type &t)
	Put an item to the receiver. More...
bool	try_put (const typename internal::async_helpers< T >::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...
virtual bool	register_predecessor (predecessor_type &)
	Add a predecessor to the node. More...
virtual bool	remove_predecessor (predecessor_type &)
	Remove a predecessor from the node. More...
Public Member Functions inherited from tbb::flow::interface10::internal::untyped_sender
virtual	~untyped_sender ()

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 tbb::flow::interface10::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

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 () __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 tbb::flow::interface10::internal::reservable_item_buffer< T, A >
bool	reserve_front (T &v)
void	consume_front ()
void	release_front ()
Protected Member Functions inherited from tbb::flow::interface10::internal::item_buffer< T, A >
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::interface10::receiver< T >
virtual task *	try_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 >
task *	try_put_task (const X &t)
virtual bool	is_continue_receiver ()
Protected Member Functions inherited from tbb::flow::interface10::sender< T >
virtual bool	try_get_wrapper (void *p, bool is_async) __TBB_override
virtual bool	try_reserve_wrapper (void *p, bool is_async) __TBB_override
Protected Member Functions inherited from tbb::flow::interface10::internal::untyped_sender
template<typename X >
bool	try_get (X &t)
	Request an item from the sender. More...
template<typename X >
bool	try_reserve (X &t)
	Reserves an item in the sender. More...

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::interface10::graph_node
graph &	my_graph
graph_node *	next
graph_node *	prev
Protected Attributes inherited from tbb::flow::interface10::internal::reservable_item_buffer< T, A >
bool	my_reserved
Protected Attributes inherited from tbb::flow::interface10::internal::item_buffer< T, A >
buffer_item_type *	my_array
size_type	my_array_size
size_type	my_head
size_type	my_tail

Private Member Functions
void	order ()
bool	is_item_valid ()
void	try_put_and_add_task (task *&last_task)

Friends
class	internal::forward_task_bypass< buffer_node< T, A > >
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
Static Protected Attributes inherited from tbb::flow::interface10::internal::item_buffer< T, A >
static const size_type	initial_buffer_size = 4

Detailed Description

template<typename T, typename A = cache_aligned_allocator<T>>
class tbb::flow::interface10::buffer_node< T, A >

Forwards messages in arbitrary order.

Definition at line 1529 of file flow_graph.h.

Member Typedef Documentation

class_type

template<typename T, typename A = cache_aligned_allocator<T>>

typedef buffer_node<T, A> tbb::flow::interface10::buffer_node< T, A >::class_type

Definition at line 1535 of file flow_graph.h.

handler_type

template<typename T, typename A = cache_aligned_allocator<T>>

typedef internal::aggregating_functor<class_type, buffer_operation> tbb::flow::interface10::buffer_node< T, A >::handler_type

protected

Definition at line 1590 of file flow_graph.h.

input_type

template<typename T, typename A = cache_aligned_allocator<T>>

typedef T tbb::flow::interface10::buffer_node< T, A >::input_type

Definition at line 1531 of file flow_graph.h.

output_type

template<typename T, typename A = cache_aligned_allocator<T>>

typedef T tbb::flow::interface10::buffer_node< T, A >::output_type

Definition at line 1532 of file flow_graph.h.

predecessor_type

template<typename T, typename A = cache_aligned_allocator<T>>

typedef receiver<input_type>::predecessor_type tbb::flow::interface10::buffer_node< T, A >::predecessor_type

Definition at line 1533 of file flow_graph.h.

size_type

template<typename T, typename A = cache_aligned_allocator<T>>

typedef size_t tbb::flow::interface10::buffer_node< T, A >::size_type

protected

Definition at line 1541 of file flow_graph.h.

successor_type

template<typename T, typename A = cache_aligned_allocator<T>>

typedef sender<output_type>::successor_type tbb::flow::interface10::buffer_node< T, A >::successor_type

Definition at line 1534 of file flow_graph.h.

Member Enumeration Documentation

op_type

template<typename T, typename A = cache_aligned_allocator<T>>

enum tbb::flow::interface10::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 1550 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 A = cache_aligned_allocator<T>>

tbb::flow::interface10::buffer_node< T, A >::buffer_node ( graph &  g )

inlineexplicit

Constructor.

Definition at line 1825 of file flow_graph.h.

                                     : graph_node(g), internal::reservable_item_buffer<T>(),
        forwarder_busy(false) {
        my_successors.set_owner(this);
        my_aggregator.initialize_handler(handler_type(this));
        tbb::internal::fgt_node( 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 A = cache_aligned_allocator<T>>

tbb::flow::interface10::buffer_node< T, A >::buffer_node ( const buffer_node< T, A > &  src )

inline

Copy constructor.

Definition at line 1834 of file flow_graph.h.

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

References tbb::internal::fgt_node(), and tbb::flow::interface10::internal::successor_cache< T, M >::set_owner().

Here is the call graph for this function:

Member Function Documentation

enqueue_forwarding_task()

template<typename T, typename A = cache_aligned_allocator<T>>

bool tbb::flow::interface10::buffer_node< T, A >::enqueue_forwarding_task ( buffer_operation &  op_data )

inlineprotected

Definition at line 1652 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;
    }

forward_task()

template<typename T, typename A = cache_aligned_allocator<T>>

virtual task* tbb::flow::interface10::buffer_node< T, A >::forward_task ( )

inlineprotectedvirtual

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

Definition at line 1662 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 A = cache_aligned_allocator<T>>

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

inlineprotected

Definition at line 1648 of file flow_graph.h.

                                                                  {
        return op_data.ltask;
    }

graph_reference()

template<typename T, typename A = cache_aligned_allocator<T>>

graph& tbb::flow::interface10::buffer_node< T, A >::graph_reference ( )

inlineprotectedvirtual

Implements tbb::flow::interface10::internal::untyped_receiver.

Definition at line 1994 of file flow_graph.h.

                                            {
        return my_graph;
    }

handle_operations()

template<typename T, typename A = cache_aligned_allocator<T>>

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

inlineprotectedvirtual

Reimplemented in tbb::flow::interface10::priority_queue_node< T, Compare, A >.

Definition at line 1594 of file flow_graph.h.

                                                              {
        handle_operations_impl(op_list, this);
    }

handle_operations_impl()

template<typename T, typename A = cache_aligned_allocator<T>>

template<typename derived_type >

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

inlineprotected

Definition at line 1599 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
                        < buffer_node<input_type, A> >(*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

internal_consume()

template<typename T, typename A = cache_aligned_allocator<T>>

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

inlineprotectedvirtual

Reimplemented in tbb::flow::interface10::priority_queue_node< T, Compare, A >, and tbb::flow::interface10::queue_node< T, A >.

Definition at line 1813 of file flow_graph.h.

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

internal_forward_task()

template<typename T, typename A = cache_aligned_allocator<T>>

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

inlineprotectedvirtual

Tries to forward valid items to successors.

Reimplemented in tbb::flow::interface10::priority_queue_node< T, Compare, A >, and tbb::flow::interface10::queue_node< T, A >.

Definition at line 1760 of file flow_graph.h.

                                                             {
        internal_forward_task_impl(op, this);
    }

internal_forward_task_impl()

template<typename T, typename A = cache_aligned_allocator<T>>

template<typename derived_type >

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

inlineprotected

Definition at line 1765 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;
        }
    }

internal_pop()

template<typename T, typename A = cache_aligned_allocator<T>>

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

inlineprotectedvirtual

Reimplemented in tbb::flow::interface10::priority_queue_node< T, Compare, A >, and tbb::flow::interface10::queue_node< T, A >.

Definition at line 1795 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);
        }
    }

References tbb::internal::__TBB_store_with_release(), tbb::flow::interface10::buffer_node< T, A >::buffer_operation::elem, and tbb::flow::interface10::internal::SUCCEEDED.

Here is the call graph for this function:

internal_push()

template<typename T, typename A = cache_aligned_allocator<T>>

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

inlineprotectedvirtual

Reimplemented in tbb::flow::interface10::priority_queue_node< T, Compare, A >, and tbb::flow::interface10::sequencer_node< T, A >.

Definition at line 1789 of file flow_graph.h.

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

References tbb::internal::__TBB_store_with_release(), tbb::flow::interface10::buffer_node< T, A >::buffer_operation::elem, and tbb::flow::interface10::internal::SUCCEEDED.

Here is the call graph for this function:

internal_reg_succ()

template<typename T, typename A = cache_aligned_allocator<T>>

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

inlineprotectedvirtual

Register successor.

Definition at line 1679 of file flow_graph.h.

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

References tbb::internal::__TBB_store_with_release(), tbb::flow::interface10::buffer_node< T, A >::buffer_operation::r, tbb::flow::interface10::internal::successor_cache< T, M >::register_successor(), and tbb::flow::interface10::internal::SUCCEEDED.

Here is the call graph for this function:

internal_release()

template<typename T, typename A = cache_aligned_allocator<T>>

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

inlineprotectedvirtual

Reimplemented in tbb::flow::interface10::priority_queue_node< T, Compare, A >.

Definition at line 1818 of file flow_graph.h.

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

internal_rem_succ()

template<typename T, typename A = cache_aligned_allocator<T>>

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

inlineprotectedvirtual

Remove successor.

Definition at line 1685 of file flow_graph.h.

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

References tbb::internal::__TBB_store_with_release(), tbb::flow::interface10::buffer_node< T, A >::buffer_operation::r, tbb::flow::interface10::internal::successor_cache< T, M >::remove_successor(), and tbb::flow::interface10::internal::SUCCEEDED.

Here is the call graph for this function:

internal_reserve()

template<typename T, typename A = cache_aligned_allocator<T>>

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

inlineprotectedvirtual

Reimplemented in tbb::flow::interface10::priority_queue_node< T, Compare, A >, and tbb::flow::interface10::queue_node< T, A >.

Definition at line 1804 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);
        }
    }

is_item_valid()

template<typename T, typename A = cache_aligned_allocator<T>>

bool tbb::flow::interface10::buffer_node< T, A >::is_item_valid ( )

inlineprivate

Definition at line 1744 of file flow_graph.h.

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

order()

template<typename T, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::buffer_node< T, A >::order ( )

inlineprivate

Definition at line 1742 of file flow_graph.h.

{}

register_successor()

template<typename T, typename A = cache_aligned_allocator<T>>

bool tbb::flow::interface10::buffer_node< T, A >::register_successor ( successor_type &  r )

inlinevirtual

Adds a new successor.

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

Implements tbb::flow::interface10::internal::untyped_sender.

Definition at line 1855 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;
    }

References tbb::flow::interface10::buffer_node< T, A >::buffer_operation::r.

remove_successor()

template<typename T, typename A = cache_aligned_allocator<T>>

bool tbb::flow::interface10::buffer_node< T, A >::remove_successor ( successor_type &  r )

inlinevirtual

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.

Implements tbb::flow::interface10::internal::untyped_sender.

Definition at line 1917 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;
    }

References tbb::flow::interface10::buffer_node< T, A >::buffer_operation::r.

reset_node()

template<typename T, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::buffer_node< T, A >::reset_node ( reset_flags  f )

inlineprotectedvirtual

Implements tbb::flow::interface10::graph_node.

Reimplemented in tbb::flow::interface10::priority_queue_node< T, Compare, A >, and tbb::flow::interface10::queue_node< T, A >.

Definition at line 2009 of file flow_graph.h.

                                                   {
        internal::reservable_item_buffer<T, A>::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;
    }

References internal::successor_cache< T, M >::my_successors, tbb::flow::interface10::internal::reservable_item_buffer< T, A >::reset(), and tbb::flow::interface10::rf_clear_edges.

Here is the call graph for this function:

reset_receiver()

template<typename T, typename A = cache_aligned_allocator<T>>

void tbb::flow::interface10::buffer_node< T, A >::reset_receiver ( reset_flags  f )

inlineprotectedvirtual

put receiver back in initial state

Implements tbb::flow::interface10::internal::untyped_receiver.

Definition at line 1998 of file flow_graph.h.

{ }

try_consume()

template<typename T, typename A = cache_aligned_allocator<T>>

bool tbb::flow::interface10::buffer_node< T, A >::try_consume ( )

inlinevirtual

Consumes a reserved item.

true = item is removed from sender and reservation removed

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

Definition at line 1962 of file flow_graph.h.

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

References void.

try_get()

template<typename T, typename A = cache_aligned_allocator<T>>

bool tbb::flow::interface10::buffer_node< T, A >::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::interface10::sender< T >.

Definition at line 1932 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 A = cache_aligned_allocator<T>>

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

inlineprivate

Definition at line 1748 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 A = cache_aligned_allocator<T>>

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

inlineprotectedvirtual

receive an item, return a task *if possible

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

Definition at line 1975 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 A = cache_aligned_allocator<T>>

bool tbb::flow::interface10::buffer_node< T, A >::try_release ( )

inlinevirtual

Release a reserved item.

true = item has been released and so remains in sender

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

Definition at line 1953 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 A = cache_aligned_allocator<T>>

bool tbb::flow::interface10::buffer_node< T, A >::try_reserve ( T &  v )

inlinevirtual

Reserves an item.

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

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

Definition at line 1943 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 A = cache_aligned_allocator<T>>

friend class internal::aggregating_functor< class_type, buffer_operation >

friend

Definition at line 1591 of file flow_graph.h.

internal::broadcast_cache

template<typename T, typename A = cache_aligned_allocator<T>>

template<typename X , typename Y >

friend class internal::broadcast_cache

friend

Definition at line 1972 of file flow_graph.h.

internal::forward_task_bypass< buffer_node< T, A > >

template<typename T, typename A = cache_aligned_allocator<T>>

friend class internal::forward_task_bypass< buffer_node< T, A > >

friend

Definition at line 1548 of file flow_graph.h.

internal::round_robin_cache

template<typename T, typename A = cache_aligned_allocator<T>>

template<typename X , typename Y >

friend class internal::round_robin_cache

friend

Definition at line 1973 of file flow_graph.h.

run_and_put_task

template<typename T, typename A = cache_aligned_allocator<T>>

template<typename R , typename B >

friend class run_and_put_task

friend

Definition at line 1971 of file flow_graph.h.

Member Data Documentation

forwarder_busy

template<typename T, typename A = cache_aligned_allocator<T>>

bool tbb::flow::interface10::buffer_node< T, A >::forwarder_busy

protected

Definition at line 1589 of file flow_graph.h.

my_aggregator

template<typename T, typename A = cache_aligned_allocator<T>>

internal::aggregator< handler_type, buffer_operation> tbb::flow::interface10::buffer_node< T, A >::my_aggregator

protected

Definition at line 1592 of file flow_graph.h.

my_successors

template<typename T, typename A = cache_aligned_allocator<T>>

internal::round_robin_cache< T, null_rw_mutex > tbb::flow::interface10::buffer_node< T, A >::my_successors

protected

Definition at line 1542 of file flow_graph.h.

---

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

• flow_graph.h