internal Namespace Reference

Namespaces
	graph_policy_namespace

Classes
struct	aligned_pair
struct	alignment_of
class	apply_body_task_bypass
	A task that calls a node's apply_body_bypass function, passing in an input of type Input. More...
class	async_storage
class	broadcast_cache
	A cache of successors that are broadcast to. More...
struct	clear_element
struct	clear_element< 1 >
class	continue_input
	Implements methods for an executable node that takes continue_msg as input. More...
struct	convert_and_call_impl
struct	convert_and_call_impl< A1, Args1... >
struct	convert_and_call_impl<>
struct	count_element
class	decrementer
class	decrementer< T, continue_msg, void >
class	decrementer< T, DecrementType, typename tbb::internal::enable_if< tbb::internal::is_integral< DecrementType >::value, void >::type >
struct	default_constructed
struct	do_if
struct	do_if< T, false >
struct	do_if< T, true >
struct	emit_element
struct	emit_element< 1 >
struct	empty_body
	An empty functor that takes an Input and returns a default constructed Output. More...
struct	ERROR_Type_Not_allowed_In_Tagged_Msg_Not_Member_Of_Tuple
class	forward_task_bypass
	A task that calls a node's forward_task function. More...
struct	forwarding_base
class	function_body
	A functor that takes an Input and generates an Output. More...
class	function_body_leaf
	the leaf for function_body More...
class	function_body_leaf< continue_msg, continue_msg, B >
	the leaf for function_body specialized for Input and output of continue_msg More...
class	function_body_leaf< continue_msg, Output, B >
	the leaf for function_body specialized for Input of continue_msg More...
class	function_body_leaf< Input, continue_msg, B >
	the leaf for function_body specialized for Output of continue_msg More...
class	function_input
	Implements methods for a function node that takes a type Input as input and sends. More...
class	function_input_base
	Input and scheduling for a function node that takes a type Input as input. More...
class	function_input_queue
class	function_output
	Implements methods for both executable and function nodes that puts Output to its successors. More...
struct	has_policy
struct	has_policy< ExpectedPolicy, FirstPolicy, Policies... >
struct	has_policy< ExpectedPolicy, Policy< Policies... > >
struct	has_policy< ExpectedPolicy, SinglePolicy >
struct	indexer_helper
struct	indexer_helper< TupleTypes, 1 >
class	indexer_input_port
class	indexer_node_base
	indexer_node_base More...
class	indexer_node_FE
struct	indexer_types
struct	init_output_ports
class	initializer_list_wrapper
class	input_body
	A functor that takes no input and generates a value of type Output. More...
class	input_body_leaf
	The leaf for input_body. More...
struct	input_types
struct	input_types< 1, InputTuple >
struct	input_types< 10, InputTuple >
struct	input_types< 2, InputTuple >
struct	input_types< 3, InputTuple >
struct	input_types< 4, InputTuple >
struct	input_types< 5, InputTuple >
struct	input_types< 6, InputTuple >
struct	input_types< 7, InputTuple >
struct	input_types< 8, InputTuple >
struct	input_types< 9, InputTuple >
struct	is_element_of
struct	is_element_of< Q, 0, Tuple >
struct	is_port_ref
struct	is_port_ref_impl
struct	is_port_ref_impl< port_ref_impl< N1, N2 > >
struct	is_port_ref_impl< port_ref_impl< N1, N2 >(*)() >
class	item_buffer
struct	join_base
struct	join_base< N, key_matching_port, OutputTuple, key_matching< K, KHash > >
struct	join_helper
struct	join_helper< 1 >
class	join_node_base
	join_node_base More...
class	join_node_FE
	join_node_FE : implements input port policy More...
class	join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >
class	join_node_FE< queueing, InputTuple, OutputTuple >
class	join_node_FE< reserving, InputTuple, OutputTuple >
class	kernel_executor_helper
class	kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >
struct	key_from_policy
struct	key_from_policy< key_matching< Key & > >
struct	key_from_policy< key_matching< Key > >
class	key_matching_port
struct	key_to_count_functor
struct	KeyTrait
struct	make_sequence
struct	make_sequence< 0, S... >
struct	matching_forwarding_base
class	multifunction_body
	function_body that takes an Input and a set of output ports More...
class	multifunction_body_leaf
	leaf for multifunction. OutputSet can be a std::tuple or a vector. More...
class	multifunction_input
	Implements methods for a function node that takes a type Input as input. More...
class	multifunction_output
class	node_cache
	A node_cache maintains a std::queue of elements of type T. Each operation is protected by a lock. More...
struct	num_arguments
struct	num_arguments< port_ref_impl< N1, N2 > >
struct	num_arguments< port_ref_impl< N1, N2 >(*)()>
struct	pick_max
struct	pick_one
struct	pick_one< false, T1, T2 >
struct	pick_one< true, T1, T2 >
struct	pick_tuple_max
struct	pick_tuple_max< 0, Tuple, Selector >
struct	Policy
struct	port_ref_impl
class	predecessor_cache
	A cache of predecessors that only supports try_get. More...
class	queueing_port
	queueing join_port More...
