Base class of all nodes. More...

#include <tpie/pipelining/node.h>

Public Types
enum	PLOT { PLOT_SIMPLIFIED_HIDE =1, PLOT_BUFFERED =2, PLOT_PARALLEL =4 }
	Options for how to plot this node. More...

enum	STATE { STATE_FRESH, STATE_IN_PREPARE, STATE_AFTER_PREPARE, STATE_IN_PROPAGATE, STATE_AFTER_PROPAGATE, STATE_IN_BEGIN, STATE_AFTER_BEGIN, STATE_IN_GO, STATE_IN_END, STATE_AFTER_END }
	Used internally to check order of method calls. More...

typedef boost::optional < any_noncopyable & >	maybeany_t

Public Member Functions
virtual	~node ()
	Virtual dtor. More...

memory_size_type	get_minimum_resource_usage (resource_type type) const
	Get the minimum amount of the resource declared by this node. More...

memory_size_type	get_maximum_resource_usage (resource_type type) const
	Get the maximum amount of the resource declared by this node. More...

double	get_resource_fraction (resource_type type) const
	Get the priority for the specific resource of this node. More...

memory_size_type	get_available_of_resource (resource_type type) const
	Get the amount of the specific resource assigned to this node. More...

void	set_minimum_resource_usage (resource_type type, memory_size_type usage)
	Called by implementers to declare minimum resource requirements. More...

void	set_maximum_resource_usage (resource_type type, memory_size_type usage)
	Called by implementers to declare maximum resource requirements. More...

void	set_resource_fraction (resource_type type, double f)
	Set the resource priority of this node. More...

virtual void	resource_available_changed (resource_type, memory_size_type)
	Called by the resource manager to notify the node's available amount of resource has changed. More...

void	_internal_set_available_of_resource (resource_type type, memory_size_type available)
	Used internally to assign the available resource to the node. More...

memory_size_type	get_minimum_memory () const
	Get the minimum amount of memory declared by this node. More...

memory_size_type	get_maximum_memory () const
	Get the maximum amount of memory declared by this node. More...

double	get_memory_fraction () const
	Get the memory priority of this node. More...

memory_size_type	get_available_memory () const
	Get the amount of memory assigned to this node. More...

void	set_minimum_memory (memory_size_type minimumMemory)
	Called by implementers to declare minimum memory requirements. More...

void	set_maximum_memory (memory_size_type maximumMemory)
	Called by implementers to declare maximum memory requirements. More...

void	set_memory_fraction (double f)
	Set the memory priority of this node. More...

virtual void	set_available_memory (memory_size_type availableMemory)
	Called by the memory manager to set the amount of memory assigned to this node. More...

memory_size_type	get_used_memory () const
	Get the amount of memory currently used by this node. More...

bits::node_map::ptr	get_node_map () const
	Get the local node map, mapping node IDs to node pointers for all the nodes reachable from this one. More...

node_token::id_t	get_id () const
	Get the internal node ID of this node (mainly for debugging purposes). More...

virtual void	prepare ()
	Called before memory assignment but after depending phases have executed and ended. More...

virtual void	propagate ()
	Propagate stream metadata. More...

virtual void	begin ()
	Begin pipeline processing phase. More...

virtual bool	is_go_free () const

virtual void	go ()
	For initiator nodes, execute this phase by pushing all items to be pushed. More...

virtual void	end ()
	End pipeline processing phase. More...

virtual bool	can_evacuate ()
	Overridden by nodes that have data to evacuate. More...

virtual void	evacuate ()
	Overridden by nodes that have data to evacuate. More...

priority_type	get_name_priority ()
	Get the priority of this node's name. More...

const std::string &	get_name ()
	Get this node's name. More...

void	set_name (const std::string &name, priority_type priority=PRIORITY_USER)
	Set this node's name. More...

priority_type	get_phase_name_priority ()
	Get the priority of this node's pdane name. More...

const std::string &	get_phase_name ()
	Get this node's phase name. More...

void	set_phase_name (const std::string &name, priority_type priority=PRIORITY_USER)
	Set this node's phase name. More...

void	set_breadcrumb (const std::string &breadcrumb)
	Used internally when a pair_factory has a name set. More...

stream_size_type	get_steps ()
	Used internally for progress indication. More...

stream_size_type	get_steps_left ()

