tbb::flow::interface11::async_node< Input, Output, Policy, Allocator > Class Template Reference

Implements async node. More...

#include <flow_graph.h>

Inheritance diagram for tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >:

Collaboration diagram for tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >:

Classes
class	receiver_gateway_impl
struct	try_put_functor

Public Types
typedef Input	input_type
typedef Output	output_type
typedef receiver< input_type >	receiver_type
typedef receiver_type::predecessor_type	predecessor_type
typedef sender< output_type >::successor_type	successor_type
typedef receiver_gateway< output_type >	gateway_type
typedef internal::async_body_base< gateway_type >	async_body_base_type
typedef base_type::output_ports_type	output_ports_type
Public Types inherited from tbb::flow::interface11::multifunction_node< Input, Output, Policy, Allocator >
typedef Input	input_type
typedef null_type	output_type
typedef internal::wrap_tuple_elements< N, internal::multifunction_output, Output >::type	output_ports_type
typedef internal::multifunction_input< input_type, output_ports_type, Policy, internals_allocator >	input_impl_type
typedef internal::function_input_queue< input_type, internals_allocator >	input_queue_type
Public Types inherited from internal::multifunction_input< Input, OutputPortSet, Policy, A >
typedef Input	input_type
typedef OutputPortSet	output_ports_type
typedef multifunction_body< input_type, output_ports_type >	multifunction_body_type
typedef multifunction_input< Input, OutputPortSet, Policy, A >	my_class
typedef function_input_base< Input, Policy, A, my_class >	base_type
typedef function_input_queue< input_type, A >	input_queue_type
Public Types inherited from internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >
typedef Input	input_type
	The input type of this receiver.
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 tbb::internal::allocator_rebind< A, input_queue_type >::type	queue_allocator_type
Public Types inherited from tbb::flow::interface11::internal::untyped_receiver
typedef untyped_sender	predecessor_type
	The predecessor type for this node.
Public Types inherited from tbb::flow::interface11::internal::untyped_sender
typedef untyped_receiver	successor_type
	The successor type for this node.

Public Member Functions
template<typename Body >
__TBB_NOINLINE_SYM	async_node (graph &g, size_t concurrency,)
__TBB_NOINLINE_SYM	async_node (const async_node &other)
gateway_type &	gateway ()
bool	register_successor (successor_type &r) __TBB_override
	Add a new successor to this node.
bool	remove_successor (successor_type &r) __TBB_override
	Removes a successor from this node.
template<typename Body >
Body	copy_function_object ()
Public Member Functions inherited from tbb::flow::interface11::multifunction_node< Input, Output, Policy, Allocator >
template<typename Body >
__TBB_NOINLINE_SYM	multifunction_node (graph &g, size_t concurrency,)
__TBB_NOINLINE_SYM	multifunction_node (const multifunction_node &other)
Public Member Functions inherited from tbb::flow::interface11::graph_node
	graph_node (graph &g)
virtual	~graph_node ()
Public Member Functions inherited from internal::multifunction_input< Input, OutputPortSet, Policy, A >
template<typename Body >
	multifunction_input (graph &g, size_t max_concurrency,)
	multifunction_input (const multifunction_input &src)
	Copy constructor.
	~multifunction_input ()
template<typename Body >
Body	copy_function_object ()
task *	apply_body_impl_bypass (const input_type &i)
output_ports_type &	output_ports ()
Public Member Functions inherited from internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >
	__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.
	function_input_base (const function_input_base &src)
	Copy constructor.
virtual	~function_input_base ()
	Destructor.
task *	try_put_task (const input_type &t) __TBB_override
	Put item to successor; return task to run the successor if possible.
bool	register_predecessor (predecessor_type &src) __TBB_override
	Adds src to the list of cached predecessors.
bool	remove_predecessor (predecessor_type &src) __TBB_override
	Removes src from the list of cached predecessors.
Public Member Functions inherited from tbb::flow::interface11::receiver< Input >
bool	try_put (const typename internal::async_helpers< Input >::filtered_type &t)
	Put an item to the receiver.