class	reservable_item_buffer
	item_buffer with reservable front-end. NOTE: if reserving, do not More...
class	reservable_predecessor_cache
	An cache of predecessors that supports requests and reservations. More...
class	reserving_port
	The two-phase join port. More...
class	round_robin_cache
	A cache of successors that are put in a round-robin fashion. More...
class	sequence
struct	size_of
class	source_body
class	source_body_leaf
	The leaf for source_body. More...
class	source_task_bypass
	A task that calls a node's apply_body_bypass function with no input. More...
class	streaming_device_with_key
struct	streaming_node_traits
class	successor_cache
	An abstract cache of successors. More...
class	successor_cache< continue_msg, M >
	An abstract cache of successors, specialized to continue_msg. More...
class	tagged_msg
struct	tagged_null_type
struct	type_plus_align
	type mimicking std::pair but with trailing fill to ensure each element of an array More...
struct	type_plus_align< T1, T2, 0 >
class	type_to_key_function_body
class	type_to_key_function_body< Input, Output & >
class	type_to_key_function_body_leaf
class	type_to_key_function_body_leaf< Input, Output &, B >
class	unfolded_indexer_node
class	unfolded_join_node
	unfolded_join_node : passes input_ports_type to join_node_base. We build the input port type More...
class	unfolded_join_node< 2, key_matching_port, OutputTuple, key_matching< K, KHash > >
class	unfolded_join_node< 3, key_matching_port, OutputTuple, key_matching< K, KHash > >
class	unfolded_join_node< 4, key_matching_port, OutputTuple, key_matching< K, KHash > >
class	unfolded_join_node< 5, key_matching_port, OutputTuple, key_matching< K, KHash > >
struct	wrap_key_tuple_elements
struct	wrap_key_tuple_elements< 1, PT, KeyTraits, TypeTuple >
struct	wrap_key_tuple_elements< 2, PT, KeyTraits, TypeTuple >
struct	wrap_key_tuple_elements< 3, PT, KeyTraits, TypeTuple >
struct	wrap_key_tuple_elements< 4, PT, KeyTraits, TypeTuple >
struct	wrap_key_tuple_elements< 5, PT, KeyTraits, TypeTuple >
struct	wrap_tuple_elements
struct	wrap_tuple_elements< 1, PT, TypeTuple >
struct	wrap_tuple_elements< 2, PT, TypeTuple >
struct	wrap_tuple_elements< 3, PT, TypeTuple >
struct	wrap_tuple_elements< 4, PT, TypeTuple >
struct	wrap_tuple_elements< 5, PT, TypeTuple >
struct	Wrapper
struct	Wrapper< T[N]>
struct	WrapperBase

Typedefs
typedef tbb::internal::uint64_t	tag_value

Enumerations
enum	op_stat { WAIT = 0, SUCCEEDED, FAILED }

Functions
template<typename Body >
void	check_input_node_body_input_type_impl (Body)
template<typename Body >
void	check_input_node_body_input_type (Body)
template<typename ReturnType , typename T >
void	check_input_node_body_input_type (ReturnType(*)(T))
template<typename IndexerNodeBaseType , typename T , size_t K>
task *	do_try_put (const T &v, void *p)
template<size_t N, typename JNT >
tbb::flow::tuple_element< N, typename JNT::input_ports_type >::type &	input_port (JNT &jn)
	templated function to refer to input ports of the join node More...
template<size_t N, typename MOP >
tbb::flow::tuple_element< N, typename MOP::output_ports_type >::type &	output_port (MOP &op)
void	check_task_and_spawn (graph &g, task *t)
template<typename CompositeType >
void	add_nodes_impl (CompositeType *, bool)
template<typename CompositeType , typename NodeType1 , typename... NodeTypes>
void	add_nodes_impl (CompositeType *c_node, bool visible, const NodeType1 &n1, const NodeTypes &... n)
template<typename... Args>
void	ignore_return_values (Args &&...)
template<typename T >
T	or_return_values (T &&t)
template<typename T , typename... Rest>
T	or_return_values (T &&t, Rest &&... rest)
template<typename V , typename T >
const V &	cast_to (T const &t)
template<typename V , typename T >
bool	is_a (T const &t)

Typedef Documentation

tag_value

typedef tbb::internal::uint64_t internal::tag_value

Definition at line 30 of file _flow_graph_body_impl.h.

Enumeration Type Documentation

op_stat

enum internal::op_stat

Enumerator
WAIT
SUCCEEDED
FAILED

Definition at line 719 of file _flow_graph_types_impl.h.

{ WAIT = 0, SUCCEEDED, FAILED };

Function Documentation

add_nodes_impl() [1/2]

template<typename CompositeType >

void internal::add_nodes_impl	(	CompositeType *	,
		bool
	)

Definition at line 958 of file _flow_graph_node_impl.h.

{}

Referenced by add_nodes_impl().

Here is the caller graph for this function:

add_nodes_impl() [2/2]

template<typename CompositeType , typename NodeType1 , typename... NodeTypes>

void internal::add_nodes_impl	(	CompositeType *	c_node,
		bool	visible,
		const NodeType1 &	n1,
		const NodeTypes &...	n
	)