void	set_progress_indicator (progress_indicator_base *pi)
	Used internally. Set the progress indicator to use. More...

progress_indicator_base *	get_progress_indicator ()
	Used internally. Get the progress indicator used. More...

STATE	get_state () const
	Used internally to check order of method calls. More...

void	set_state (STATE s)
	Used internally to check order of method calls. More...

resource_type	get_resource_being_assigned () const
	Used internally to check order of method calls. More...

void	set_resource_being_assigned (resource_type type)
	Used internally to check order of method calls. More...

flags< PLOT >	get_plot_options () const
	Get options specified for plot(), as a combination of `node::PLOT` values. More...

void	set_plot_options (flags< PLOT > options)
	Set options specified for plot(), as a combination of `node::PLOT` values. More...

void	add_push_destination (const node_token &dest)
	Called by implementers to declare a push destination. More...

void	add_push_destination (const node &dest)
	Called by implementers to declare a push destination. More...

void	add_pull_source (const node_token &dest)
	Called by implementers to declare a pull source. More...

void	add_pull_source (const node &dest)
	Called by implementers to declare a pull source. More...

void	add_dependency (const node_token &dest)
	Called by implementers to declare a node dependency, that is, a requirement that another node has end() called before the begin() of this node. More...

void	add_dependency (const node &dest)
	Called by implementers to declare a node dependency, that is, a requirement that another node has end() called before the begin() of this node. More...

void	add_memory_share_dependency (const node_token &dest)
	Called by implementers to declare a node memory share dependency, that is, a requirement that another node has end() called before the begin() of this node, and memory shared between end() and begin() unless evacuate() is called. More...

void	add_memory_share_dependency (const node &dest)
	Called by implementers to declare a node memory share dependency, that is, a requirement that another node has end() called before the begin() of this node, and memory shared between end() and begin() unless evacuate() is called. More...

template<typename T >
void	forward (std::string key, T value, memory_size_type k=std::numeric_limits< memory_size_type >::max())
	Called by implementers to forward auxiliary data to successors. More...

void	forward_any (std::string key, any_noncopyable value, memory_size_type k=std::numeric_limits< memory_size_type >::max())
	See node::forward. More...

bool	can_fetch (std::string key)
	Find out if there is a piece of auxiliary data forwarded with a given name. More...

maybeany_t	fetch_maybe (std::string key)
	Fetch piece of auxiliary data as any_noncopyable (the internal representation) wrapped in a boost::optional which is unitialized if the key is not found. More...

any_noncopyable &	fetch_any (std::string key)
	Fetch piece of auxiliary data as any_noncopyable (the internal representation). More...

template<typename T >
T &	fetch (std::string key)
	Fetch piece of auxiliary data, expecting a given value type. More...

void	no_forward_through ()
	Dissablow forwards through this node. More...

const node_token &	get_token () const
	Get the node_token that maps this node's ID to a pointer to this. More...

void	set_steps (stream_size_type steps)
	Called by implementers that intend to call step(). More...

void	step (stream_size_type steps=1)
	Step the progress indicator. More...

progress_indicator_base *	proxy_progress_indicator ()
	Get a non-initialized progress indicator for use with external implementations. More...

bool	can_pull () const
	For pull nodes, return true if there are more items to be pulled. More...

item_type	pull ()
	For pull nodes, pull the next item from this node. More...

void	push (const item_type &item)
	For push nodes, push the next item to this node. More...

void	register_datastructure_usage (const std::string &name, double priority=1)
	Registers a datastructure. More...

void	set_datastructure_memory_limits (const std::string &name, memory_size_type min, memory_size_type max=std::numeric_limits< memory_size_type >::max())
	Assign memory to a registered datastructure. More...

memory_size_type	get_datastructure_memory (const std::string &name)
	Returns the memory assigned to a datastructure. More...

template<typename T >
void	set_datastructure (const std::string &name, T datastructure)
	Returns a previously declared datastructure. More...

template<typename T >
T &	get_datastructure (const std::string &name)
	Returns a previously declared datastructure. More...

void	unset_datastructure (const std::string &name)

size_t	buckets () const
	Count the number of memory buckets. More...

std::unique_ptr< memory_bucket > &	bucket (size_t i)
	Access a memory bucket. More...

tpie::memory_bucket_ref	allocator (size_t i=0)
	Return an allocator that counts memory usage within the node. More...

