Base class for dynamically (fully or semifully) built graphs. More...

#include <DynParaLoop.hxx>

Inheritance diagram for YACS::ENGINE::DynParaLoop:

Collaboration diagram for YACS::ENGINE::DynParaLoop:

Public Member Functions
Node *	edRemoveNode ()

Node *	edRemoveInitNode ()

Node *	edRemoveFinalizeNode ()

Node *	edSetNode (Node *DISOWNnode)

Node *	edSetInitNode (Node *DISOWNnode)

Node *	edSetFinalizeNode (Node *DISOWNnode)

virtual bool	edAddDFLink (OutPort start, InPort end) throw (Exception)
	Connect an OutPort to an InPort and add control link if necessary. More...

void	init (bool start=true)

InputPort *	edGetNbOfBranchesPort ()

int	getNumberOfInputPorts () const

int	getNumberOfOutputPorts () const

unsigned	getNumberOfEltsConsumed () const

int	getBranchIDOfNode (Node *node) const

std::list< OutputPort * >	getSetOfOutputPort () const

std::list< OutputPort * >	getLocalOutputPorts () const
	redefined on derived class of ComposedNode. by default a ComposedNode has no port by itself More...

OutputPort *	edGetSamplePort ()

OutPort *	getOutPort (const std::string &name) const throw (Exception)

InputPort *	getInputPort (const std::string &name) const throw (Exception)
	Get an input port given its name. More...

OutputPort *	getOutputPort (const std::string &name) const throw (Exception)
	Get an output port given its name. More...

bool	isPlacementPredictableB4Run () const
	For the moment false is returned : impovement about it coming soon. More...

void	edRemoveChild (Node *node) throw (Exception)
	Remove a child node. More...

virtual bool	edAddChild (Node *DISOWNnode) throw (Exception)

std::list< Node * >	edGetDirectDescendants () const

std::list< InputPort * >	getSetOfInputPort () const

std::list< InputPort * >	getLocalInputPorts () const
	redefined on derived class of ComposedNode. by default a ComposedNode has no port by itself More...

unsigned	getNumberOfBranchesCreatedDyn () const throw (Exception)

Node *	getChildByShortName (const std::string &name) const throw (Exception)

Node *	getChildByNameExec (const std::string &name, unsigned id) const throw (Exception)

std::vector< Node * >	getNodes () const

bool	isMultiplicitySpecified (unsigned &value) const

void	forceMultiplicity (unsigned value)

virtual void	checkBasicConsistency () const throw (Exception)

virtual std::string	getErrorReport ()
	returns a string that contains an error report if the node is in error More...

void	accept (Visitor *visitor)

Node *	getInitNode ()

Node *	getExecNode ()

Node *	getFinalizeNode ()

int	getMaxLevelOfParallelism () const

Public Member Functions inherited from YACS::ENGINE::ComposedNode
virtual	~ComposedNode ()

bool	isFinished ()

virtual void	resetState (int level)
	Reset the state of the node and its children depending on the parameter level. More...

std::string	getName () const

std::string	getTaskName (Task *task) const

DeploymentTree	getDeploymentTree () const
	Essentially for test. Use checkDeploymentTree instead to be sure that returned DeploymentTree is consistent. More...

DeploymentTree	checkDeploymentTree (bool deep) const throw (Exception)
	Perform check of deployment consistency of the current graph. More...

std::vector< Task * >	getNextTasks (bool &isMore)

void	notifyFrom (const Task sender, YACS::Event event, const Executor execInst)
	Notify the node a task has emitted an event. More...

bool	edAddLink (OutPort start, InPort end) throw (Exception)
	Add a dataflow link between two data ports. More...

bool	edAddLink (OutGate start, InGate end) throw (Exception)
	Add a controlflow link between two control ports. More...

bool	edAddCFLink (Node nodeS, Node nodeE) throw (Exception)
	Add a controlflow link between two nodes. More...

void	edRemoveCFLink (Node nodeS, Node nodeE) throw (Exception)
	Remove a controlflow link. More...

void	edRemoveLink (OutPort start, InPort end) throw (Exception)
	Remove a dataflow link. More...

void	edRemoveLink (OutGate start, InGate end) throw (Exception)
	Remove a controlflow link. More...

virtual bool	isRepeatedUnpredictablySeveralTimes () const

virtual void	removeRecursivelyRedundantCL ()

std::list< ElementaryNode * >	getRecursiveConstituents () const

std::list< Node * >	getAllRecursiveNodes ()
	Get all children nodes elementary and composed including this node. More...

virtual std::list< Node * >	getAllRecursiveConstituents ()
	Idem getAllRecursiveNodes, but this node is NOT included. More...

std::list< ProgressWeight >	getProgressWeight () const
	Get the progress weight for all elementary nodes. More...

std::string	getInPortName (const InPort *) const throw (Exception)
	Get the input port name. More...

std::string	getOutPortName (const OutPort *) const throw (Exception)

std::set< OutPort * >	getAllOutPortsLeavingCurrentScope () const
	List all output ports of children nodes that are linked to out of scope input ports. More...

std::set< InPort * >	getAllInPortsComingFromOutsideOfCurrentScope () const
	List all input ports that are linked to out of scope ports. More...

std::list< InputDataStreamPort * >	getSetOfInputDataStreamPort () const

std::list< OutputDataStreamPort * >	getSetOfOutputDataStreamPort () const

InputDataStreamPort *	getInputDataStreamPort (const std::string &name) const throw (Exception)

OutputDataStreamPort *	getOutputDataStreamPort (const std::string &name) const throw (Exception)

std::vector< std::pair < OutPort , InPort > >	getSetOfInternalLinks () const

virtual std::vector< std::pair < OutPort , InPort > >	getSetOfLinksLeavingCurrentScope () const

void	checkConsistency (LinkInfo &info) const throw (Exception)

virtual std::vector< std::pair < InPort , OutPort > >	getSetOfLinksComingInCurrentScope () const

virtual std::string	typeName ()

virtual void	edUpdateState ()
	update the status of the node More...

ComposedNode *	getRootNode () const throw (Exception)

bool	isNodeAlreadyAggregated (const Node *node) const
	Check that Node 'node' is already a direct son of this. More...

virtual bool	isNameAlreadyUsed (const std::string &name) const

Node *	isInMyDescendance (Node *nodeToTest) const
	Returns the parent of a node that is the direct child of this node. More...

std::string	getChildName (const Node *node) const throw (Exception)

virtual std::string	getMyQualifiedName (const Node *directSon) const

Node *	getChildByName (const std::string &name) const throw (Exception)

void	loaded ()

void	connected ()

virtual void	cleanNodes ()
	Clean the composed node in case of not clean exit. More...

virtual std::string	getProgress () const

Public Member Functions inherited from YACS::ENGINE::Node
virtual	~Node ()

Node *	clone (ComposedNode *father, bool editionOnly=true) const
	This method MUST NEVER BE VIRTUAL More...

Node *	cloneWithoutCompAndContDeepCpy (ComposedNode *father, bool editionOnly=true) const
	This method MUST NEVER BE VIRTUAL More...

void	setState (YACS::StatesForNode theState)
	Sets the given state for node. More...

virtual YACS::StatesForNode	getState () const

virtual YACS::StatesForNode	getEffectiveState () const
	Return the node state in the context of its father. More...

virtual YACS::StatesForNode	getEffectiveState (const Node *) const
	Return the effective state of a node in the context of this one (its father) More...

std::string	getColorState (YACS::StatesForNode state) const
	Return the color associated to a state. More...

InGate *	getInGate ()

OutGate *	getOutGate ()

const std::string &	getName () const

void	setName (const std::string &name)
	Change the name of the node. More...

ComposedNode *	getFather () const

const std::string	getId () const

bool	exIsControlReady () const

std::list< Node * >	getOutNodes () const

virtual void	writeDot (std::ostream &os) const
	Dump to the input stream a dot representation of the node. More...

virtual void	exUpdateState ()
	Update the node state. More...

virtual void	exFailedState ()
	Notify this node that its execution has failed. More...

virtual void	exDisabledState ()
	Notify this node that it has been disabled. More...

virtual void	getReadyTasks (std::vector< Task * > &tasks)=0

std::list< InPort * >	getSetOfInPort () const

std::list< OutPort * >	getSetOfOutPort () const

virtual std::set< InputPort * >	edGetSetOfUnitializedInputPort () const
	Becomes deprecated soon. Replaced by ComposedNode::CheckConsistency. More...

virtual bool	edAreAllInputPortInitialized () const
	Becomes deprecated soon. Replaced by ComposedNode::CheckConsistency. More...

InPort *	getInPort (const std::string &name) const throw (Exception)

InPropertyPort *	getInPropertyPort () const throw (Exception)

std::list< ComposedNode * >	getAllAscendanceOf (ComposedNode *levelToStop=0) const

bool	operator> (const Node &other) const

bool	operator< (const Node &other) const

std::string	getImplementation () const

