Ctrl+K

continue_node

continue_node#

[flow_graph.continue_node]

A node that executes a specified body object when triggered.

// Defined in header <oneapi/tbb/flow_graph.h>

namespace oneapi {
namespace tbb {
namespace flow {

    template< typename Output, typename Policy = /*implementation-defined*/ >
    class continue_node : public graph_node, public receiver<continue_msg>, public sender<Output> {
    public:
        template<typename Body>
        continue_node( graph &g, Body body, node_priority_t priority = no_priority );
        template<typename Body>
        continue_node( graph &g, Body body, Policy /*unspecified*/ = Policy(),
                      node_priority_t priority = no_priority );

        template<typename Body>
        continue_node( graph &g, int number_of_predecessors, Body body,
                       node_priority_t priority = no_priority );
        template<typename Body>
        continue_node( graph &g, int number_of_predecessors, Body body,
                       Policy /*unspecified*/ = Policy(), node_priority_t priority = no_priority );

        continue_node( const continue_node &src );
        ~continue_node();

        bool try_put( const input_type &v );
        bool try_get( output_type &v );
    };

} // namespace flow
} // namespace tbb
} // namespace oneapi

Requirements:

  • The type Output must meet the CopyConstructible requirements from [copyconstructible] ISO C++ Standard section.

  • The type Policy can be specified as lightweight policy or defaulted.

  • The type Body must meet the ContinueNodeBody requirements.

A continue_node is a graph_node, receiver<continue_msg>, and sender<Output>.

This node is used for nodes that wait for their predecessors to complete before executing, but no explicit data is passed across the incoming edges.

A continue_node maintains an internal threshold that defines the number of predecessors. This value can be provided at construction. Call of the make_edge function with continue_node as a receiver increases its threshold. Call of the remove_edge function with continue_node as a receiver decreases it.

Each time the number of try_put() calls reaches the defined threshold, node’s body is called and the node starts counting the number of try_put() calls from the beginning.

continue_node has a discarding and broadcast-push properties.

The body object passed to a continue_node is copied. Updates to member variables do not affect the original object used to construct the node. If the state held within a body object must be inspected from outside of the node, the copy_body function can be used to obtain an updated copy.

Member functions#

template<typename Body>
continue_node( graph &g, Body body, node_priority_t priority = no_priority );

Constructs a continue_node that invokes body. The internal threshold is set to 0.

This function specifies node priority.

template<typename Body>
continue_node( graph &g, Body body, Policy /*unspecified*/ = Policy(),
               node_priority_t priority = no_priority );

Constructs a continue_node that invokes body. The internal threshold is set to 0.

This function specifies lightweight policy and node priority.

template<typename Body>
continue_node( graph &g, int number_of_predecessors, Body body,
               node_priority_t priority = no_priority );

Constructs a continue_node that invokes body. The internal threshold is set to number_of_predecessors.

This function specifies node priority.

template<typename Body>
continue_node( graph &g, int number_of_predecessors, Body body,
               Policy /*unspecified*/ = Policy(), node_priority_t priority = no_priority );

Constructs a continue_node that invokes body. The internal threshold is set to number_of_predecessors.

This function specifies lightweight policy and node priority.

template<typename Body>
continue_node( graph &g, int number_of_predecessors, Body body );

Constructs a continue_node that invokes body. The internal threshold is set to number_of_predecessors.

continue_node( const continue_node &src )

Constructs a continue_node that has the same initial state that src had after its construction. It does not copy the current count of try_puts received, or the current known number of predecessors. The continue_node that is constructed has a reference to the same graph object as src, has a copy of the initial body used by src, and only has a non-zero threshold if src is constructed with a non-zero threshold.

The new body object is copy-constructed from a copy of the original body provided to src at its construction.

bool try_put( const Input &v )

Increments the count of try_put() calls received. If the incremented count is equal to the number of known predecessors, performs the body function object execution. It does not wait for the execution of the body to complete.

Returns: true

bool try_get( Output &v )

Returns: false

Deduction Guides#

template <typename Body, typename Policy>
continue_node(graph&, Body, Policy, node_priority_t = no_priority)
    -> continue_node<continue_output_t<std::invoke_result_t<Body, continue_msg>>, Policy>;

template <typename Body, typename Policy>
continue_node(graph&, int, Body, Policy, node_priority_t = no_priority)
    -> continue_node<continue_output_t<std::invoke_result_t<Body, continue_msg>>, Policy>;

template <typename Body>
continue_node(graph&, Body, node_priority_t = no_priority)
    -> continue_node<continue_output_t<std::invoke_result_t<Body, continue_msg>>, /*default-policy*/>;

template <typename Body>
continue_node(graph&, int, Body, node_priority_t = no_priority)
    -> continue_node<continue_output_t<std::invoke_result_t<Body, continue_msg>>, /*default-policy*/>;

Where:

  • continue_output_t<Output> is an alias to Output template argument type. If Output specified as void, continue_output_t<Output> is an alias to continue_msg type.

Example#

A set of continue_nodes forms a Dependency Flow Graph.

Contents