Protected Member Functions
	node ()
	Default constructor, using a new node_token. More...

	node (const node &other)=delete
	Copy constructor. More...

node &	operator= (const node &other)=delete

	node (node &&other)
	Move constructor. More...

node &	operator= (node &&other)

	node (const node_token &token)
	Constructor using a given fresh node_token. More...

Friends
class	bits::memory_runtime

class	bits::datastructure_runtime

class	factory_base

class	bits::pipeline_base

class	bits::proxy_progress_indicator

Detailed Description

Base class of all nodes.

A node should inherit from the node class, have a single template parameter dest_t if it is not a terminus node, and implement methods begin(), push() and end(), if it is not a source node.

Definition at line 78 of file node.h.

Member Enumeration Documentation

enum tpie::pipelining::node::PLOT

Options for how to plot this node.

Definition at line 85 of file node.h.

               {
         PLOT_SIMPLIFIED_HIDE=1,
         PLOT_BUFFERED=2,
         PLOT_PARALLEL=4
     };

enum tpie::pipelining::node::STATE

Used internally to check order of method calls.

Definition at line 94 of file node.h.

                {
         STATE_FRESH,
         STATE_IN_PREPARE,
         STATE_AFTER_PREPARE,
         STATE_IN_PROPAGATE,
         STATE_AFTER_PROPAGATE,
         STATE_IN_BEGIN,
         STATE_AFTER_BEGIN,
         STATE_IN_GO,
         STATE_IN_END,
         STATE_AFTER_END
     };

Constructor & Destructor Documentation

virtual tpie::pipelining::node::~node ( )

inlinevirtual

Virtual dtor.

Definition at line 110 of file node.h.

110 {}

tpie::pipelining::node::node ( )

protected

Default constructor, using a new node_token.

tpie::pipelining::node::node ( const node & other )

protecteddelete

Copy constructor.

tpie::pipelining::node::node ( node && other )

protected

Move constructor.

We need to define this explicitly since the node_token needs to know its new owner.

tpie::pipelining::node::node ( const node_token & token )

protected

Constructor using a given fresh node_token.

Member Function Documentation

void tpie::pipelining::node::_internal_set_available_of_resource	(	resource_type	type,
		memory_size_type	available
	)

Used internally to assign the available resource to the node.

void tpie::pipelining::node::add_dependency ( const node_token & dest )

Called by implementers to declare a node dependency, that is, a requirement that another node has end() called before the begin() of this node.

void tpie::pipelining::node::add_dependency ( const node & dest )

Called by implementers to declare a node dependency, that is, a requirement that another node has end() called before the begin() of this node.

void tpie::pipelining::node::add_memory_share_dependency ( const node_token & dest )

Called by implementers to declare a node memory share dependency, that is, a requirement that another node has end() called before the begin() of this node, and memory shared between end() and begin() unless evacuate() is called.

void tpie::pipelining::node::add_memory_share_dependency ( const node & dest )

Called by implementers to declare a node memory share dependency, that is, a requirement that another node has end() called before the begin() of this node, and memory shared between end() and begin() unless evacuate() is called.

void tpie::pipelining::node::add_pull_source ( const node_token & dest )

Called by implementers to declare a pull source.

Referenced by tpie::pipelining::factory_base::add_default_edge().

void tpie::pipelining::node::add_pull_source ( const node & dest )

Called by implementers to declare a pull source.

void tpie::pipelining::node::add_push_destination ( const node_token & dest )

Called by implementers to declare a push destination.

Referenced by tpie::pipelining::factory_base::add_default_edge(), and tpie::pipelining::parallel_bits::after< T >::set_consumer().

void tpie::pipelining::node::add_push_destination ( const node & dest )

Called by implementers to declare a push destination.

tpie::memory_bucket_ref tpie::pipelining::node::allocator ( size_t i = 0 )

inline

Return an allocator that counts memory usage within the node.

Definition at line 788 of file node.h.

References bucket().

                                                 {
         return tpie::memory_bucket_ref(bucket(i).get());
     }

virtual void tpie::pipelining::node::begin ( )

inlinevirtual

Begin pipeline processing phase.

The implementation may pull() from a pull destination in begin(), and it may push() to a push destination.