virtual void	setProperty (const std::string &name, const std::string &value)

virtual std::string	getProperty (const std::string &name)

std::map< std::string, std::string >	getProperties ()

std::map< std::string, std::string >	getPropertyMap ()

virtual void	setProperties (std::map< std::string, std::string > properties)

virtual Proc *	getProc ()

virtual const Proc *	getProc () const

std::string	getQualifiedName () const
	same as Node::getName() in most cases, but differs for children of switch More...

int	getNumId ()
	return node instance identifiant, unique for each node instance More...

std::vector< std::pair < std::string, int > >	getDPLScopeInfo (ComposedNode *gfn)

virtual void	applyDPLScope (ComposedNode *gfn)

virtual void	sendEvent (const std::string &event)
	emit notification to all observers registered with the dispatcher More...

virtual void	sendEvent2 (const std::string &event, void *something)
	emit notification to all observers registered with the dispatcher More...

virtual std::string	getErrorDetails () const

virtual void	setErrorDetails (const std::string &error)

virtual void	modified ()
	Sets Node in modified state and its father if it exists. More...

virtual int	isModified ()

virtual int	isValid ()
	indicates if the node is valid (returns 1) or not (returns 0) More...

virtual std::string	getContainerLog ()
	returns a string that contains the name of the container log file if it exists More...

virtual void	ensureLoading ()
	Put this node into TOLOAD state when possible. More...

virtual void	getCoupledNodes (std::set< Task * > &coupledNodes)

Public Member Functions inherited from YACS::ENGINE::Scheduler
virtual void	exUpdateState ()=0

virtual void	selectRunnableTasks (std::vector< Task * > &tasks)=0

virtual	~Scheduler ()

Protected Types
enum	TypeOfNode { INIT_NODE = 5, WORK_NODE = 6, FINALIZE_NODE = 7 }

Protected Member Functions
	DynParaLoop (const std::string &name, TypeCode *typeOfDataSplitted)

virtual	~DynParaLoop ()

	DynParaLoop (const DynParaLoop &other, ComposedNode *father, bool editionOnly)

void	buildDelegateOf (InPort &port, OutPort initialStart, const std::list< ComposedNode * > &pointsOfView)

void	buildDelegateOf (std::pair< OutPort , OutPort > &port, InPort finalTarget, const std::list< ComposedNode > &pointsOfView)

void	checkCFLinks (const std::list< OutPort * > &starts, InputPort *end, unsigned char &alreadyFed, bool direction, LinkInfo &info) const
	check control flow links More...

void	checkControlDependancy (OutPort start, InPort end, bool cross, std::map< ComposedNode , std::list< OutPort >, SortHierarc > &fw, std::vector< OutPort * > &fwCross, std::map< ComposedNode , std::list< OutPort >, SortHierarc > &bw, LinkInfo &info) const

virtual void	checkLinkPossibility (OutPort start, const std::list< ComposedNode > &pointsOfViewStart, InPort end, const std::list< ComposedNode > &pointsOfViewEnd) throw (Exception)

void	cleanDynGraph ()

void	prepareInputsFromOutOfScope (int branchNb)

void	putValueOnBranch (Any *val, unsigned branchId, bool first)

TypeOfNode	getIdentityOfNotifyerNode (const Node *node, unsigned &id)

InputPort *	getDynInputPortByAbsName (int branchNb, const std::string &name, bool initNodeAdmitted)

virtual void	forwardExecStateToOriginalBody (Node *execNode)

virtual YACS::Event	updateStateOnFailedEventFrom (Node node, const Executor execInst)
	Method used to notify the node that a child node has failed. More...

std::vector< Node * >	cloneAndPlaceNodesCoherently (const std::vector< Node * > &origNodes)
	Clone nodes and make their placement consistent with the placement of the original ones. More...

Node *	checkConsistencyAndSetNode (Node &nodeToReplace, Node DISOWNnode)
	This method is used to factorize methods edSetNode, edSetInitNode and edSetFinalizeNode. More...

Node *	removeNode (Node *&nodeToRemove)
	This method is used to factorize methods edRemoveNode, edRemoveInitNode and edRemoveFinalizeNode. More...

virtual void	shutdown (int level)
	Stop all pending activities of the composed node. More...

Protected Member Functions inherited from YACS::ENGINE::ComposedNode
	ComposedNode (const std::string &name)

	ComposedNode (const ComposedNode &other, ComposedNode *father)

void	performDuplicationOfPlacement (const Node &other)
	performs a duplication of placement using clone method of containers and components. clone behaviour is driven by attachOnCloning attribute. More...

void	performShallowDuplicationOfPlacement (const Node &other)
	performs a also duplication of placement but here containers and components are not copied at all whatever the value of attachedOnCloning. More...

void	edDisconnectAllLinksWithMe ()

YACS::Event	updateStateFrom (Node node, YACS::Event event, const Executor execInst)
	Update node state on receiving event from a node. More...

virtual YACS::Event	updateStateOnStartEventFrom (Node *node)
	Method used to notify the node that a child node has started. More...

virtual YACS::Event	updateStateOnFinishedEventFrom (Node *node)=0

virtual void	getDelegateOf (InPort &port, OutPort initialStart, const std::list< ComposedNode * > &pointsOfView) throw (Exception)

virtual void	getDelegateOf (std::pair< OutPort , OutPort > &port, InPort finalTarget, const std::list< ComposedNode > &pointsOfView) throw (Exception)

virtual void	releaseDelegateOf (InPort &port, OutPort initialStart, const std::list< ComposedNode * > &pointsOfView) throw (Exception)

virtual void	releaseDelegateOf (OutPort portDwn, OutPort portUp, InPort finalTarget, const std::list< ComposedNode > &pointsOfView) throw (Exception)

virtual void	checkNoCyclePassingThrough (Node *node)=0 throw (Exception)

void	checkInMyDescendance (Node *nodeToTest) const throw (Exception)
	Check if a node is in the descendance of this node. More...

template<class PORT >
std::string	getPortName (const PORT *port) const throw (Exception)

void	checkNoCrossHierachyWith (Node *node) const throw (Exception)

virtual void	performCFComputations (LinkInfo &info) const
	perform recursively all CF computations. More...

virtual void	destructCFComputations (LinkInfo &info) const
	destroy recursively all results of initial computations. More...

Node *	getLowestNodeDealingAll (const std::list< OutPort * > &ports) const

void	checkLinksCoherenceRegardingControl (const std::vector< OutPort * > &starts, InputPort *end, LinkInfo &info) const throw (Exception)

void	solveObviousOrDelegateCFLinks (const std::list< OutPort * > &starts, InputPort *end, unsigned char &alreadyFed, bool direction, LinkInfo &info) const

Protected Member Functions inherited from YACS::ENGINE::Node
	Node (const std::string &name)

	Node (const Node &other, ComposedNode *father)

virtual Node *	simpleClone (ComposedNode *father, bool editionOnly=true) const =0

virtual void	exForwardFailed ()

virtual void	exForwardFinished ()

Protected Attributes
Node *	_node

Node *	_initNode

Node *	_finalizeNode

unsigned	_nbOfEltConsumed

std::vector< int >	_execIds

AnyInputPort	_nbOfBranches

AnyOutputPort	_splittedPort

std::vector< Node * >	_execNodes

std::vector< Node * >	_execInitNodes

std::vector< Node * >	_execFinalizeNodes

int	_initializingCounter

int	_unfinishedCounter

int	_failedCounter

Static Protected Attributes
static const char	NAME_OF_SPLITTED_SEQ_OUT [] = "evalSamples"

static const char	OLD_NAME_OF_SPLITTED_SEQ_OUT [] = "SmplPrt"

static const char	NAME_OF_NUMBER_OF_BRANCHES [] ="nbBranches"

Static Protected Attributes inherited from YACS::ENGINE::ComposedNode
static const char	SEP_CHAR_BTW_LEVEL [] ="."

static const unsigned char	FED_ST = 2

static const unsigned char	FREE_ST = 0

static const unsigned char	FED_DS_ST = 1

Static Protected Attributes inherited from YACS::ENGINE::Node
static const char	SEP_CHAR_IN_PORT [] ="."

static int	_total = 0

Additional Inherited Members
Static Public Member Functions inherited from YACS::ENGINE::ComposedNode
static ComposedNode *	getLowestCommonAncestor (Node node1, Node node2) throw (Exception)
	Retrieves the lowest common ancestor of 2 nodes. More...

static std::string	getLowestCommonAncestorStr (const std::string &node1, const std::string &node2)

Public Attributes inherited from YACS::ENGINE::Node
YACS::Colour	_colour

Static Public Attributes inherited from YACS::ENGINE::Node
static std::map< int, Node * >	idMap

Static Protected Member Functions inherited from YACS::ENGINE::ComposedNode
static bool	splitNamesBySep (const std::string &globalName, const char separator[], std::string &firstPart, std::string &lastPart, bool priority) throw (Exception)
	Splits name globalName in 2 parts using separator. More...

