Virtual chunk that has input and output. More...

#include <tpie/pipelining/virtual.h>

Inherits tpie::pipelining::bits::virtual_chunk_base.

Public Member Functions
	virtual_chunk ()
	Constructor that leaves the virtual chunk unassigned. More...

template<typename fact_t >
	virtual_chunk (pipe_middle< fact_t > &&pipe, virtual_container *ctr=0)
	Constructor that recursively constructs a node and takes ownership of it. More...

template<typename Mid >
	virtual_chunk (const virtual_chunk< Input, Mid > &left, const virtual_chunk< Mid, Output > &right)
	Constructor that combines two virtual chunks. More...

	virtual_chunk (const virtual_chunk_end< Input > &left, const virtual_chunk_begin< Output > &right)

template<typename fact_t >
virtual_chunk &	operator= (pipe_middle< fact_t > &&pipe)
	Construct a node and assign it to this virtual chunk. More...

template<typename NextOutput >
virtual_chunk< Input, NextOutput >	operator\| (virtual_chunk< Output, NextOutput > dest)
	Connect this virtual chunk to another chunk. More...

virtual_chunk_end< Input >	operator\| (virtual_chunk_end< Output > dest)
	Connect this virtual chunk to another chunk. More...

virt_node::ptr	get_node () const

void	set_container (virtual_container *ctr)

bool	empty () const

void	operator() (stream_size_type items, progress_indicator_base &pi, memory_size_type filesAvailable, memory_size_type mem, const char file, const char function)
	Invoke the pipeline. More...

void	operator() (stream_size_type items, progress_indicator_base &pi, memory_size_type mem, const char file, const char function)
	Invoke the pipeline with amount of available files automatically configured. More...

double	memory () const

void	order_before (pipeline_base &other)

void	plot (std::ostream &out)
	Generate a GraphViz plot of the pipeline. More...

void	plot_full (std::ostream &out)
	Generate a GraphViz plot of the actor graph. More...

void	forward_any (std::string key, any_noncopyable value)

bool	can_fetch (std::string key)

any_noncopyable &	fetch_any (std::string key)

node_map::ptr	get_node_map () const

void	output_memory (std::ostream &o) const

size_t	uid () const

Protected Attributes
virt_node::ptr	m_node

double	m_memory

node_map::ptr	m_nodeMap

size_t	m_uid

Friends
class	bits::access

Detailed Description

template<typename Input, typename Output>
class tpie::pipelining::virtual_chunk< Input, Output >

Virtual chunk that has input and output.

Definition at line 283 of file virtual.h.

Constructor & Destructor Documentation

template<typename Input, typename Output>

tpie::pipelining::virtual_chunk< Input, Output >::virtual_chunk ( )

inline

Constructor that leaves the virtual chunk unassigned.

Definition at line 391 of file virtual.h.

         : m_src(0)
         , m_recv(0)
     {}

template<typename Input, typename Output>

template<typename fact_t >

tpie::pipelining::virtual_chunk< Input, Output >::virtual_chunk	(	pipe_middle< fact_t > &&	pipe,
		virtual_container *	ctr = `0`
	)

inline

Constructor that recursively constructs a node and takes ownership of it.

Definition at line 401 of file virtual.h.

                                                                             {
         *this = std::forward<pipe_middle<fact_t>>(pipe);
         set_container(ctr);
     }

template<typename Input, typename Output>

template<typename Mid >

tpie::pipelining::virtual_chunk< Input, Output >::virtual_chunk	(	const virtual_chunk< Input, Mid > &	left,
		const virtual_chunk< Mid, Output > &	right
	)

inline

Constructor that combines two virtual chunks.

Assumes that the virtual nodes are already connected. You should not use this constructor directly; instead, use the pipe operator.

Definition at line 412 of file virtual.h.

         : virtual_chunk_base(left.get_node_map(), bits::virt_node::combine(left.get_node(), right.get_node()))
     {
         m_src = acc::get_source(left);
         m_recv = acc::get_destination(right);
     }

Member Function Documentation

void tpie::pipelining::bits::pipeline_base::operator()	(	stream_size_type	items,
		progress_indicator_base &	pi,
		memory_size_type	filesAvailable,
		memory_size_type	mem,
		const char *	file,
		const char *	function
	)

inherited

Invoke the pipeline.

Referenced by tpie::pipelining::bits::pipeline_base::operator()().