The pipelining framework calls begin() on the nodes in the actor graph in a reverse topological order. The framework calls node::begin() on a node after calling begin() on its pull and push destinations.

The default implementation does nothing.

Definition at line 299 of file node.h.

Referenced by tpie::pipelining::bits::ostream_logger_t< dest_t >::begin(), tpie::pipelining::bits::virtrecv< Output >::begin(), and tpie::pipelining::parallel_bits::before< push_type< dest_t >::type >::begin().

299 {

300 }

std::unique_ptr<memory_bucket>& tpie::pipelining::node::bucket ( size_t i )

inline

Access a memory bucket.

Definition at line 779 of file node.h.

Referenced by allocator().

                                                     {
         if (m_buckets.size() <= i) m_buckets.resize(i+1);
         if (!m_buckets[i]) m_buckets[i].reset(new memory_bucket());
         return m_buckets[i];
     }

size_t tpie::pipelining::node::buckets ( ) const

inline

Count the number of memory buckets.

Definition at line 774 of file node.h.

774 {return m_buckets.size();}

virtual bool tpie::pipelining::node::can_evacuate ( )

inlinevirtual

Overridden by nodes that have data to evacuate.

Reimplemented in tpie::pipelining::bits::sort_input_t< T, pred_t, store_t >, tpie::pipelining::serialization_bits::sort_input_t< Traits >, tpie::pipelining::bits::sort_calc_t< T, pred_t, store_t >, and tpie::pipelining::serialization_bits::sort_calc_t< Traits >.

Definition at line 335 of file node.h.

                                 {
         return false;
     }

bool tpie::pipelining::node::can_fetch ( std::string key )

inline

Find out if there is a piece of auxiliary data forwarded with a given name.

Definition at line 589 of file node.h.

References fetch_maybe().

Referenced by tpie::pipelining::bits::sort_input_t< T, pred_t, store_t >::propagate().

                                   {
         return bool(fetch_maybe(key));
     }

bool tpie::pipelining::node::can_pull ( ) const

inline

For pull nodes, return true if there are more items to be pulled.

virtual void tpie::pipelining::node::end ( )

inlinevirtual

End pipeline processing phase.

The implementation may pull() from a pull destination in end(), and it may push() to a push destination.

The pipelining framework calls end() on the nodes in the pipeline graph in a topological order. The framework calls node::end() on a node before its pull and push destinations.

The default implementation does nothing, so it does not matter if the implementation calls the parent end().

Definition at line 329 of file node.h.

Referenced by tpie::pipelining::bits::count_consecutive_t< dest_t >::end(), tpie::pipelining::bits::ostream_logger_t< dest_t >::end(), and tpie::pipelining::bits::sort_input_t< T, pred_t, store_t >::end().

329 {

330 }

virtual void tpie::pipelining::node::evacuate ( )

inlinevirtual

Overridden by nodes that have data to evacuate.

Reimplemented in tpie::pipelining::bits::sort_input_t< T, pred_t, store_t >, tpie::pipelining::serialization_bits::sort_input_t< Traits >, tpie::pipelining::bits::sort_calc_t< T, pred_t, store_t >, and tpie::pipelining::serialization_bits::sort_calc_t< Traits >.

Definition at line 342 of file node.h.

342 {

343 }

template<typename T >

T& tpie::pipelining::node::fetch ( std::string key )

inline

Fetch piece of auxiliary data, expecting a given value type.

Definition at line 610 of file node.h.

References fetch_any().

                                     {
         any_noncopyable &item = fetch_any(key);
         try {
             return any_cast<T>(item);
         } catch (bad_any_noncopyable_cast m) {
             std::stringstream ss;
             ss << "Trying to fetch key '" << key << "' of type "
                << typeid(T).name() << " but forwarded data was of type "
                << item.type().name() << ". Message was: " << m.what();
             throw invalid_argument_exception(ss.str());
         }
     }

any_noncopyable& tpie::pipelining::node::fetch_any ( std::string key )

Fetch piece of auxiliary data as any_noncopyable (the internal representation).

Referenced by fetch().

maybeany_t tpie::pipelining::node::fetch_maybe ( std::string key )

Fetch piece of auxiliary data as any_noncopyable (the internal representation) wrapped in a boost::optional which is unitialized if the key is not found.

Referenced by can_fetch().

template<typename T >