Detailed Description

Base class for dynamically (fully or semifully) built graphs.

Definition at line 37 of file DynParaLoop.hxx.

Member Enumeration Documentation

enum YACS::ENGINE::DynParaLoop::TypeOfNode

protected

Enumerator
INIT_NODE
WORK_NODE
FINALIZE_NODE

Definition at line 40 of file DynParaLoop.hxx.

         {
           INIT_NODE = 5,
           WORK_NODE = 6,
           FINALIZE_NODE = 7
       } TypeOfNode;

Constructor & Destructor Documentation

DynParaLoop::DynParaLoop	(	const std::string &	name,
		TypeCode *	typeOfDataSplitted
	)

protected

Definition at line 44 of file DynParaLoop.cxx.

   : ComposedNode(name),_node(0),_initNode(0),_finalizeNode(0),_nbOfEltConsumed(0),
     _nbOfBranches(NAME_OF_NUMBER_OF_BRANCHES,this,Runtime::_tc_int),
     _splittedPort(NAME_OF_SPLITTED_SEQ_OUT,this,typeOfDataSplitted),_initializingCounter(0),_unfinishedCounter(0),_failedCounter(0)
 {
 }

DynParaLoop::~DynParaLoop ( )

protectedvirtual

Definition at line 51 of file DynParaLoop.cxx.

References _finalizeNode, _initNode, and _node.

 {
   delete _node;
   delete _initNode;
   delete _finalizeNode;
 }

DynParaLoop::DynParaLoop	(	const DynParaLoop &	other,
		ComposedNode *	father,
		bool	editionOnly
	)

protected

Definition at line 58 of file DynParaLoop.cxx.

References _finalizeNode, _initNode, _node, _splittedPort, YACS::ENGINE::Node::clone(), YACS::ENGINE::ComposedNode::edAddLink(), YACS::ENGINE::OutputPort::edSetInPort(), YACS::ENGINE::Node::getInPort(), and YACS::ENGINE::ComposedNode::getPortName().

   : ComposedNode(other,father), _nbOfBranches(other._nbOfBranches,this),
     _splittedPort(other._splittedPort,this), _node(0), _initNode(0), _finalizeNode(0),
     _nbOfEltConsumed(0),_initializingCounter(0),_unfinishedCounter(0),_failedCounter(0)
 {
   if(other._node)
     _node=other._node->clone(this,editionOnly);
   if(other._initNode)
     _initNode=other._initNode->clone(this,editionOnly);
   if(other._finalizeNode)
     _finalizeNode = other._finalizeNode->clone(this,editionOnly);
   const AnyOutputPort& startOfLinksToReproduce=other._splittedPort;
   set<InPort *> endsOfLinksToReproduce=startOfLinksToReproduce.edSetInPort();
   for(set<InPort *>::iterator iter=endsOfLinksToReproduce.begin();iter!=endsOfLinksToReproduce.end();iter++)
     edAddLink(&_splittedPort,getInPort(other.getPortName(*iter)));
 }

Member Function Documentation

void DynParaLoop::accept ( Visitor * visitor )

virtual

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 874 of file DynParaLoop.cxx.

References YACS::ENGINE::Visitor::visitDynParaLoop().

 {
   visitor->visitDynParaLoop(this);
 }

void DynParaLoop::buildDelegateOf	(	InPort *&	port,
		OutPort *	initialStart,
		const std::list< ComposedNode * > &	pointsOfView
	)

protectedvirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::OptimizerLoop.

Definition at line 443 of file DynParaLoop.cxx.

References YACS::ENGINE::DataPort::getNameOfTypeOfCurrentInstance(), and YACS::ENGINE::InputPort::NAME.

Referenced by YACS::ENGINE::OptimizerLoop::buildDelegateOf(), and YACS::ENGINE::ForEachLoop::buildDelegateOf().

 {
   string typeOfPortInstance=port->getNameOfTypeOfCurrentInstance();
   if(typeOfPortInstance!=InputPort::NAME)
     throw Exception("DynParaLoop::buildDelegateOf : A link with datastream end inside DynParaLoop is not possible");
 }

void DynParaLoop::buildDelegateOf	(	std::pair< OutPort , OutPort > &	port,
		InPort *	finalTarget,
		const std::list< ComposedNode * > &	pointsOfView
	)

protectedvirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 450 of file DynParaLoop.cxx.

References _finalizeNode, _initNode, _splittedPort, YACS::ENGINE::DataPort::getName(), and YACS::ENGINE::ComposedNode::isInMyDescendance().

 {
   std::string linkName("(");
   linkName += port.first->getName()+" to "+finalTarget->getName()+")";
   if(_initNode)
     if(isInMyDescendance(port.first->getNode())==_initNode)
       throw Exception(std::string("Illegal link within a parallel loop: \
 a link starting from the init node can't leave the scope of the loop.")
                     + linkName);
 
   if(_finalizeNode)
     if(isInMyDescendance(port.first->getNode())==_finalizeNode)
       throw Exception(std::string("Illegal link within a parallel loop: \
 an output port of the finalize node can't be linked.")
                     + linkName);
 
   if(port.first==&_splittedPort)
     throw Exception(std::string("Illegal link within a parallel loop: \
 the 'evalSamples' port must be linked within the scope of the loop.")
                     + linkName);
 }

void DynParaLoop::checkBasicConsistency ( ) const throw (Exception)

virtual

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::OptimizerLoop.

Definition at line 567 of file DynParaLoop.cxx.

References _node, YACS::ENGINE::ComposedNode::checkBasicConsistency(), and DEBTRACE.

Referenced by YACS::ENGINE::OptimizerLoop::checkBasicConsistency().

 {
   DEBTRACE("DynParaLoop::checkBasicConsistency");
   ComposedNode::checkBasicConsistency();
   if(!_node)
     throw Exception("For a dynamic loop, internal node is mandatory");
 }

void DynParaLoop::checkCFLinks	(	const std::list< OutPort * > &	starts,
		InputPort *	end,
		unsigned char &	alreadyFed,
		bool	direction,
		LinkInfo &	info
	)		const

protectedvirtual

check control flow links

Parameters

starts	If different of 0, must aggregate at leat 1 element.
end	:
alreadyFed	in/out parameter. Indicates if 'end' ports is already and surely set or fed by an another port.
direction	If true : forward direction else backward direction.
info	: informations collectedduring the check

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::OptimizerLoop.

Definition at line 472 of file DynParaLoop.cxx.

References YACS::ENGINE::ComposedNode::FED_ST, YACS::ENGINE::ComposedNode::FREE_ST, YACS::ENGINE::Port::getNode(), YACS::ENGINE::I_USELESS, YACS::ENGINE::ComposedNode::isInMyDescendance(), YACS::ENGINE::LinkInfo::pushInfoLink(), and YACS::ENGINE::ComposedNode::solveObviousOrDelegateCFLinks().

Referenced by YACS::ENGINE::OptimizerLoop::checkCFLinks().

 {
   const char what[]="DynParaLoop::checkCFLinks : internal error.";
   //First dealing checkCFLinks forwarding...
   if(isInMyDescendance(end->getNode())==0)//no chance that _splittedPort is in starts due to buildDelegate.
     solveObviousOrDelegateCFLinks(starts,end,alreadyFed,direction,info);
   else
     {//no forwarding here.
       if(starts.size()!=1)
         throw Exception(what);
       //ASSERT(direction) : see DynParaLoop::checkControlDependancy only 'fw' filled.
       if(alreadyFed==FREE_ST)
         alreadyFed=FED_ST;
       else if(alreadyFed==FED_ST)
         {//Shame ! splittedPort fills a port already fed...
           info.pushInfoLink(*(starts.begin()),end,I_USELESS);
         }
     }
 }

Node * DynParaLoop::checkConsistencyAndSetNode	(	Node *&	nodeToReplace,
		Node *	DISOWNnode
	)

protected

This method is used to factorize methods edSetNode, edSetInitNode and edSetFinalizeNode.

Definition at line 81 of file DynParaLoop.cxx.

References YACS::ENGINE::Node::_father, _finalizeNode, _initNode, YACS::ENGINE::Node::_name, _node, YACS::ENGINE::ComposedNode::checkNoCrossHierachyWith(), YACS::ENGINE::ComposedNode::edRemoveChild(), YACS::ENGINE::Node::getName(), YACS::ENGINE::Node::modified(), and PMMLBasicsTestLauncher::ret.

