WireCellTbb Namespace Reference

Classes
class	DataFlowGraph
class	FaninBody
class	FaninWrapper
class	FunctionBody
class	FunctionWrapper
class	JoinBody
class	JoinWrapper
class	MockDepoSink
class	MockDepoSource
class	MockDrifter
class	NodeWrapper
class	QueuedoutBody
class	QueuedoutWrapper
class	SinkBody
class	SinkNodeWrapper
class	SourceBody
class	SourceNodeWrapper
class	TbbFlow
class	WrapperFactory
struct	WrapperMaker
struct	WrapperMakerT

Typedefs
typedef tbb::flow::sender< boost::any >	sender_type
typedef tbb::flow::receiver< boost::any >	receiver_type
typedef std::vector< sender_type * >	sender_port_vector
typedef std::vector< receiver_type * >	receiver_port_vector
typedef std::vector< boost::any >	any_vector
typedef std::tuple< boost::any >	any_single
typedef std::tuple< boost::any, boost::any >	any_double
typedef std::tuple< boost::any, boost::any, boost::any >	any_triple
typedef tbb::flow::source_node< boost::any >	source_node
	Types for TBB nodes. More...
typedef tbb::flow::function_node< boost::any >	sink_node
typedef tbb::flow::function_node< boost::any, boost::any >	function_node
typedef tbb::flow::multifunction_node< boost::any, any_single >	queuedout_node
typedef queuedout_node::output_ports_type	queuedout_port
typedef std::shared_ptr< NodeWrapper >	Node

Functions
template<std::size_t N>
receiver_port_vector	build_faniner (tbb::flow::graph &graph, WireCell::INode::pointer wcnode, tbb::flow::graph_node *&joiner, tbb::flow::graph_node *&caller)
template<std::size_t N>
receiver_port_vector	build_joiner (tbb::flow::graph &graph, WireCell::INode::pointer wcnode, tbb::flow::graph_node *&joiner, tbb::flow::graph_node *&caller)
template<typename Tuple , std::size_t... Is>
receiver_port_vector	receiver_ports (tbb::flow::join_node< Tuple > &jn, std::index_sequence< Is... >)
template<typename Tuple >
receiver_port_vector	receiver_ports (tbb::flow::join_node< Tuple > &jn)
	Return receiver ports of a join node as a vector. More...

Detailed Description

This adapts the queued out node category to a TBB multifunction node.

Facade/adapter to TBB for source node category.

Typedef Documentation

typedef std::tuple<boost::any,boost::any> WireCellTbb::any_double

Definition at line 24 of file NodeWrapper.h.

typedef std::tuple<boost::any> WireCellTbb::any_single

Definition at line 23 of file NodeWrapper.h.

typedef std::tuple<boost::any,boost::any,boost::any> WireCellTbb::any_triple

Definition at line 25 of file NodeWrapper.h.

typedef std::vector<boost::any> WireCellTbb::any_vector

Definition at line 21 of file NodeWrapper.h.

typedef tbb::flow::function_node<boost::any,boost::any> WireCellTbb::function_node

Definition at line 30 of file NodeWrapper.h.

typedef std::shared_ptr<NodeWrapper> WireCellTbb::Node

Definition at line 51 of file NodeWrapper.h.

typedef tbb::flow::multifunction_node<boost::any,any_single> WireCellTbb::queuedout_node

Definition at line 31 of file NodeWrapper.h.

typedef queuedout_node::output_ports_type WireCellTbb::queuedout_port

Definition at line 32 of file NodeWrapper.h.

typedef std::vector<receiver_type*> WireCellTbb::receiver_port_vector

Definition at line 19 of file NodeWrapper.h.

typedef tbb::flow::receiver<boost::any> WireCellTbb::receiver_type

Definition at line 16 of file NodeWrapper.h.

typedef std::vector<sender_type*> WireCellTbb::sender_port_vector

Definition at line 18 of file NodeWrapper.h.

typedef tbb::flow::sender<boost::any> WireCellTbb::sender_type

Definition at line 15 of file NodeWrapper.h.

typedef tbb::flow::function_node<boost::any> WireCellTbb::sink_node

Definition at line 29 of file NodeWrapper.h.

typedef tbb::flow::source_node<boost::any> WireCellTbb::source_node

Types for TBB nodes.

Definition at line 28 of file NodeWrapper.h.

Function Documentation

template<std::size_t N>

receiver_port_vector WireCellTbb::build_faniner	(	tbb::flow::graph &	graph,
		WireCell::INode::pointer	wcnode,
		tbb::flow::graph_node *&	joiner,
		tbb::flow::graph_node *&	caller
	)

Definition at line 37 of file FaninCat.h.

    {
        typedef typename WireCell::type_repeater<N, boost::any>::type TupleType;

        // this node is fully TBB and joins N receiver ports into a tuple
        typedef tbb::flow::join_node< TupleType > tbb_join_node_type;
        tbb_join_node_type* jn = new tbb_join_node_type(graph);
        joiner = jn;

        // this node takes user WC body and runs it after converting input tuple to vector
        typedef tbb::flow::function_node<TupleType,boost::any> joining_node;
        joining_node* fn = new joining_node(graph, wcnode->concurrency(), FaninBody<TupleType>(wcnode));
        caller = fn;

        tbb::flow::make_edge(*jn, *fn);

        //FaninNodeInputPorts<TupleType,N> ports;
        //return ports(*jn);
        return receiver_ports(*jn);
    }

template<std::size_t N>

receiver_port_vector WireCellTbb::build_joiner	(	tbb::flow::graph &	graph,
		WireCell::INode::pointer	wcnode,
		tbb::flow::graph_node *&	joiner,
		tbb::flow::graph_node *&	caller
	)

Definition at line 36 of file JoinCat.h.

    {
        typedef typename WireCell::type_repeater<N, boost::any>::type TupleType;

        // this node is fully TBB and joins N receiver ports into a tuple
        typedef tbb::flow::join_node< TupleType > tbb_join_node_type;
        tbb_join_node_type* jn = new tbb_join_node_type(graph);
        joiner = jn;

        // this node takes user WC body and runs it after converting input tuple to vector
        typedef tbb::flow::function_node<TupleType,boost::any> joining_node;
        joining_node* fn = new joining_node(graph, wcnode->concurrency(), JoinBody<TupleType>(wcnode));
        caller = fn;

        tbb::flow::make_edge(*jn, *fn);

        //JoinNodeInputPorts<TupleType,N> ports;
        //return ports(*jn);
        return receiver_ports(*jn);
    }

template<typename Tuple , std::size_t... Is>

receiver_port_vector WireCellTbb::receiver_ports	(	tbb::flow::join_node< Tuple > &	jn,
		std::index_sequence< Is... >
	)

Definition at line 56 of file NodeWrapper.h.

                                                                                               {
        return { dynamic_cast<receiver_type*>(&tbb::flow::input_port<Is>(jn))... };
    }

template<typename Tuple >

receiver_port_vector WireCellTbb::receiver_ports

(

tbb::flow::join_node< Tuple > &

jn

)

Return receiver ports of a join node as a vector.

Definition at line 61 of file NodeWrapper.h.

                                                                     {
        return receiver_ports(jn, std::make_index_sequence<std::tuple_size<Tuple>::value>{});
    }