bool	try_put (const typename internal::async_helpers< Input >::async_type &t)
Public Member Functions inherited from tbb::flow::interface11::internal::untyped_receiver
virtual	~untyped_receiver ()
	Destructor.
template<typename X >
bool	try_put (const X &t)
	Put an item to the receiver.
virtual bool	register_predecessor (predecessor_type &)
	Add a predecessor to the node.
virtual bool	remove_predecessor (predecessor_type &)
	Remove a predecessor from the node.
Public Member Functions inherited from tbb::flow::interface11::sender< Output >
virtual bool	try_get (Output &)
	Request an item from the sender.
virtual bool	try_reserve (Output &)
	Reserves an item in the sender.
Public Member Functions inherited from tbb::flow::interface11::internal::untyped_sender
virtual	~untyped_sender ()
virtual bool	register_successor (successor_type &r)=0
	Add a new successor to this node.
virtual bool	remove_successor (successor_type &r)=0
	Removes a successor from this node.
virtual bool	try_release ()
	Releases the reserved item.
virtual bool	try_consume ()
	Consumes the reserved item.

Protected Member Functions
void	reset_node (reset_flags f) __TBB_override
void	reset_node (reset_flags f) __TBB_override
virtual void	reset_node (reset_flags f=rf_reset_protocol)=0
Protected Member Functions inherited from internal::multifunction_input< Input, OutputPortSet, Policy, A >
void	reset (reset_flags f)
Protected Member Functions inherited from internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >
void	reset_function_input_base (reset_flags f)
void	reset_receiver (reset_flags f) __TBB_override
graph &	graph_reference () const __TBB_override
task *	try_get_postponed_task (const input_type &i)
Protected Member Functions inherited from tbb::flow::interface11::receiver< Input >
virtual task *	try_put_task_wrapper (const void *p, bool is_async) __TBB_override
virtual task *	try_put_task (const Input &t)=0
	Put item to successor; return task to run the successor if possible.
Protected Member Functions inherited from tbb::flow::interface11::internal::untyped_receiver
template<typename X >
task *	try_put_task (const X &t)
virtual task *	try_put_task_wrapper (const void *p, bool is_async)=0
virtual graph &	graph_reference () const =0
virtual void	reset_receiver (reset_flags f=rf_reset_protocol)=0
	put receiver back in initial state
virtual bool	is_continue_receiver ()
Protected Member Functions inherited from tbb::flow::interface11::sender< Output >
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::interface11::internal::untyped_sender
template<typename X >
bool	try_get (X &t)
	Request an item from the sender.
template<typename X >
bool	try_reserve (X &t)
	Reserves an item in the sender.
virtual bool	try_get_wrapper (void *p, bool is_async)=0
virtual bool	try_reserve_wrapper (void *p, bool is_async)=0

Private Types
typedef multifunction_node< Input, tuple< Output >, Policy, Allocator >	base_type
typedef internal::multifunction_input< Input, typename base_type::output_ports_type, Policy, Allocator >	mfn_input_type

Private 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 removed in the future. " "To temporary enable the deprecated interface specify TBB_ENABLE_DEPRECATED_NODE_ALLOCATOR.")
async_node *	self ()
bool	try_put_impl (const Output &i)
	Implements gateway_type::try_put for an external activity to submit a message to FG.

Private Attributes
tbb::flow::interface11::async_node::receiver_gateway_impl	my_gateway

Additional Inherited Members
Public Attributes inherited from tbb::flow::interface11::receiver< Input >
__TBB_DEPRECATED typedef Input	input_type
	The input type of this receiver.
__TBB_DEPRECATED typedef internal::async_helpers< Input >::filtered_type	filtered_type
Public Attributes inherited from tbb::flow::interface11::sender< Output >
__TBB_DEPRECATED typedef Output	output_type
	The output type of this sender.