void tpie::pipelining::bits::pipeline_base::operator()	(	stream_size_type	items,
		progress_indicator_base &	pi,
		memory_size_type	mem,
		const char *	file,
		const char *	function
	)

inlineinherited

Invoke the pipeline with amount of available files automatically configured.

Definition at line 123 of file pipeline.h.

References tpie::get_file_manager(), and tpie::pipelining::bits::pipeline_base::operator()().

                                                               {
         operator()(items, pi, get_file_manager().available(), mem, file, function);
     }

template<typename Input, typename Output>

template<typename fact_t >

virtual_chunk& tpie::pipelining::virtual_chunk< Input, Output >::operator= ( pipe_middle< fact_t > && pipe )

inline

Construct a node and assign it to this virtual chunk.

Definition at line 433 of file virtual.h.

References tpie::pipelining::node::get_node_map(), tpie::log_error(), and tpie::pipelining::bits::virt_node::take_own().

                                                            {
         if (this->m_node) {
             log_error() << "Virtual chunk assigned twice" << std::endl;
             throw tpie::exception("Virtual chunk assigned twice");
         }
         typedef typename fact_t::template constructed<recv_type>::type constructed_type;
         recv_type temp(m_recv);
         this->m_nodeMap = temp.get_node_map();
         fact_t f = std::move(pipe.factory);
         f.set_destination_kind_push();
         m_src = new bits::virtsrc_impl<constructed_type, Input>(f.construct(std::move(temp)));
         this->m_node = bits::virt_node::take_own(m_src);
 
         return *this;
     }

template<typename Input, typename Output>

template<typename NextOutput >

virtual_chunk<Input, NextOutput> tpie::pipelining::virtual_chunk< Input, Output >::operator| ( virtual_chunk< Output, NextOutput > dest )

inline

Connect this virtual chunk to another chunk.

Definition at line 453 of file virtual.h.

                                                                                        {
         if (empty()) {
             return *bits::assert_types_equal_and_return<Input, Output, virtual_chunk<Input, NextOutput> *>
                 ::go(&dest);
         }
         bits::virtsrc<Output> * dst=acc::get_source(dest);
         if (dest.empty() || !dst) {
             return *bits::assert_types_equal_and_return<Output, NextOutput, virtual_chunk<Input, NextOutput> *>
                 ::go(this);
         }
         m_recv->set_destination(dst);
         return virtual_chunk<Input, NextOutput>(*this, dest);
     }

template<typename Input, typename Output>

virtual_chunk_end<Input> tpie::pipelining::virtual_chunk< Input, Output >::operator| ( virtual_chunk_end< Output > dest )

inline

Connect this virtual chunk to another chunk.

Definition at line 470 of file virtual.h.

                                                                        {
         if (empty()) {
             return *bits::assert_types_equal_and_return<Input, Output, virtual_chunk_end<Input> *>
                 ::go(&dest);
         }
         m_recv->set_destination(acc::get_source(dest));
         return virtual_chunk_end<Input>(*this, dest);
     }

void tpie::pipelining::bits::pipeline_base_base::plot ( std::ostream & out )

inlineinherited

Generate a GraphViz plot of the pipeline.

When rendered with dot, GraphViz will place the nodes in the topological order of the item flow graph with items flowing from the top downwards.

Thus, a downwards arrow in the plot is a push edge, and an upwards arrow is a pull edge (assuming no cycles in the item flow graph).

Compared to plot_full, sorts, buffers and reversers will be represented as one node in the graph as apposed to 3 or 2. Nodes added by virtual wrapping will not be showed at all

Definition at line 65 of file pipeline.h.

65 {plot_impl(out, false);}

void tpie::pipelining::bits::pipeline_base_base::plot_full ( std::ostream & out )

inlineinherited

Generate a GraphViz plot of the actor graph.

When rendered with dot, GraphViz will place the nodes in the topological order of the item flow graph with items flowing from the top downwards.

Thus, a downwards arrow in the plot is a push edge, and an upwards arrow is a pull edge (assuming no cycles in the item flow graph).

Definition at line 77 of file pipeline.h.

77 {plot_impl(out, true);}

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

pipelining/virtual.h

TPIE

Public Member Functions

Protected Attributes

Friends

Detailed Description

template<typename Input, typename Output> class tpie::pipelining::virtual_chunk< Input, Output >

Constructor & Destructor Documentation

Member Function Documentation

template<typename Input, typename Output>
class tpie::pipelining::virtual_chunk< Input, Output >