Definition at line 961 of file _flow_graph_node_impl.h.

                                                                                                         {
        void *addr = const_cast<NodeType1 *>(&n1);

        fgt_alias_port(c_node, addr, visible);
        add_nodes_impl(c_node, visible, n...);
    }

References add_nodes_impl(), addr, and tbb::internal::fgt_alias_port().

Here is the call graph for this function:

cast_to()

template<typename V , typename T >

const V& internal::cast_to

(

T const &

t

)

Definition at line 714 of file _flow_graph_types_impl.h.

{ return t.template cast_to<V>(); }

check_input_node_body_input_type() [1/2]

template<typename Body >

void internal::check_input_node_body_input_type

(

Body

)

Definition at line 117 of file _flow_graph_body_impl.h.

                                            {
    check_input_node_body_input_type_impl(&Body::operator());
}

References check_input_node_body_input_type_impl().

Referenced by internal::input_body_leaf< Output, Body >::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

check_input_node_body_input_type() [2/2]

template<typename ReturnType , typename T >

void internal::check_input_node_body_input_type

(

ReturnType(*)(T)

)

Definition at line 122 of file _flow_graph_body_impl.h.

                                                        {
    __TBB_STATIC_ASSERT((tbb::internal::is_same_type<T, flow_control&>::value),
        "TBB Warning: input_node body requirements have been changed."
        "To temporarily enforce deprecated API specify TBB_DEPRECATED_INPUT_NODE_BODY.");
}

References __TBB_STATIC_ASSERT.

check_input_node_body_input_type_impl()

template<typename Body >

void internal::check_input_node_body_input_type_impl

(

Body

)

Definition at line 110 of file _flow_graph_body_impl.h.

                                                 {
    __TBB_STATIC_ASSERT((tbb::internal::is_same_type<typename tbb::internal::body_arg_detector<Body>::arg_type, flow_control&>::value),
        "TBB Warning: input_node body requirements have been changed."
        "To temporarily enforce deprecated API specify TBB_DEPRECATED_INPUT_NODE_BODY.");
}

References __TBB_STATIC_ASSERT, and value.

Referenced by check_input_node_body_input_type().

Here is the caller graph for this function:

check_task_and_spawn()

void internal::check_task_and_spawn ( graph &  g, task *  t  )

inline

Definition at line 723 of file _flow_graph_node_impl.h.

                                                        {
        if (t && t != SUCCESSFULLY_ENQUEUED) {
            internal::spawn_in_graph_arena(g, *t);
        }
    }

References tbb::flow::interface11::internal::spawn_in_graph_arena(), and tbb::flow::internal::SUCCESSFULLY_ENQUEUED.

Referenced by internal::emit_element< N >::emit_this(), and internal::emit_element< 1 >::emit_this().

Here is the call graph for this function:

Here is the caller graph for this function:

do_try_put()

template<typename IndexerNodeBaseType , typename T , size_t K>

task* internal::do_try_put	(	const T &	v,
		void *	p
	)

Definition at line 34 of file _flow_graph_indexer_impl.h.

                                          {
        typename IndexerNodeBaseType::output_type o(K, v);
        return reinterpret_cast<IndexerNodeBaseType *>(p)->try_put_task(&o);
    }

References p.

ignore_return_values()

template<typename... Args>

void internal::ignore_return_values

(

Args &&

...

)

Definition at line 63 of file _flow_graph_streaming_node.h.

{}

Referenced by streaming_node< tuple< Ports... >, JP, StreamFactory >::make_edges().

Here is the caller graph for this function:

input_port()

template<size_t N, typename JNT >

tbb::flow::tuple_element<N, typename JNT::input_ports_type>::type& internal::input_port

(

JNT &

jn

)

templated function to refer to input ports of the join node

Definition at line 1996 of file _flow_graph_join_impl.h.

                                                                                            {
        return tbb::flow::get<N>(jn.input_ports());
    }

is_a()

template<typename V , typename T >

bool internal::is_a

(

T const &

t

)

Definition at line 717 of file _flow_graph_types_impl.h.

{ return t.template is_a<V>(); }

or_return_values() [1/2]

template<typename T >

T internal::or_return_values

(

T &&

t

)

Definition at line 66 of file _flow_graph_streaming_node.h.

{ return t; }

Referenced by streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage< Args >::do_try_put(), and or_return_values().

Here is the caller graph for this function:

or_return_values() [2/2]

template<typename T , typename... Rest>

T internal::or_return_values	(	T &&	t,
		Rest &&...	rest
	)

Definition at line 68 of file _flow_graph_streaming_node.h.

                                            {
    return t | or_return_values( std::forward<Rest>(rest)... );
}

References or_return_values().

Here is the call graph for this function:

output_port()

template<size_t N, typename MOP >

tbb::flow::tuple_element<N, typename MOP::output_ports_type>::type& internal::output_port

(

MOP &

op

)

Definition at line 719 of file _flow_graph_node_impl.h.

                                                                                              {
        return tbb::flow::get<N>(op.output_ports());
    }