void tpie::pipelining::node::forward	(	std::string	key,
		T	value,
		memory_size_type	k = `std::numeric_limits<memory_size_type>::max()`
	)

inline

Called by implementers to forward auxiliary data to successors.

If explicitForward is false, the data will not override data forwarded with explicitForward == true.

Parameters

key	The key of forwarded data
value	The value of forwarded data
k	The maximum distance to forward the distance. If there are more than k nodes between the forwarding nodes and another node b. b will not be able to fetch the data. Defaults to infinity.

Definition at line 564 of file node.h.

References forward_any().

                                                                                                         {
         forward_any(key, any_noncopyable(std::move(value)), k);
     }

void tpie::pipelining::node::forward_any	(	std::string	key,
		any_noncopyable	value,
		memory_size_type	k = `std::numeric_limits< memory_size_type >::max()`
	)

See node::forward.

Referenced by forward(), and tpie::pipelining::bits::Forwarder< dest_t >::prepare().

memory_size_type tpie::pipelining::node::get_available_memory ( ) const

inline

Get the amount of memory assigned to this node.

Definition at line 200 of file node.h.

References get_available_of_resource().

                                                          {
         return get_available_of_resource(MEMORY);
     }

memory_size_type tpie::pipelining::node::get_available_of_resource ( resource_type type ) const

inline

Get the amount of the specific resource assigned to this node.

Definition at line 138 of file node.h.

Referenced by get_available_memory().

                                                                                 {
         return m_parameters.resource_parameters[type].available;
     }

template<typename T >

T& tpie::pipelining::node::get_datastructure ( const std::string & name )

inline

Returns a previously declared datastructure.

Parameters

name	the name of the datastructure

Template Parameters

the	type of the datastructure

Definition at line 738 of file node.h.

References get_node_map().

                                                   {
         bits::node_map::datastructuremap_t & structures = get_node_map()->find_authority()->get_datastructures();
         bits::node_map::datastructuremap_t::iterator i = structures.find(name);
 
         if(i == structures.end())
             throw tpie::exception("attempted to get non-registered datastructure");
 
         return any_cast<T>(i->second.second);
     }

memory_size_type tpie::pipelining::node::get_datastructure_memory ( const std::string & name )

Returns the memory assigned to a datastructure.

Parameters

name	the name of the datastructure

node_token::id_t tpie::pipelining::node::get_id ( ) const

inline

Get the internal node ID of this node (mainly for debugging purposes).

Definition at line 259 of file node.h.

Referenced by tpie::pipelining::factory_base::add_default_edge().

                                          {
         return token.id();
     }

memory_size_type tpie::pipelining::node::get_maximum_memory ( ) const

inline

Get the maximum amount of memory declared by this node.

Defaults to maxint when no maximum has been set.

Definition at line 186 of file node.h.

References get_maximum_resource_usage().

                                                        {
         return get_maximum_resource_usage(MEMORY);
     }

memory_size_type tpie::pipelining::node::get_maximum_resource_usage ( resource_type type ) const

inline

Get the maximum amount of the resource declared by this node.

Defaults to maxint when no maximum has been set.

Definition at line 124 of file node.h.

Referenced by get_maximum_memory().

                                                                                  {
         return m_parameters.resource_parameters[type].maximum;
     }

double tpie::pipelining::node::get_memory_fraction ( ) const

inline

Get the memory priority of this node.

Definition at line 193 of file node.h.

References get_resource_fraction().

                                               {
         return get_resource_fraction(MEMORY);
     }

memory_size_type tpie::pipelining::node::get_minimum_memory ( ) const

inline

Get the minimum amount of memory declared by this node.

Defaults to zero when no minimum has been set.

Definition at line 178 of file node.h.

References get_minimum_resource_usage().

                                                        {
         return get_minimum_resource_usage(MEMORY);
     }

memory_size_type tpie::pipelining::node::get_minimum_resource_usage ( resource_type type ) const

inline

Get the minimum amount of the resource declared by this node.

Defaults to zero when no minimum has been set.

Definition at line 116 of file node.h.

Referenced by get_minimum_memory().

                                                                                  {
         return m_parameters.resource_parameters[type].minimum;
     }

const std::string& tpie::pipelining::node::get_name ( )

Get this node's name.

For purposes of pipeline debugging and phase naming for progress indicator breadcrumbs.