Referenced by edSetFinalizeNode(), edSetInitNode(), and edSetNode().

 {
   if (node == NULL || nodeToReplace == node)
     return 0;
   if (node->_father)
     throw Exception(string("Can't set node: node ") + node->getName() + " is not orphan.");
   if (_node && _node != nodeToReplace && _node->getName() == node->getName())
     throw Exception(string("Can't set node: node ") + node->getName() +
                     " has the same name than exec node already in " + _name + ".");
   if (_initNode && _initNode != nodeToReplace && _initNode->getName() == node->getName())
     throw Exception(string("Can't set node: node ") + node->getName() +
                     " has the same name than init node already in " + _name + ".");
   if (_finalizeNode && _finalizeNode != nodeToReplace && _finalizeNode->getName() == node->getName())
     throw Exception(string("Can't set node: node ") + node->getName() +
                     " has the same name than finalize node already in " + _name + ".");
   checkNoCrossHierachyWith(node);
   ComposedNode::edRemoveChild(nodeToReplace);
   Node * ret = nodeToReplace;
   nodeToReplace = node;
   nodeToReplace->_father = this;
   // set _modified flag so that edUpdateState can refresh state
   modified();
   return ret;
 }

void DynParaLoop::checkControlDependancy	(	OutPort *	start,
		InPort *	end,
		bool	cross,
		std::map< ComposedNode , std::list< OutPort >, SortHierarc > &	fw,
		std::vector< OutPort * > &	fwCross,
		std::map< ComposedNode , std::list< OutPort >, SortHierarc > &	bw,
		LinkInfo &	info
	)		const

protectedvirtual

Parameters

start	: start port
end	: end port
cross	indicates if start -> end link is a DS link behind.
fw	out parameter.
fwCross	out parameter storing links where a cross has been detected.
bw	out parameter where backward links are stored.
info	: collected information

Implements YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::OptimizerLoop.

Definition at line 501 of file DynParaLoop.cxx.

Referenced by YACS::ENGINE::OptimizerLoop::checkControlDependancy().

 {
     fw[(ComposedNode *)this].push_back(start);
 }

void DynParaLoop::checkLinkPossibility	(	OutPort *	start,
		const std::list< ComposedNode * > &	pointsOfViewStart,
		InPort *	end,
		const std::list< ComposedNode * > &	pointsOfViewEnd
	)		throw (Exception)

protectedvirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 510 of file DynParaLoop.cxx.

References YACS::ENGINE::ComposedNode::checkLinkPossibility().

Referenced by YACS::ENGINE::OptimizerLoop::checkLinkPossibility(), and YACS::ENGINE::ForEachLoop::checkLinkPossibility().

 {
   ComposedNode::checkLinkPossibility(start, pointsOfViewStart, end, pointsOfViewEnd);
   Node * startNode = isInMyDescendance(start->getNode());
   Node * endNode = isInMyDescendance(end->getNode());
   std::string linkName("(");
   linkName += start->getName()+" to "+end->getName()+")";
   
   if(start == &_splittedPort && endNode != _node)
     throw Exception(std::string("Illegal link within a parallel loop: \
 the 'evalSamples' port can only be connected to the working node of the loop.")
                     + linkName);
   
   if(_finalizeNode && _finalizeNode == startNode)
     throw Exception(std::string("Illegal link within a parallel loop: \
 the finalize node can't be the origin of a link.")
                     + linkName);
   
   if(_initNode && _node == startNode && _initNode == endNode)
     throw Exception(std::string("Illegal link within a parallel loop: \
 can't make a link from the working node to the init node.")
                     + linkName);
   
   if(_finalizeNode && _node == startNode && _finalizeNode == endNode)
     throw Exception(std::string("Illegal link within a parallel loop: \
 can't make a link from the working node to the finalize node.")
                     + linkName);
 }

void DynParaLoop::cleanDynGraph ( )

protected

Definition at line 330 of file DynParaLoop.cxx.

References _execFinalizeNodes, _execInitNodes, and _execNodes.

Referenced by YACS::ENGINE::ForEachLoop::cleanDynGraph(), YACS::ENGINE::OptimizerLoop::init(), and YACS::ENGINE::OptimizerLoop::~OptimizerLoop().

 {
   vector<Node *>::iterator iter;
   for(iter=_execNodes.begin() ; iter!=_execNodes.end() ; iter++)
     delete *iter;
   _execNodes.clear();
   for(iter=_execInitNodes.begin() ; iter!=_execInitNodes.end() ; iter++)
     delete *iter;
   _execInitNodes.clear();
   for(iter=_execFinalizeNodes.begin() ; iter!=_execFinalizeNodes.end() ; iter++)
     delete *iter;
   _execFinalizeNodes.clear();
 }

vector< Node * > DynParaLoop::cloneAndPlaceNodesCoherently ( const std::vector< Node * > & origNodes )

protected

Clone nodes and make their placement consistent with the placement of the original ones.

For instance, if two original nodes are placed on a component comp1 in a container cont1 and a third one is placed on a component comp2 in the container cont1, the clones of the two first nodes will be placed on a component comp3 in a container cont2 and the third clone will be placed on a component comp4 in the container cont2.

Definition at line 729 of file DynParaLoop.cxx.

