An executable node that acts as a source, i.e. it has no predecessors. More...

#include <flow_graph.h>

Inheritance diagram for tbb::flow::interface11::input_node< Output >:

Collaboration diagram for tbb::flow::interface11::input_node< Output >:

Public Types
typedef Output	output_type
	The type of the output message, which is complete. More...

typedef sender< output_type >::successor_type	successor_type
	The type of successors of this node. More...

typedef null_type	input_type

Public Types inherited from tbb::flow::interface11::internal::untyped_sender
typedef untyped_receiver	successor_type
	The successor type for this node. More...

Public Member Functions
template<typename Body >
__TBB_NOINLINE_SYM	input_node (graph &g, Body body)
	Constructor for a node with a successor. More...

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

	~input_node ()
	The destructor. More...

bool	register_successor (successor_type &r) __TBB_override
	Add a new successor to this node. More...

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

bool	try_get (output_type &v) __TBB_override
	Request an item from the node. More...

bool	try_reserve (output_type &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...

void	activate ()
	Activates a node that was created in the inactive state. More...

template<typename Body >
Body	copy_function_object ()

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

virtual	~graph_node ()

Public Member Functions inherited from tbb::flow::interface11::internal::untyped_sender
virtual	~untyped_sender ()

Protected Member Functions
void	reset_node (reset_flags f) __TBB_override
	resets the input_node to its initial state More...

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. More...

template<typename X >
bool	try_reserve (X &t)
	Reserves an item in the sender. More...

Private Member Functions
bool	try_reserve_apply_body (output_type &v)

task *	create_put_task ()

void	spawn_put ()
	Spawns a task that applies the body. More...

task *	apply_body_bypass ()
	Applies the body. Returning SUCCESSFULLY_ENQUEUED okay; forward_task_bypass will handle it. More...

Private Attributes
spin_mutex	my_mutex

bool	my_active

internal::input_body< output_type > *	my_body

internal::input_body< output_type > *	my_init_body

internal::broadcast_cache< output_type >	my_successors

bool	my_reserved

bool	my_has_cached_item

output_type	my_cached_item

Friends
class	internal::source_task_bypass< input_node< output_type > >

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

__TBB_DEPRECATED typedef internal::async_helpers< Output >::filtered_type	filtered_type

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

graph_node *	next

graph_node *	prev

Detailed Description

template<typename Output>
class tbb::flow::interface11::input_node< Output >

An executable node that acts as a source, i.e. it has no predecessors.

Definition at line 904 of file flow_graph.h.

Member Typedef Documentation

◆ input_type

template<typename Output >

typedef null_type tbb::flow::interface11::input_node< Output >::input_type

Definition at line 913 of file flow_graph.h.

◆ output_type

template<typename Output >

typedef Output tbb::flow::interface11::input_node< Output >::output_type

The type of the output message, which is complete.

Definition at line 907 of file flow_graph.h.

◆ successor_type

template<typename Output >

typedef sender<output_type>::successor_type tbb::flow::interface11::input_node< Output >::successor_type

The type of successors of this node.

Definition at line 910 of file flow_graph.h.

Constructor & Destructor Documentation

◆ input_node() [1/2]

template<typename Output >

template<typename Body >

__TBB_NOINLINE_SYM tbb::flow::interface11::input_node< Output >::input_node	(	graph &	g,
		Body	body
	)

inline

Constructor for a node with a successor.

Definition at line 922 of file flow_graph.h.

         : graph_node(g), my_active(false),
         my_body( new internal::input_body_leaf< output_type, Body>(body) ),
         my_init_body( new internal::input_body_leaf< output_type, Body>(body) ),
         my_reserved(false), my_has_cached_item(false)
     {
         my_successors.set_owner(this);
         tbb::internal::fgt_node_with_body( CODEPTR(), tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
                                            static_cast<sender<output_type> *>(this), this->my_body );
     }

◆ input_node() [2/2]

template<typename Output >

__TBB_NOINLINE_SYM tbb::flow::interface11::input_node< Output >::input_node ( const input_node< Output > & src )

inline

Copy constructor.

Definition at line 942 of file flow_graph.h.

                                                            :
         graph_node(src.my_graph), sender<Output>(),
         my_active(false),
         my_body( src.my_init_body->clone() ), my_init_body(src.my_init_body->clone() ),
         my_reserved(false), my_has_cached_item(false)
     {
         my_successors.set_owner(this);
         tbb::internal::fgt_node_with_body(CODEPTR(), tbb::internal::FLOW_SOURCE_NODE, &this->my_graph,
                                            static_cast<sender<output_type> *>(this), this->my_body );
     }

◆ ~input_node()

template<typename Output >

tbb::flow::interface11::input_node< Output >::~input_node ( )

inline

The destructor.

Definition at line 954 of file flow_graph.h.

954 { delete my_body; delete my_init_body; }

tbb::flow::interface11::input_node::my_init_body

internal::input_body< output_type > * my_init_body

Definition: flow_graph.h:1103

tbb::flow::interface11::input_node::my_body

internal::input_body< output_type > * my_body

Definition: flow_graph.h:1102

References tbb::flow::interface11::input_node< Output >::my_body, and tbb::flow::interface11::input_node< Output >::my_init_body.

Member Function Documentation

◆ activate()

template<typename Output >

void tbb::flow::interface11::input_node< Output >::activate ( )

inline

Activates a node that was created in the inactive state.

Definition at line 1061 of file flow_graph.h.

                     {
         spin_mutex::scoped_lock lock(my_mutex);
         my_active = true;
         if (!my_successors.empty())
             spawn_put();
     }

◆ apply_body_bypass()

template<typename Output >

task* tbb::flow::interface11::input_node< Output >::apply_body_bypass ( )

inlineprivate

Applies the body. Returning SUCCESSFULLY_ENQUEUED okay; forward_task_bypass will handle it.

Definition at line 1153 of file flow_graph.h.

                                 {
         output_type v;
         if ( !try_reserve_apply_body(v) )
             return NULL;
 
         task *last_task = my_successors.try_put_task(v);
         if ( last_task )
             try_consume();
         else
             try_release();
         return last_task;
     }

References tbb::flow::interface11::input_node< Output >::my_successors, tbb::flow::interface11::input_node< Output >::try_consume(), tbb::flow::interface11::internal::broadcast_cache< T, M >::try_put_task(), tbb::flow::interface11::input_node< Output >::try_release(), and tbb::flow::interface11::input_node< Output >::try_reserve_apply_body().

Here is the call graph for this function:

◆ copy_function_object()

template<typename Output >

template<typename Body >

Body tbb::flow::interface11::input_node< Output >::copy_function_object ( )

inline

Definition at line 1069 of file flow_graph.h.

                                 {
         internal::input_body<output_type> &body_ref = *this->my_body;
         return dynamic_cast< internal::input_body_leaf<output_type, Body> & >(body_ref).get_body();
     }

◆ create_put_task()

template<typename Output >

task* tbb::flow::interface11::input_node< Output >::create_put_task ( )

inlineprivate

Definition at line 1139 of file flow_graph.h.

                             {
         return ( new ( task::allocate_additional_child_of( *(this->my_graph.root_task()) ) )
                         internal:: source_task_bypass < input_node< output_type > >( *this ) );
     }

References tbb::flow::interface11::graph_node::my_graph, and tbb::flow::interface10::graph::root_task().

Referenced by tbb::flow::interface11::input_node< Output >::spawn_put().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ register_successor()

template<typename Output >

bool tbb::flow::interface11::input_node< Output >::register_successor ( successor_type & r )

inlinevirtual

Add a new successor to this node.

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

Definition at line 963 of file flow_graph.h.

                                                                 {
         spin_mutex::scoped_lock lock(my_mutex);
         my_successors.register_successor(r);
         if ( my_active )
             spawn_put();
         return true;
     }

References lock, and tbb::flow::interface11::input_node< Output >::my_mutex.

◆ remove_successor()

template<typename Output >

bool tbb::flow::interface11::input_node< Output >::remove_successor ( successor_type & r )

inlinevirtual

Removes a successor from this node.

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

Definition at line 972 of file flow_graph.h.

                                                               {
         spin_mutex::scoped_lock lock(my_mutex);
         my_successors.remove_successor(r);
         return true;
     }

◆ reset_node()

template<typename Output >

void tbb::flow::interface11::input_node< Output >::reset_node ( reset_flags f )

inlineprotectedvirtual

resets the input_node to its initial state

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

Definition at line 1086 of file flow_graph.h.

                                                    {
         my_active = false;
         my_reserved = false;
         my_has_cached_item = false;
 
         if(f & rf_clear_edges) my_successors.clear();
         if(f & rf_reset_bodies) {
             internal::input_body<output_type> *tmp = my_init_body->clone();
             delete my_body;
             my_body = tmp;
         }
     }

References tbb::flow::interface11::input_node< Output >::my_active, and tbb::flow::interface11::input_node< Output >::my_reserved.

◆ spawn_put()

template<typename Output >

void tbb::flow::interface11::input_node< Output >::spawn_put ( )

inlineprivate

Spawns a task that applies the body.

Definition at line 1145 of file flow_graph.h.

                       {
         if(internal::is_graph_active(this->my_graph)) {
             internal::spawn_in_graph_arena(this->my_graph, *create_put_task());
         }
     }

References tbb::flow::interface11::input_node< Output >::create_put_task(), tbb::flow::interface11::internal::is_graph_active(), tbb::flow::interface11::graph_node::my_graph, and tbb::flow::interface11::internal::spawn_in_graph_arena().

Referenced by tbb::flow::interface11::input_node< Output >::try_release().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ try_consume()

template<typename Output >

bool tbb::flow::interface11::input_node< Output >::try_consume ( )

inlinevirtual

Consumes a reserved item.

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

Definition at line 1049 of file flow_graph.h.

                                        {
         spin_mutex::scoped_lock lock(my_mutex);
         __TBB_ASSERT( my_reserved && my_has_cached_item, "consuming non-existent reservation" );
         my_reserved = false;
         my_has_cached_item = false;
         if ( !my_successors.empty() ) {
             spawn_put();
         }
         return true;
     }

Referenced by tbb::flow::interface11::input_node< Output >::apply_body_bypass().

Here is the caller graph for this function:

◆ try_get()

template<typename Output >

bool tbb::flow::interface11::input_node< Output >::try_get ( output_type & v )

inlinevirtual

Request an item from the node.

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

Definition at line 1004 of file flow_graph.h.

                                                   {
         spin_mutex::scoped_lock lock(my_mutex);
         if ( my_reserved )
             return false;
 
         if ( my_has_cached_item ) {
             v = my_cached_item;
             my_has_cached_item = false;
             return true;
         }
         // we've been asked to provide an item, but we have none.  enqueue a task to
         // provide one.
         if ( my_active )
             spawn_put();
         return false;
     }

References lock, tbb::flow::interface11::input_node< Output >::my_has_cached_item, tbb::flow::interface11::input_node< Output >::my_mutex, and tbb::flow::interface11::input_node< Output >::my_reserved.

◆ try_release()

template<typename Output >

bool tbb::flow::interface11::input_node< Output >::try_release ( )

inlinevirtual

Release a reserved item.

true = item has been released and so remains in sender, dest must request or reserve future items

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

Definition at line 1039 of file flow_graph.h.

                                        {
         spin_mutex::scoped_lock lock(my_mutex);
         __TBB_ASSERT( my_reserved && my_has_cached_item, "releasing non-existent reservation" );
         my_reserved = false;
         if(!my_successors.empty())
             spawn_put();
         return true;
     }

References __TBB_ASSERT, tbb::flow::interface11::internal::successor_cache< T, M >::empty(), lock, tbb::flow::interface11::input_node< Output >::my_has_cached_item, tbb::flow::interface11::input_node< Output >::my_mutex, tbb::flow::interface11::input_node< Output >::my_reserved, tbb::flow::interface11::input_node< Output >::my_successors, and tbb::flow::interface11::input_node< Output >::spawn_put().

Referenced by tbb::flow::interface11::input_node< Output >::apply_body_bypass().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ try_reserve()

template<typename Output >

bool tbb::flow::interface11::input_node< Output >::try_reserve ( output_type & v )

inlinevirtual

Reserves an item.

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

Definition at line 1022 of file flow_graph.h.

                                                       {
         spin_mutex::scoped_lock lock(my_mutex);
         if ( my_reserved ) {
             return false;
         }
 
         if ( my_has_cached_item ) {
             v = my_cached_item;
             my_reserved = true;
             return true;
         } else {
             return false;
         }
     }

◆ try_reserve_apply_body()

template<typename Output >

bool tbb::flow::interface11::input_node< Output >::try_reserve_apply_body ( output_type & v )

inlineprivate

Definition at line 1110 of file flow_graph.h.

                                                 {
         spin_mutex::scoped_lock lock(my_mutex);
         if ( my_reserved ) {
             return false;
         }
         if ( !my_has_cached_item ) {
             tbb::internal::fgt_begin_body( my_body );
 
 #if TBB_DEPRECATED_INPUT_NODE_BODY
             bool r = (*my_body)(my_cached_item);
             if (r) {
                 my_has_cached_item = true;
             }
 #else
             flow_control control;
             my_cached_item = (*my_body)(control);
             my_has_cached_item = !control.is_pipeline_stopped;
 #endif
             tbb::internal::fgt_end_body( my_body );
         }
         if ( my_has_cached_item ) {
             v = my_cached_item;
             my_reserved = true;
             return true;
         } else {
             return false;
         }
     }