priority_type tpie::pipelining::node::get_name_priority ( )

inline

Get the priority of this node's name.

For purposes of pipeline debugging and phase naming for progress indicator breadcrumbs.

Definition at line 349 of file node.h.

                                              {
         return m_parameters.namePriority;
     }

bits::node_map::ptr tpie::pipelining::node::get_node_map ( ) const

inline

Get the local node map, mapping node IDs to node pointers for all the nodes reachable from this one.

Definition at line 251 of file node.h.

Referenced by tpie::pipelining::factory_base::add_default_edge(), get_datastructure(), tpie::pipelining::virtual_chunk_end< Input >::operator=(), tpie::pipelining::virtual_chunk< Input, Output >::operator=(), tpie::pipelining::virtual_chunk_begin< Output >::operator=(), and set_datastructure().

                                                 {
         return token.get_map();
     }

const std::string& tpie::pipelining::node::get_phase_name ( )

Get this node's phase name.

For purposes of pipeline debugging and phase naming for progress indicator breadcrumbs.

priority_type tpie::pipelining::node::get_phase_name_priority ( )

inline

Get the priority of this node's pdane name.

For purposes of pipeline debugging and phase naming for progress indicator breadcrumbs.

Definition at line 369 of file node.h.

                                                    {
         return m_parameters.phaseNamePriority;
     }

flags<PLOT> tpie::pipelining::node::get_plot_options ( ) const

inline

Get options specified for plot(), as a combination of node::PLOT values.

Definition at line 451 of file node.h.

                                          {
         return m_plotOptions;
     }

progress_indicator_base* tpie::pipelining::node::get_progress_indicator ( )

inline

Used internally. Get the progress indicator used.

Definition at line 415 of file node.h.

                                                        {
         return m_pi;
     }

resource_type tpie::pipelining::node::get_resource_being_assigned ( ) const

inline

Used internally to check order of method calls.

Definition at line 436 of file node.h.

                                                       {
         return m_resourceBeingAssigned;
     }

double tpie::pipelining::node::get_resource_fraction ( resource_type type ) const

inline

Get the priority for the specific resource of this node.

Definition at line 131 of file node.h.

Referenced by get_memory_fraction().

                                                                   {
         return m_parameters.resource_parameters[type].fraction;
     }

STATE tpie::pipelining::node::get_state ( ) const

inline

Used internally to check order of method calls.

Definition at line 422 of file node.h.

Referenced by step().

                             {
         return m_state;
     }

stream_size_type tpie::pipelining::node::get_steps ( )

inline

Used internally for progress indication.

Get the number of times the node expects to call step() at most.

Definition at line 397 of file node.h.

                                         {
         return m_parameters.stepsTotal;
     }

const node_token& tpie::pipelining::node::get_token ( ) const

inline

Get the node_token that maps this node's ID to a pointer to this.

Definition at line 632 of file node.h.

Referenced by tpie::pipelining::factory_base::add_default_edge().

                                          {
         return token;
     }

memory_size_type tpie::pipelining::node::get_used_memory ( ) const

inline

Get the amount of memory currently used by this node.

Definition at line 240 of file node.h.

                                                     {
         memory_size_type ans=0;
         for (const auto & p: m_buckets)
             if (p) ans += p->count;
         return ans;
     }

virtual void tpie::pipelining::node::go ( )

inlinevirtual

For initiator nodes, execute this phase by pushing all items to be pushed.

For non-initiator nodes, the default implementation throws a not_initiator_node exception.

Definition at line 309 of file node.h.

References tpie::log_warning().

                       {
         log_warning() << "node subclass " << typeid(*this).name()
             << " is not an initiator node" << std::endl;
         throw not_initiator_node();
     }

void tpie::pipelining::node::no_forward_through ( )

Dissablow forwards through this node.

virtual void tpie::pipelining::node::prepare ( )

inlinevirtual

Called before memory assignment but after depending phases have executed and ended.

The implementer may use fetch and forward in this phase. The implementer does not have to call the super prepare-method; its default implementation is empty.

Reimplemented in tpie::pipelining::bits::preparer_t< F >::type< dest_t >, tpie::pipelining::join< T >::source_impl< dest_t >, tpie::pipelining::split< T >::source_impl< dest_t >, and tpie::pipelining::bits::Forwarder< dest_t >.

Definition at line 269 of file node.h.