References _finalizeNode, _initNode, _node, YACS::ENGINE::DeploymentTree::appendTask(), YACS::ENGINE::Container::clone(), YACS::ENGINE::ComponentInstance::clone(), DEBTRACE, YACS::ENGINE::RefCounter::decrRef(), YACS::ENGINE::ComposedNode::edAddLink(), YACS::ENGINE::DeploymentTree::getAllContainers(), YACS::ENGINE::ComposedNode::getChildByName(), YACS::ENGINE::DeploymentTree::getComponentsLinkedToContainer(), YACS::ENGINE::Node::getInPort(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::ComposedNode::getName(), YACS::ENGINE::Container::getName(), YACS::ENGINE::Node::getName(), YACS::ENGINE::Port::getNode(), getOutPort(), YACS::ENGINE::Node::getSetOfLinksLeavingCurrentScope(), YACS::ENGINE::DeploymentTree::getTasksLinkedToComponent(), YACS::ENGINE::DeploymentTree::getTasksLinkedToContainer(), CORBAEngineTest::i, YACS::ENGINE::ComposedNode::isInMyDescendance(), YACS::ENGINE::ServiceNode::setComponent(), YACS::ENGINE::ComponentInstance::setContainer(), YACS::ENGINE::InlineNode::setContainer(), YACS::ENGINE::Node::simpleClone(), and YASSERT.

Referenced by YACS::ENGINE::OptimizerLoop::exUpdateState(), and YACS::ENGINE::ForEachLoop::exUpdateState().

 {
   DEBTRACE("Begin cloneAndPlaceNodesCoherently")
   vector<Node *> clones;
   DeploymentTree treeToDup;
   vector<list<ElementaryNode *> > origElemNodeList;
   for (int i=0 ; i<origNodes.size() ; i++)
     {
       DEBTRACE("Cloning node " << i)
       if (origNodes[i] == NULL)
         {
           DEBTRACE("Cloning node " << i << ", NULL" )
           clones.push_back(NULL);
           origElemNodeList.push_back(list<ElementaryNode *>());
         }
       else
         {
           DEBTRACE("Cloning node " << i << "," << origNodes[i]->getName())
           clones.push_back(origNodes[i]->simpleClone(this, false));
           list<ElementaryNode *> tasks = origNodes[i]->getRecursiveConstituents();
           origElemNodeList.push_back(tasks);
           for (list< ElementaryNode *>::iterator iter=tasks.begin() ; iter!=tasks.end() ; iter++)
             treeToDup.appendTask(*iter, (*iter)->getDynClonerIfExists(this));
         }
     }
   
   // Build the links between clones.
   // Only the links starting from initNode are possible.
   if(_initNode)
   {
     std::vector< std::pair<OutPort *, InPort *> > outLinks = _initNode->getSetOfLinksLeavingCurrentScope();
     std::vector< std::pair<OutPort *, InPort *> >::const_iterator it;
     for(it=outLinks.begin(); it!=outLinks.end(); it++)
     {
       OutPort *startPort = it->first;
       InPort *endPort = it->second;
       Node* destNode = isInMyDescendance(endPort->getNode());
       if(destNode == _node)
         edAddLink(clones[0]->getOutPort(startPort->getName()),
                   clones[1]->getInPort(endPort->getName()));
       if(destNode == _finalizeNode)
         edAddLink(clones[0]->getOutPort(startPort->getName()),
                   clones[2]->getInPort(endPort->getName()));
     }
   }
 
   DEBTRACE("Placing nodes...")
   vector<Container *> conts=treeToDup.getAllContainers();
 
   //iterate on all containers
   for(vector<Container *>::iterator iterCt=conts.begin();iterCt!=conts.end();iterCt++)
     {
       DEBTRACE("Container " << ((*iterCt)?(*iterCt)->getName():"NULL"))
       vector<ComponentInstance *> comps=treeToDup.getComponentsLinkedToContainer(*iterCt);
       Container *contCloned=0;
       if((*iterCt))
         contCloned=(*iterCt)->clone();
 
       //iterate on all component instances linked to the container
       for(vector<ComponentInstance *>::iterator iterCp=comps.begin();iterCp!=comps.end();iterCp++)
         {
           DEBTRACE("Component " << (*iterCp)->getCompoName())
           vector<Task *> tasks=treeToDup.getTasksLinkedToComponent(*iterCp);
           ComponentInstance *curCloned=(*iterCp)->clone();
           DEBTRACE("Assign container " << (*iterCp)->getCompoName())
           curCloned->setContainer(contCloned);
           for(vector<Task *>::iterator iterT=tasks.begin();iterT!=tasks.end();iterT++)
             {
               DEBTRACE("Task " << ((ElementaryNode *)(*iterT))->getName())
               int i = 0;
               ElementaryNode * origElemNode = NULL;
               for (i=0 ; i<origNodes.size() ; i++)
                 if (origNodes[i] != NULL)
                   {
                     DEBTRACE("Looking in original node " << i)
                     list<ElementaryNode *>::iterator res=find(origElemNodeList[i].begin(),
                                                               origElemNodeList[i].end(),
                                                               (ElementaryNode *)(*iterT));
                     if (res != origElemNodeList[i].end()) {
                       origElemNode = *res;
                       break;
                     }
                   }
 
               YASSERT(origElemNode != NULL)
               DEBTRACE("Found task in node " << i)
               ServiceNode * nodeC = NULL;
               if (origNodes[i] == origElemNode)
                 nodeC = (ServiceNode *)clones[i];
               else
                 {
                   string childName = ((ComposedNode *)origNodes[i])->getChildName(origElemNode);
                   nodeC = (ServiceNode *)clones[i]->getChildByName(childName);
                 }
               DEBTRACE("Assign component: " << (*iterCp)->getCompoName() << "," << nodeC->getName())
               nodeC->setComponent(curCloned);
             }
           curCloned->decrRef();
         }
 
       // iterate on all tasks linked to the container
       vector<Task *> tasks=treeToDup.getTasksLinkedToContainer(*iterCt);
       for(vector<Task *>::iterator iterT=tasks.begin();iterT!=tasks.end();iterT++)
         {
           DEBTRACE("Task " << ((ElementaryNode *)(*iterT))->getName())
           int i = 0;
           ElementaryNode * origElemNode = NULL;
           for (i=0 ; i<origNodes.size() ; i++)
             if (origNodes[i] != NULL)
               {
                 DEBTRACE("Looking in original node " << i)
                 list<ElementaryNode *>::iterator res=find(origElemNodeList[i].begin(),
                                                           origElemNodeList[i].end(),
                                                           (ElementaryNode *)(*iterT));
                 if (res != origElemNodeList[i].end()) 
                   {
                     origElemNode = *res;
                     break;
                   }
               }
           YASSERT(origElemNode != NULL)
           DEBTRACE("Found task in node " << i)
           InlineFuncNode * nodeC = NULL;
           if (origNodes[i] == origElemNode)
             {
               nodeC = (InlineFuncNode *)clones[i];
             }
           else
             {
               string childName = ((ComposedNode *)origNodes[i])->getChildName(origElemNode);
               nodeC = (InlineFuncNode *)clones[i]->getChildByName(childName);
             }
           DEBTRACE("Assign container " << nodeC->getName() << "," << contCloned->getName())
           nodeC->setContainer(contCloned);
         }
 
       // ended with current container
       if(contCloned)
         contCloned->decrRef();
     }
 
   DEBTRACE("End cloneAndPlaceNodesCoherently")
   return clones;
 }

bool DynParaLoop::edAddChild ( Node * DISOWNnode ) throw (Exception)

virtual

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 258 of file DynParaLoop.cxx.

 {
   return edSetNode(DISOWNnode);
 }

bool DynParaLoop::edAddDFLink	(	OutPort *	start,
		InPort *	end
	)		throw (Exception)

virtual

Connect an OutPort to an InPort and add control link if necessary.

Connect the ports with a data link (edAddLink) In a Loop don't add control flow link : use this only to add data back links

Parameters

start	: the OutPort to connect
end	: the InPort to connect

Returns: true if a new link has been created, false otherwise.

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 142 of file DynParaLoop.cxx.

 {
   return edAddLink(start,end);
 }

std::list< Node * > DynParaLoop::edGetDirectDescendants ( ) const

virtual

Implements YACS::ENGINE::ComposedNode.

Definition at line 263 of file DynParaLoop.cxx.

References _finalizeNode, _initNode, _node, and PMMLBasicsTestLauncher::ret.

Referenced by getErrorReport(), and YACS::ENGINE::ForEachLoop::getProgressWeight().

 {
   list<Node *> ret;
   if(_node)
     ret.push_back(_node);
   if(_initNode)
     ret.push_back(_initNode);
   if(_finalizeNode)
     ret.push_back(_finalizeNode);
   return ret;
 }

InputPort* YACS::ENGINE::DynParaLoop::edGetNbOfBranchesPort ( )

inline

Definition at line 78 of file DynParaLoop.hxx.

Referenced by YACS::ENGINE::Runtime::createForEachLoop(), YACS::ENGINE::RuntimeSALOME::createOptimizerLoop(), YACS::HMI::SubjectDynParaLoop::getValue(), YACS::ENGINE::VisitorSaveSchema::visitForEachLoop(), and YACS::ENGINE::VisitorSaveSchema::visitOptimizerLoop().

78 { return &_nbOfBranches; }

OutputPort* YACS::ENGINE::DynParaLoop::edGetSamplePort ( )

inline

Definition at line 85 of file DynParaLoop.hxx.

Referenced by YACS::HMI::EditionForEachLoop::EditionForEachLoop(), YACS::HMI::CommandSetAlgo::localExecute(), YACS::HMI::CommandSetAlgo::localReverse(), YACS::HMI::EditionOptimizerLoop::update(), and YACS::ENGINE::VisitorSaveSchema::visitForEachLoop().

85 { return &_splittedPort; }

void DynParaLoop::edRemoveChild ( Node * node ) throw (Exception)

virtual

Remove a child node.

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 246 of file DynParaLoop.cxx.

References YACS::ENGINE::ComposedNode::edRemoveChild().

Referenced by YACS::HMI::SubjectForEachLoop::clean().

 {
   ComposedNode::edRemoveChild(node);
   if(node==_node)
     _node=0;
   if(node==_initNode)
     _initNode=0;
   if(node==_finalizeNode)
     _finalizeNode=0;
   modified();
 }

Node * DynParaLoop::edRemoveFinalizeNode ( )

Definition at line 241 of file DynParaLoop.cxx.

References _finalizeNode, and removeNode().

 {
   return removeNode(_finalizeNode);
 }

Node * DynParaLoop::edRemoveInitNode ( )

Definition at line 236 of file DynParaLoop.cxx.

References _initNode, and removeNode().

 {
   return removeNode(_initNode);
 }

Node * DynParaLoop::edRemoveNode ( )

Definition at line 219 of file DynParaLoop.cxx.

References _node, and removeNode().

 {
   return removeNode(_node);
 }

Node * DynParaLoop::edSetFinalizeNode ( Node * DISOWNnode )

Definition at line 128 of file DynParaLoop.cxx.

References _finalizeNode, and checkConsistencyAndSetNode().

 {
   return checkConsistencyAndSetNode(_finalizeNode, node);
 }

Node * DynParaLoop::edSetInitNode ( Node * DISOWNnode )

Definition at line 123 of file DynParaLoop.cxx.

References _initNode, and checkConsistencyAndSetNode().

 {
   return checkConsistencyAndSetNode(_initNode, node);
 }

Node * DynParaLoop::edSetNode ( Node * DISOWNnode )

Definition at line 75 of file DynParaLoop.cxx.

References _node, and checkConsistencyAndSetNode().

 {
   return checkConsistencyAndSetNode(_node, node);
 }

void DynParaLoop::forceMultiplicity ( unsigned value )

virtual

Implements YACS::ENGINE::Scheduler.

Definition at line 437 of file DynParaLoop.cxx.

References _nbOfBranches, YACS::ENGINE::InputPort::edInit(), and YACS::ENGINE::InPort::edRemoveAllLinksLinkedWithMe().

 {
   _nbOfBranches.edRemoveAllLinksLinkedWithMe();
   _nbOfBranches.edInit((int)value);
 }

void DynParaLoop::forwardExecStateToOriginalBody ( Node * execNode )

protectedvirtual

Definition at line 648 of file DynParaLoop.cxx.

References _finalizeNode, _initNode, _node, FINALIZE_NODE, YACS::ENGINE::ComposedNode::getAllRecursiveConstituents(), YACS::ENGINE::ComposedNode::getChildByName(), YACS::ENGINE::ComposedNode::getChildName(), YACS::ENGINE::Node::getErrorDetails(), getIdentityOfNotifyerNode(), YACS::ENGINE::Node::getState(), INIT_NODE, YACS::ENGINE::Node::setErrorDetails(), YACS::ENGINE::Node::setState(), WORK_NODE, and YASSERT.

Referenced by YACS::ENGINE::ForEachLoop::exUpdateState(), YACS::ENGINE::ForEachLoop::updateStateForWorkNodeOnFinishedEventFrom(), and updateStateOnFailedEventFrom().

 {
   unsigned int id;
   Node * origNode = NULL;
   switch (getIdentityOfNotifyerNode(execNode,id))
     {
     case INIT_NODE:
     {
       origNode = _initNode;
       break;
     }
     case WORK_NODE:
     {
       origNode = _node;
       break;
     }
     case FINALIZE_NODE:
     {
       origNode = _finalizeNode;
       break;
     }
     default:
       YASSERT(false)
     }
 
   YASSERT(origNode != NULL)
   origNode->setState(execNode->getState());
   origNode->setErrorDetails(execNode->getErrorDetails());
 
   ComposedNode* compNode = dynamic_cast<ComposedNode*>(origNode);
   ComposedNode* compNodeExe = dynamic_cast<ComposedNode*>(execNode);
   if (compNode && compNodeExe)
     {
       list<Node *> aChldn = compNodeExe->getAllRecursiveConstituents();
       list<Node *>::iterator iter=aChldn.begin();
       for(;iter!=aChldn.end();iter++)
         {
           Node* node=compNode->getChildByName(compNodeExe->getChildName(*iter));
           node->setState((*iter)->getState());
           node->setErrorDetails((*iter)->getErrorDetails());
         }
     }
 }

int DynParaLoop::getBranchIDOfNode ( Node * node ) const

DynParaLoop creates at runtime (exupdateState) clone of nodes. One clone per branch. This method returns the id of the branch given the node node. If node is not a dynamically created node in this -1 is returned.

Definition at line 162 of file DynParaLoop.cxx.

References _execFinalizeNodes, _execInitNodes, _execNodes, _finalizeNode, _initNode, _node, and gui.graph::distance().

Referenced by YACS::ENGINE::Node::getDPLScopeInfo().

 {
   if(_node)
     {
       for(std::vector<Node *>::const_iterator it=_execNodes.begin();it!=_execNodes.end();it++)
         if(node==*it)
           return std::distance(_execNodes.begin(),it);
     }
   if(_finalizeNode)
     {
       for(std::vector<Node *>::const_iterator it=_execFinalizeNodes.begin();it!=_execFinalizeNodes.end();it++)
         if(node==*it)
           return std::distance(_execFinalizeNodes.begin(),it);
     }
   if(_initNode)
     {
       for(std::vector<Node *>::const_iterator it=_execInitNodes.begin();it!=_execInitNodes.end();it++)
         if(node==*it)
           return std::distance(_execInitNodes.begin(),it);
     }
   return -1;
 }

Node * DynParaLoop::getChildByNameExec	(	const std::string &	name,
		unsigned	id
	)		const throw (Exception)

Definition at line 316 of file DynParaLoop.cxx.

 {
   if(id>=getNumberOfBranchesCreatedDyn())
     throw Exception("ForEachLoop::getChildByNameExec : invalid id - too large compared with dynamically created branches.");
   if (_node && name == _node->getName())
     return _execNodes[id];
   if (_initNode && name == _initNode->getName())
     return _execInitNodes[id];
   if (_finalizeNode && name == _finalizeNode->getName())
     return _execFinalizeNodes[id];
   std::string what("node "); what+= name ; what+=" is not a child of DynParaLoop node "; what += getName();
   throw Exception(what);
 }

Node * DynParaLoop::getChildByShortName ( const std::string & name ) const throw (Exception)

virtual

Implements YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop.

Definition at line 304 of file DynParaLoop.cxx.

Referenced by YACS::ENGINE::ForEachLoop::getChildByShortName().

 {
   if (_node && name == _node->getName())
     return _node;
   if (_initNode && name == _initNode->getName())
     return  _initNode;
   if (_finalizeNode && name == _finalizeNode->getName())
     return  _finalizeNode;
   std::string what("node "); what+= name ; what+=" is not a child of DynParaLoop node "; what += getName();
   throw Exception(what);
 }

InputPort * DynParaLoop::getDynInputPortByAbsName	(	int	branchNb,
		const std::string &	name,
		bool	initNodeAdmitted
	)

protected

Note: : For a given name 'name' of port in absolute form from this, returns the corresponding InputPort instance of the port for the branch # 'branchNb'. The port can be part of _node or _initNode if it exists (if 'initNodeAdmitted' is true). WARNING : no check performed on 'branchNb' value to see if it is compatible with size of '_execNodes'. This method is called to dispatch value on each InputPort linked to this->._splitterNode._splittedPort

Definition at line 547 of file DynParaLoop.cxx.

References _execInitNodes, _execNodes, _initNode, _node, YACS::ENGINE::ComposedNode::getChildByName(), YACS::ENGINE::ComposedNode::isInMyDescendance(), YACS::ENGINE::Node::SEP_CHAR_IN_PORT, and YACS::ENGINE::ComposedNode::splitNamesBySep().

Referenced by prepareInputsFromOutOfScope(), and putValueOnBranch().

 {
   string portName, nodeName;
   splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,true);
   Node *staticChild = getChildByName(nodeName);
   Node *desc=isInMyDescendance(staticChild);
   if(desc==_node)
     {
       splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,false);
       return _execNodes[branchNb]->getInputPort(portName);
     }
   else if(desc==_initNode)
     if(initNodeAdmitted)
       {
         splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,false);
         return _execInitNodes[branchNb]->getInputPort(portName);
       }
   return 0;
 }