__TBB_DEPRECATED typedef internal::async_helpers< Output >::filtered_type	filtered_type
Static Public Attributes inherited from internal::multifunction_input< Input, OutputPortSet, Policy, A >
static const int	N = tbb::flow::tuple_size<OutputPortSet>::value
Protected Attributes inherited from tbb::flow::interface11::graph_node
graph &	my_graph
graph_node *	next
graph_node *	prev
Protected Attributes inherited from internal::multifunction_input< Input, OutputPortSet, Policy, A >
multifunction_body_type *	my_body
multifunction_body_type *	my_init_body
output_ports_type	my_output_ports
Protected Attributes inherited from internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >
graph &	my_graph_ref
const size_t	my_max_concurrency
size_t	my_concurrency
input_queue_type *	my_queue
predecessor_cache< input_type, null_mutex >	my_predecessors
Static Protected Attributes inherited from tbb::flow::interface11::multifunction_node< Input, Output, Policy, Allocator >
static const int	N = tbb::flow::tuple_size<Output>::value

Detailed Description

template<typename Input, typename Output, typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>
class tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >

Implements async node.

Definition at line 4211 of file flow_graph.h.

Member Typedef Documentation

async_body_base_type

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

typedef internal::async_body_base<gateway_type> tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::async_body_base_type

Definition at line 4231 of file flow_graph.h.

base_type

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

typedef multifunction_node< Input, tuple< Output >, Policy, Allocator > tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::base_type

private

Definition at line 4221 of file flow_graph.h.

gateway_type

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

typedef receiver_gateway<output_type> tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::gateway_type

Definition at line 4230 of file flow_graph.h.

input_type

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

typedef Input tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::input_type

Definition at line 4225 of file flow_graph.h.

mfn_input_type

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

typedef internal::multifunction_input<Input, typename base_type::output_ports_type, Policy, Allocator> tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::mfn_input_type

private

Definition at line 4222 of file flow_graph.h.

output_ports_type

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

typedef base_type::output_ports_type tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::output_ports_type

Definition at line 4232 of file flow_graph.h.

output_type

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

typedef Output tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::output_type

Definition at line 4226 of file flow_graph.h.

predecessor_type

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

typedef receiver_type::predecessor_type tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::predecessor_type

Definition at line 4228 of file flow_graph.h.

receiver_type

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

typedef receiver<input_type> tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::receiver_type

Definition at line 4227 of file flow_graph.h.

successor_type

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

typedef sender<output_type>::successor_type tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::successor_type

Definition at line 4229 of file flow_graph.h.

Constructor & Destructor Documentation

async_node() [1/2]

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

template<typename Body >

__TBB_NOINLINE_SYM tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::async_node ( graph &  g, size_t  concurrency  )

inline

Definition at line 4291 of file flow_graph.h.

      : base_type(
        g, concurrency,
        internal::async_body<Input, typename base_type::output_ports_type, gateway_type, Body>
        (body, &my_gateway) __TBB_FLOW_GRAPH_PRIORITY_ARG0(priority) ), my_gateway(self()) {
        tbb::internal::fgt_multioutput_node_with_body<1>(
            CODEPTR(), tbb::internal::FLOW_ASYNC_NODE,
            &this->my_graph, static_cast<receiver<input_type> *>(this),
            this->output_ports(), this->my_body
        );
    }

References CODEPTR.

async_node() [2/2]

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

__TBB_NOINLINE_SYM tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::async_node ( const async_node< Input, Output, Policy, Allocator > &  other )

inline

Definition at line 4331 of file flow_graph.h.

                                                             : base_type(other), sender<Output>(), my_gateway(self()) {
        static_cast<async_body_base_type*>(this->my_body->get_body_ptr())->set_gateway(&my_gateway);
        static_cast<async_body_base_type*>(this->my_init_body->get_body_ptr())->set_gateway(&my_gateway);
 
        tbb::internal::fgt_multioutput_node_with_body<1>( CODEPTR(), tbb::internal::FLOW_ASYNC_NODE,
                &this->my_graph, static_cast<receiver<input_type> *>(this),
                this->output_ports(), this->my_body );
    }