269 {

270 }

virtual void tpie::pipelining::node::propagate ( )

inlinevirtual

Propagate stream metadata.

The implementation may fetch() and forward() metadata such as number of items or the size of a single item.

The pipelining framework calls propagate() on the nodes in the item flow graph in a topological order.

The default implementation does nothing.

Definition at line 283 of file node.h.

283 {

284 }

progress_indicator_base* tpie::pipelining::node::proxy_progress_indicator ( )

Get a non-initialized progress indicator for use with external implementations.

When step() is called on a proxying progress indicator, step() is called on the node according to the number of steps declared in progress_indicator_base::init() and in node::set_steps().

Referenced by tpie::pipelining::serialization_bits::sort_calc_t< Traits >::go(), and tpie::pipelining::bits::sort_calc_t< T, pred_t, store_t >::go().

item_type tpie::pipelining::node::pull ( )

inline

For pull nodes, pull the next item from this node.

void tpie::pipelining::node::push ( const item_type & item )

inline

For push nodes, push the next item to this node.

void tpie::pipelining::node::register_datastructure_usage	(	const std::string &	name,
		double	priority = `1`
	)

Registers a datastructure.

Parameters

name	the name of the datastructure
priority	the priority that should be given to this datastructure when assigning memory

virtual void tpie::pipelining::node::resource_available_changed	(	resource_type	,
		memory_size_type
	)

inlinevirtual

Called by the resource manager to notify the node's available amount of resource has changed.

Reimplemented in tpie::pipelining::bits::sort_input_t< T, pred_t, store_t >, tpie::pipelining::bits::sort_calc_t< T, pred_t, store_t >, tpie::pipelining::bits::sort_output_base< T, pred_t, store_t >, and tpie::pipelining::bits::sort_output_base< push_type< dest_t >::type, pred_t, store_t >.

Definition at line 166 of file node.h.

166 {

167 }

virtual void tpie::pipelining::node::set_available_memory ( memory_size_type availableMemory )

inlinevirtual

Called by the memory manager to set the amount of memory assigned to this node.

Reimplemented in tpie::pipelining::serialization_bits::sort_input_t< Traits >, tpie::pipelining::serialization_bits::sort_calc_t< Traits >, and tpie::pipelining::serialization_bits::sort_output_base< Traits >.

Definition at line 233 of file node.h.

References tpie::unused().

                                                                         {
         unused(availableMemory);
     }

void tpie::pipelining::node::set_breadcrumb ( const std::string & breadcrumb )

inline

Used internally when a pair_factory has a name set.

Definition at line 389 of file node.h.

Referenced by tpie::pipelining::factory_base::init_node(), and tpie::pipelining::factory_base::init_sub_node().

                                                              {
         m_parameters.name = m_parameters.name.empty() ? breadcrumb : (breadcrumb + " | " + m_parameters.name);
     }

template<typename T >

void tpie::pipelining::node::set_datastructure	(	const std::string &	name,
		T	datastructure
	)

inline

Returns a previously declared datastructure.

Parameters

name	the name of the datastructure
datastructure	the datastructure itself

Definition at line 722 of file node.h.

References get_node_map().

                                                                     {
         bits::node_map::datastructuremap_t & structures = get_node_map()->find_authority()->get_datastructures();
         bits::node_map::datastructuremap_t::iterator i = structures.find(name);
 
         if(i == structures.end())
             throw tpie::exception("attempted to set non-registered datastructure");
 
         i->second.second = move_if_movable<T>(datastructure);
     }

void tpie::pipelining::node::set_datastructure_memory_limits	(	const std::string &	name,
		memory_size_type	min,
		memory_size_type	max = `std::numeric_limits< memory_size_type >::max()`
	)

Assign memory to a registered datastructure.

Parameters

name	the name of the datastructure
min	the minimum amount of memory required by the datastructure
max	the maximum amount of memory used by the datastructure

void tpie::pipelining::node::set_maximum_memory ( memory_size_type maximumMemory )

inline

Called by implementers to declare maximum memory requirements.

To signal that you don't want any memory, set minimum memory and the memory fraction to zero.

Definition at line 217 of file node.h.

References set_maximum_resource_usage().