std::string DynParaLoop::getErrorReport ( )

virtual

returns a string that contains an error report if the node is in error

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 575 of file DynParaLoop.cxx.

References YACS::ENGINE::Node::_errorDetails, _execFinalizeNodes, _execInitNodes, _execNodes, YACS::ENGINE::Node::_state, DEBTRACE, edGetDirectDescendants(), YACS::ERROR, YACS::FAILED, YACS::ENGINE::Node::getEffectiveState(), YACS::ENGINE::ComposedNode::getName(), and YACS::INVALID.

 {
   DEBTRACE("DynParaLoop::getErrorReport: " << getName() << " " << _state);
   YACS::StatesForNode effectiveState=getEffectiveState();
 
   if(effectiveState != YACS::INVALID &&  effectiveState != YACS::ERROR && effectiveState != YACS::FAILED)
     return "";
 
   std::string report="<error node= " + getName();
   switch(effectiveState)
     {
     case YACS::INVALID:
       report=report+" state= INVALID";
       break;
     case YACS::ERROR:
       report=report+" state= ERROR";
       break;
     case YACS::FAILED:
       report=report+" state= FAILED";
       break;
     default:
       break;
     }
   report=report + ">\n" ;
   if(_errorDetails != "")
     report=report+_errorDetails+"\n";
 
   if(_execNodes.empty())
     {
       // edition node
       list<Node *> constituents=edGetDirectDescendants();
       for(list<Node *>::iterator iter=constituents.begin(); iter!=constituents.end(); iter++)
         {
           std::string rep=(*iter)->getErrorReport();
           if(rep != "")
             {
               report=report+rep+"\n";
             }
         }
     }
   else
     {
       // execution nodes
       for(vector<Node *>::iterator iter=_execInitNodes.begin();iter!=_execInitNodes.end();iter++)
         {
           std::string rep=(*iter)->getErrorReport();
           if(rep != "")
             {
               report=report+rep+"\n";
             }
         }
       for(vector<Node *>::iterator iter=_execNodes.begin();iter!=_execNodes.end();iter++)
         {
           std::string rep=(*iter)->getErrorReport();
           if(rep != "")
             {
               report=report+rep+"\n";
             }
         }
       for(vector<Node *>::iterator iter=_execFinalizeNodes.begin();iter!=_execFinalizeNodes.end();iter++)
         {
           std::string rep=(*iter)->getErrorReport();
           if(rep != "")
             {
               report=report+rep+"\n";
             }
         }
     }
 
   report=report+"</error>";
   return report;
 }

Node * DynParaLoop::getExecNode ( )

Definition at line 884 of file DynParaLoop.cxx.

References _node.

Referenced by YACS::HMI::SubjectDynParaLoop::completeChildrenSubjectList(), and YACS::ENGINE::VisitorSaveSchema::visitDynParaLoop().

 {
   return _node;
 }

Node * DynParaLoop::getFinalizeNode ( )

Definition at line 889 of file DynParaLoop.cxx.

References _finalizeNode.

Referenced by YACS::HMI::SubjectDynParaLoop::completeChildrenSubjectList(), and YACS::ENGINE::VisitorSaveSchema::visitDynParaLoop().

 {
   return _finalizeNode;
 }

DynParaLoop::TypeOfNode DynParaLoop::getIdentityOfNotifyerNode	(	const Node *	node,
		unsigned &	id
	)

protected

Definition at line 409 of file DynParaLoop.cxx.

References _execFinalizeNodes, _execInitNodes, _execNodes, FINALIZE_NODE, INIT_NODE, and WORK_NODE.

Referenced by forwardExecStateToOriginalBody(), updateStateOnFailedEventFrom(), YACS::ENGINE::ForEachLoop::updateStateOnFailedEventFrom(), YACS::ENGINE::OptimizerLoop::updateStateOnFinishedEventFrom(), and YACS::ENGINE::ForEachLoop::updateStateOnFinishedEventFrom().

 {
   vector<Node *>::iterator iter;
   id=0;
   for (iter=_execNodes.begin() ; iter!=_execNodes.end() ; iter++,id++)
     if (*iter==node)
       return WORK_NODE;
   id=0;
   for (iter=_execInitNodes.begin() ; iter!=_execInitNodes.end() ; iter++,id++)
     if (*iter==node)
       return INIT_NODE;
   id=0;
   for (iter=_execFinalizeNodes.begin() ; iter!=_execFinalizeNodes.end() ; iter++,id++)
     if (*iter==node)
       return FINALIZE_NODE;
 }

Node * DynParaLoop::getInitNode ( )

Definition at line 879 of file DynParaLoop.cxx.

References _initNode.

Referenced by YACS::HMI::SubjectDynParaLoop::completeChildrenSubjectList(), and YACS::ENGINE::VisitorSaveSchema::visitDynParaLoop().

 {
   return _initNode;
 }

InputPort * DynParaLoop::getInputPort ( const std::string & name ) const throw (Exception)

virtual

Get an input port given its name.

Contrary to YACS::ENGINE::ComposedNode::getOutputPort, this method is NOT recursive and so the leaf of type ElementaryNode aggregating this InputPort is directly invoked.

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 282 of file DynParaLoop.cxx.

References YACS::ENGINE::ComposedNode::getInputPort().

Referenced by YACS::ENGINE::OptimizerLoop::getInputPort(), and YACS::ENGINE::ForEachLoop::getInputPort().

 {
   if(name==NAME_OF_NUMBER_OF_BRANCHES)
     return (InputPort *)&_nbOfBranches;
   return ComposedNode::getInputPort(name);
 }

std::list< InputPort * > DynParaLoop::getLocalInputPorts ( ) const

virtual

redefined on derived class of ComposedNode. by default a ComposedNode has no port by itself

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 289 of file DynParaLoop.cxx.

References _nbOfBranches, YACS::ENGINE::ComposedNode::getLocalInputPorts(), and PMMLBasicsTestLauncher::ret.

Referenced by YACS::ENGINE::OptimizerLoop::getLocalInputPorts(), YACS::ENGINE::ForEachLoop::getLocalInputPorts(), and prepareInputsFromOutOfScope().

 {
   list<InputPort *> ret=ComposedNode::getLocalInputPorts();
   ret.push_back((InputPort *)&_nbOfBranches);
   return ret;
 }

std::list< OutputPort * > DynParaLoop::getLocalOutputPorts ( ) const

virtual

redefined on derived class of ComposedNode. by default a ComposedNode has no port by itself

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 192 of file DynParaLoop.cxx.

References _splittedPort, YACS::ENGINE::ComposedNode::getLocalOutputPorts(), and PMMLBasicsTestLauncher::ret.

Referenced by YACS::ENGINE::OptimizerLoop::getLocalOutputPorts().

 {
   list<OutputPort *> ret=ComposedNode::getLocalOutputPorts();
   ret.push_back((OutputPort *)&_splittedPort);
   return ret;
 }

int DynParaLoop::getMaxLevelOfParallelism ( ) const

virtual

Implements YACS::ENGINE::Node.

Definition at line 894 of file DynParaLoop.cxx.

References _nbOfBranches, _node, YACS::ENGINE::AnyInputPort::getIntValue(), and YACS::ENGINE::Node::getMaxLevelOfParallelism().

 {
   return _nbOfBranches.getIntValue() * _node->getMaxLevelOfParallelism();
 }

std::vector<Node *> YACS::ENGINE::DynParaLoop::getNodes ( ) const

inline

Definition at line 99 of file DynParaLoop.hxx.

99 { return _execNodes; } // need to use in GUI part for adding observers for clone nodes

unsigned DynParaLoop::getNumberOfBranchesCreatedDyn ( ) const throw (Exception)

Definition at line 296 of file DynParaLoop.cxx.

References _execNodes.

 {
   if(_execNodes.empty())
     throw Exception("ForEachLoop::getNumberOfBranches : No branches created dynamically ! - ForEachLoop needs to run or to be runned to call getNumberOfBranches");
   else
     return _execNodes.size();
 }

unsigned YACS::ENGINE::DynParaLoop::getNumberOfEltsConsumed ( ) const

inline

Definition at line 81 of file DynParaLoop.hxx.

81 { return _nbOfEltConsumed; }

int DynParaLoop::getNumberOfInputPorts ( ) const

virtual

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 147 of file DynParaLoop.cxx.

References YACS::ENGINE::ComposedNode::getNumberOfInputPorts().

Referenced by YACS::ENGINE::OptimizerLoop::getNumberOfInputPorts(), and YACS::ENGINE::ForEachLoop::getNumberOfInputPorts().

 {
   return ComposedNode::getNumberOfInputPorts()+1;
 }

int DynParaLoop::getNumberOfOutputPorts ( ) const

virtual

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::OptimizerLoop.

Definition at line 152 of file DynParaLoop.cxx.

References YACS::ENGINE::ComposedNode::getNumberOfOutputPorts().

Referenced by YACS::ENGINE::OptimizerLoop::getNumberOfOutputPorts().

 {
   return ComposedNode::getNumberOfOutputPorts()+1;
 }

OutPort * DynParaLoop::getOutPort ( const std::string & name ) const throw (Exception)

virtual

Note: : Contrary to getOutputPort method, this method returns the output port at highest level, possible. That is to say in some ComposedNode, like ForEachLoop or Switch, an outport inside 'this' is seen differently than the true outport.

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 199 of file DynParaLoop.cxx.

References YACS::ENGINE::ComposedNode::getOutPort().

Referenced by cloneAndPlaceNodesCoherently(), YACS::ENGINE::OptimizerLoop::getOutPort(), and YACS::ENGINE::ForEachLoop::getOutPort().

 {
   if (name == NAME_OF_SPLITTED_SEQ_OUT || name == OLD_NAME_OF_SPLITTED_SEQ_OUT)
     return (OutPort *)&_splittedPort;
   return ComposedNode::getOutPort(name);
 }

OutputPort * DynParaLoop::getOutputPort ( const std::string & name ) const throw (Exception)

virtual

Get an output port given its name.

Contrary to YACS::ENGINE::ComposedNode::getInputPort, this method is recursive and go down hierarchy step by step to complete its work.

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 207 of file DynParaLoop.cxx.

References YACS::ENGINE::ComposedNode::getOutputPort().

Referenced by YACS::ENGINE::OptimizerLoop::getOutputPort(), and YACS::ENGINE::ForEachLoop::getOutputPort().

 {
   if (name == NAME_OF_SPLITTED_SEQ_OUT || name == OLD_NAME_OF_SPLITTED_SEQ_OUT)
     return (OutputPort *)&_splittedPort;
   return ComposedNode::getOutputPort(name);
 }

std::list< InputPort * > DynParaLoop::getSetOfInputPort ( ) const

virtual

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 275 of file DynParaLoop.cxx.

References _nbOfBranches, YACS::ENGINE::ComposedNode::getSetOfInputPort(), and PMMLBasicsTestLauncher::ret.

Referenced by YACS::ENGINE::OptimizerLoop::getSetOfInputPort(), and YACS::ENGINE::ForEachLoop::getSetOfInputPort().

 {
   list<InputPort *> ret=ComposedNode::getSetOfInputPort();
   ret.push_back((InputPort *)&_nbOfBranches);
   return ret;
 }

std::list< OutputPort * > DynParaLoop::getSetOfOutputPort ( ) const

virtual

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::OptimizerLoop.

Definition at line 185 of file DynParaLoop.cxx.

References _splittedPort, YACS::ENGINE::ComposedNode::getSetOfOutputPort(), and PMMLBasicsTestLauncher::ret.

Referenced by YACS::ENGINE::OptimizerLoop::getSetOfOutputPort().

 {
   list<OutputPort *> ret=ComposedNode::getSetOfOutputPort();
   ret.push_back((OutputPort *)&_splittedPort);
   return ret;
 }

void DynParaLoop::init ( bool start = true )

virtual

initialisation of all input and output ports and gates, for execution

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 106 of file DynParaLoop.cxx.

References _failedCounter, _finalizeNode, _initNode, YACS::ENGINE::Node::_name, _nbOfBranches, _nbOfEltConsumed, _node, _splittedPort, YACS::ENGINE::OutputPort::exInit(), YACS::ENGINE::InputPort::exInit(), YACS::ENGINE::ComposedNode::init(), and YACS::ENGINE::Node::init().

Referenced by YACS::ENGINE::OptimizerLoop::init(), and YACS::ENGINE::ForEachLoop::init().

 {
   ComposedNode::init(start);
   if(!_node)
     {
       string what("DynParaLoop::init : no node specified for ForEachLoop with name "); what +=_name;
       throw Exception(what);
     }
   _node->init(start);
   if (_initNode) _initNode->init(start);
   if (_finalizeNode) _finalizeNode->init(start);
   _nbOfBranches.exInit(start);
   _splittedPort.exInit();
   _nbOfEltConsumed=0;
   _failedCounter=0;
 }

bool DynParaLoop::isMultiplicitySpecified ( unsigned & value ) const

virtual

Implements YACS::ENGINE::Scheduler.

Definition at line 426 of file DynParaLoop.cxx.

References _nbOfBranches, YACS::ENGINE::InPort::edGetNumberOfLinks(), YACS::ENGINE::InputPort::edIsManuallyInitialized(), and YACS::ENGINE::AnyInputPort::getIntValue().

 {
   if(_nbOfBranches.edIsManuallyInitialized())
     if(_nbOfBranches.edGetNumberOfLinks()==0)
       {
         value=_nbOfBranches.getIntValue();
         return true;
       }
   return false;
 }

bool DynParaLoop::isPlacementPredictableB4Run ( ) const

virtual

For the moment false is returned : impovement about it coming soon.

Implements YACS::ENGINE::ComposedNode.

Definition at line 214 of file DynParaLoop.cxx.

 {
   return false;
 }

void DynParaLoop::prepareInputsFromOutOfScope ( int branchNb )

protected

This method applies on newly cloned on exec nodes (_execNodes/_execInitNodes) the setting of input ports coming from outside of 'this'

Definition at line 348 of file DynParaLoop.cxx.

References YACS::ENGINE::InPort::edNotifyReferencedBy(), YACS::ENGINE::InputPort::get(), YACS::ENGINE::ComposedNode::getAllInPortsComingFromOutsideOfCurrentScope(), getDynInputPortByAbsName(), YACS::ENGINE::ComposedNode::getInPortName(), getLocalInputPorts(), YACS::ENGINE::Node::getSetOfInPort(), and YACS::ENGINE::InputPort::put().

Referenced by YACS::ENGINE::OptimizerLoop::exUpdateState(), and YACS::ENGINE::ForEachLoop::exUpdateState().

 {
   set< InPort * > portsToSetVals=getAllInPortsComingFromOutsideOfCurrentScope();
 
   // This tweak is to fix problems with nested dynamic loops where links are not cloned properly
   list<InPort *> temp = getSetOfInPort();
   for(list<InPort *>::iterator iter2=temp.begin();iter2!=temp.end();iter2++)
     {
       if ((*iter2)->edSetOutPort().size() == 1 && *(*iter2)->edSetOutPort().begin() == NULL)
         {
           portsToSetVals.insert(*iter2);
         }
     }
 
   // local input ports are not candidates for dynamically duplicated inport.
   list<InputPort *> localPorts = getLocalInputPorts();
   for(list<InputPort *>::iterator iter = localPorts.begin() ; iter != localPorts.end() ; iter++)
     portsToSetVals.erase(*iter);
   for(set< InPort * >::iterator iter=portsToSetVals.begin();iter!=portsToSetVals.end();iter++)
     {
       InputPort *curPortCasted=(InputPort *) *iter;//Cast granted by ForEachLoop::buildDelegateOf(InPort)
       void *val=curPortCasted->get();
       InputPort *portToSet=getDynInputPortByAbsName(branchNb,getInPortName(*iter),true);
       if(portToSet)//portToSet==0 in case of portToSet==_splitterNode._dataPortToDispatch of ForEach
         {
           portToSet->put((const void *)val);
           portToSet->edNotifyReferencedBy(0);//This is to indicate that somewhere somebody deals with this inputport
           //even if no direct physical link exists. This exclusively for _execNodes[branchNb]::init on the next turn of loop.
         }
     }
 }

void DynParaLoop::putValueOnBranch	(	Any *	val,
		unsigned	branchId,
		bool	first
	)

protected

Definition at line 380 of file DynParaLoop.cxx.

References _splittedPort, YACS::ENGINE::Runtime::adapt(), YACS::ENGINE::Any::clone(), YACS::ENGINE::RefCounter::decrRef(), YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::InPort::edNotifyReferencedBy(), YACS::ENGINE::OutputPort::edSetInPort(), getDynInputPortByAbsName(), YACS::ENGINE::ComposedNode::getPortName(), YACS::ENGINE::getRuntime(), YACS::ENGINE::InputPort::put(), YACS::ENGINE::Runtime::RUNTIME_ENGINE_INTERACTION_IMPL_NAME, and YACS::ENGINE::AnyOutputPort::setValue().

Referenced by YACS::ENGINE::OptimizerLoop::launchMaxOfSamples(), and YACS::ENGINE::SplitterNode::putSplittedValueOnRankTo().

 {
   bool isDispatched = false;
   set<InPort *> inPrtLkdWthSplttdPrt=_splittedPort.edSetInPort();
   for(set<InPort *>::iterator iter=inPrtLkdWthSplttdPrt.begin();iter!=inPrtLkdWthSplttdPrt.end();iter++)
     {
       std::string portNameOnCurPrt=getPortName(*iter);
       InputPort *portOnGivenBranch=getDynInputPortByAbsName(branchId,portNameOnCurPrt,first);//Cast granted because impossible to have cross protocol with _splittedPort
       //see OptimizerLoop::buildDelegateOf
       if(portOnGivenBranch)
         {
           if(first)
             portOnGivenBranch->edNotifyReferencedBy(0);
           InputPort *traducer=getRuntime()->adapt(portOnGivenBranch,
                                                   Runtime::RUNTIME_ENGINE_INTERACTION_IMPL_NAME,_splittedPort.edGetType());
           traducer->put((const void *)val);
           isDispatched = true;
           if(traducer!=portOnGivenBranch)
             delete traducer;
         }
     }
   if ( isDispatched )
     {
       Any *tmp=val->clone();
       _splittedPort.setValue(tmp);
       tmp->decrRef();
     }
 }

Node * DynParaLoop::removeNode ( Node *& nodeToRemove )

protected

This method is used to factorize methods edRemoveNode, edRemoveInitNode and edRemoveFinalizeNode.

Definition at line 225 of file DynParaLoop.cxx.

References YACS::ENGINE::ComposedNode::edRemoveChild(), YACS::ENGINE::Node::modified(), and PMMLBasicsTestLauncher::ret.

Referenced by edRemoveFinalizeNode(), edRemoveInitNode(), and edRemoveNode().

 {
   if (!nodeToRemove)
     return NULL;
   ComposedNode::edRemoveChild(nodeToRemove);
   Node * ret = nodeToRemove;
   nodeToRemove = NULL;
   modified();
   return ret;
 }

void DynParaLoop::shutdown ( int level )

protectedvirtual

Stop all pending activities of the composed node.

This method should be called when a Proc is finished and must be deleted from the YACS server

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 899 of file DynParaLoop.cxx.

References _execFinalizeNodes, _execInitNodes, _execNodes, and _node.

 {
   if(level==0)return;
   if(!_node) return;
 
   std::vector<Node *>::iterator iter;
   for (iter=_execNodes.begin() ; iter!=_execNodes.end() ; iter++)
     (*iter)->shutdown(level);
   for (iter=_execInitNodes.begin() ; iter!=_execInitNodes.end() ; iter++)
     (*iter)->shutdown(level);
   for (iter=_execFinalizeNodes.begin() ; iter!=_execFinalizeNodes.end() ; iter++)
     (*iter)->shutdown(level);
 }

YACS::Event DynParaLoop::updateStateOnFailedEventFrom	(	Node *	node,
		const Executor *	execInst
	)

protectedvirtual

Method used to notify the node that a child node has failed.

Update the current state and return the change state

Parameters

node	: the child node that has failed

Returns: the state change

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::ForEachLoop, and YACS::ENGINE::OptimizerLoop.

Definition at line 699 of file DynParaLoop.cxx.

References _finalizeNode, _node, YACS::ABORT, DEBTRACE, YACS::FAILED, forwardExecStateToOriginalBody(), getIdentityOfNotifyerNode(), YACS::ENGINE::Node::getName(), INIT_NODE, YACS::ENGINE::Node::setState(), and WORK_NODE.

Referenced by YACS::ENGINE::OptimizerLoop::updateStateOnFailedEventFrom(), and YACS::ENGINE::ForEachLoop::updateStateOnFailedEventFrom().

 {
   DEBTRACE("DynParaLoop::updateStateOnFailedEventFrom " << node->getName());
   setState(YACS::FAILED);
   forwardExecStateToOriginalBody(node);
   unsigned int id;
   switch (getIdentityOfNotifyerNode(node,id))
     {
     case INIT_NODE:
     {
       _node->setState(YACS::FAILED);
       if (_finalizeNode != NULL) _finalizeNode->setState(YACS::FAILED);
       break;
     }
     case WORK_NODE:
     {
       if (_finalizeNode != NULL) _finalizeNode->setState(YACS::FAILED);
       break;
     }
     }
   return YACS::ABORT;
 }