References CODEPTR.

Member Function Documentation

__TBB_STATIC_ASSERT()

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::__TBB_STATIC_ASSERT ( (tbb::internal::is_same_type< Allocator, null_type >::value)  , "Allocator template parameter for flow graph nodes is deprecated and will removed in the future. " "To temporary enable the deprecated interface specify TBB_ENABLE_DEPRECATED_NODE_ALLOCATOR."    )

private

copy_function_object()

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

template<typename Body >

Body tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::copy_function_object ( )

inline

Definition at line 4363 of file flow_graph.h.

                                {
        typedef internal::multifunction_body<input_type, typename base_type::output_ports_type> mfn_body_type;
        typedef internal::async_body<Input, typename base_type::output_ports_type, gateway_type, Body> async_body_type;
        mfn_body_type &body_ref = *this->my_body;
        async_body_type ab = *static_cast<async_body_type*>(dynamic_cast< internal::multifunction_body_leaf<input_type, typename base_type::output_ports_type, async_body_type> & >(body_ref).get_body_ptr());
        return ab.get_body();
    }

References tbb::flow::interface11::internal::async_body< Input, Ports, Gateway, Body >::get_body().

Here is the call graph for this function:

gateway()

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

gateway_type & tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::gateway ( )

inline

Definition at line 4340 of file flow_graph.h.

                            {
        return my_gateway;
    }

register_successor()

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

bool tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::register_successor ( successor_type &  r )

inlinevirtual

Add a new successor to this node.

Implements tbb::flow::interface11::internal::untyped_sender.

Definition at line 4353 of file flow_graph.h.

                                                                {
        return internal::output_port<0>(*this).register_successor(r);
    }

remove_successor()

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

bool tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::remove_successor ( successor_type &  r )

inlinevirtual

Removes a successor from this node.

Implements tbb::flow::interface11::internal::untyped_sender.

Definition at line 4358 of file flow_graph.h.

                                                              {
        return internal::output_port<0>(*this).remove_successor(r);
    }

reset_node()

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

void tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::reset_node ( reset_flags  f )

inlineprotectedvirtual

Reimplemented from tbb::flow::interface11::multifunction_node< Input, Output, Policy, Allocator >.

Definition at line 4398 of file flow_graph.h.

                                                   {
       base_type::reset_node(f);
    }

self()

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

async_node * tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::self ( )

inlineprivate

Definition at line 4270 of file flow_graph.h.

{ return this; }

try_put_impl()

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

bool tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::try_put_impl ( const Output &  i )

inlineprivate

Implements gateway_type::try_put for an external activity to submit a message to FG.

Definition at line 4273 of file flow_graph.h.

                                       {
        internal::multifunction_output<Output> &port_0 = internal::output_port<0>(*this);
        internal::broadcast_cache<output_type>& port_successors = port_0.successors();
        tbb::internal::fgt_async_try_put_begin(this, &port_0);
        task_list tasks;
        bool is_at_least_one_put_successful = port_successors.gather_successful_try_puts(i, tasks);
        __TBB_ASSERT( is_at_least_one_put_successful || tasks.empty(),
                      "Return status is inconsistent with the method operation." );
 
        while( !tasks.empty() ) {
            internal::enqueue_in_graph_arena(this->my_graph, tasks.pop_front());
        }
        tbb::internal::fgt_async_try_put_end(this, &port_0);
        return is_at_least_one_put_successful;
    }

References __TBB_ASSERT, tbb::task_list::empty(), tbb::internal::fgt_async_try_put_begin(), tbb::internal::fgt_async_try_put_end(), tbb::task_list::pop_front(), and internal::function_output< Output >::successors().

Here is the call graph for this function:

Member Data Documentation

my_gateway

template<typename Input , typename Output , typename Policy = queueing_lightweight, typename Allocator = __TBB_DEFAULT_NODE_ALLOCATOR(Input)>

tbb::flow::interface11::async_node::receiver_gateway_impl tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::my_gateway

private

---

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

• flow_graph.h