Referenced by tpie::pipelining::bits::sort_output_base< push_type< dest_t >::type, pred_t, store_t >::propagate(), and tpie::pipelining::serialization_bits::sort_output_base< Traits >::propagate().

                                                             {
         set_maximum_resource_usage(MEMORY, maximumMemory);
     }

void tpie::pipelining::node::set_maximum_resource_usage	(	resource_type	type,
		memory_size_type	usage
	)

Called by implementers to declare maximum resource requirements.

To signal that you don't want to use this resource, set minimum resource usage and the resource fraction to zero.

Referenced by set_maximum_memory().

void tpie::pipelining::node::set_memory_fraction ( double f )

inline

Set the memory priority of this node.

Memory is distributed proportionally to the priorities of the nodes in the given phase.

Definition at line 225 of file node.h.

References set_resource_fraction().

Referenced by tpie::pipelining::bits::sort_output_base< push_type< dest_t >::type, pred_t, store_t >::propagate(), and tpie::pipelining::serialization_bits::sort_output_base< Traits >::propagate().

                                        {
         set_resource_fraction(MEMORY, f);
     }

void tpie::pipelining::node::set_minimum_memory ( memory_size_type minimumMemory )

inline

Called by implementers to declare minimum memory requirements.

Definition at line 207 of file node.h.

References set_minimum_resource_usage().

Referenced by tpie::pipelining::bits::sort_output_base< push_type< dest_t >::type, pred_t, store_t >::propagate(), and tpie::pipelining::serialization_bits::sort_output_base< Traits >::propagate().

                                                             {
         set_minimum_resource_usage(MEMORY, minimumMemory);
     }

void tpie::pipelining::node::set_minimum_resource_usage	(	resource_type	type,
		memory_size_type	usage
	)

Called by implementers to declare minimum resource requirements.

Referenced by set_minimum_memory().

void tpie::pipelining::node::set_name	(	const std::string &	name,
		priority_type	priority = `PRIORITY_USER`
	)

Set this node's name.

For purposes of pipeline debugging and phase naming for progress indicator breadcrumbs.

Referenced by tpie::pipelining::factory_base::init_node().

void tpie::pipelining::node::set_phase_name	(	const std::string &	name,
		priority_type	priority = `PRIORITY_USER`
	)

Set this node's phase name.

For purposes of pipeline debugging and phase naming for progress indicator breadcrumbs.

Referenced by tpie::pipelining::factory_base::init_node().

void tpie::pipelining::node::set_plot_options ( flags< PLOT > options )

inline

Set options specified for plot(), as a combination of node::PLOT values.

Definition at line 459 of file node.h.

                                                {
         m_plotOptions = options;
     }

void tpie::pipelining::node::set_progress_indicator ( progress_indicator_base * pi )

inline

Used internally. Set the progress indicator to use.

Definition at line 408 of file node.h.

                                                                      {
         m_pi = pi;
     }

void tpie::pipelining::node::set_resource_being_assigned ( resource_type type )

inline

Used internally to check order of method calls.

Definition at line 443 of file node.h.

                                                          {
         m_resourceBeingAssigned = type;
     }

void tpie::pipelining::node::set_resource_fraction	(	resource_type	type,
		double	f
	)

Set the resource priority of this node.

Resources are distributed proportionally to the priorities of the nodes in the given phase.

Referenced by set_memory_fraction().

void tpie::pipelining::node::set_state ( STATE s )

inline

Used internally to check order of method calls.

Definition at line 429 of file node.h.

                             {
         m_state = s;
     }

void tpie::pipelining::node::set_steps ( stream_size_type steps )

Called by implementers that intend to call step().

Parameters

steps The number of times step() is called at most.

void tpie::pipelining::node::step ( stream_size_type steps = 1 )

inline

Step the progress indicator.

Parameters

steps How many steps to step.

Definition at line 654 of file node.h.

References get_state(), and tpie::progress_indicator_base::step().

                                           {
         assert(get_state() == STATE_IN_END ||
                get_state() == STATE_IN_BEGIN ||
                get_state() == STATE_AFTER_BEGIN ||
                get_state() == STATE_IN_END ||
                get_state() == STATE_IN_GO);
         if (m_stepsLeft < steps)
             step_overflow();
         else
             m_stepsLeft -= steps;
         m_pi->step(steps);
     }

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

pipelining/node.h

TPIE

Public Types

Public Member Functions

Protected Member Functions

Friends

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation