Composed node to group elementary and composed nodes. More...

#include <Bloc.hxx>

Inheritance diagram for YACS::ENGINE::Bloc:

Collaboration diagram for YACS::ENGINE::Bloc:

Public Member Functions
	Bloc (const Bloc &other, ComposedNode *father, bool editionOnly)

	Bloc (const std::string &name)
	Create a Bloc node with a given name. More...

virtual	~Bloc ()

bool	isFinished ()
	Indicate if the bloc execution is finished. More...

int	getNumberOfCFLinks () const

void	init (bool start=true)
	Initialize the bloc. More...

void	getReadyTasks (std::vector< Task * > &tasks)
	Collect all nodes that are ready to execute. More...

void	exUpdateState ()
	Update the bloc state. More...

bool	edAddChild (Node *DISOWNnode) throw (Exception)
	Add a child node to the bloc. More...

void	edRemoveChild (Node *node) throw (Exception)

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

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

std::vector< std::list< Node * > >	splitIntoIndependantGraph () const

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

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

void	accept (Visitor *visitor)

template<bool direction>
void	findAllPathsStartingFrom (Node start, std::list< std::vector< Node > > &vec, std::map< Node , std::set< Node > > &accelStr) const

template<bool direction>
void	findAllNodesStartingFrom (Node start, std::set< Node > &result, std::map< Node , std::set< Node > > &accelStr, LinkInfo &info) const

virtual std::string	typeName ()

int	getMaxLevelOfParallelism () const

void	removeRecursivelyRedundantCL ()

template<bool direction>
unsigned	appendIfAlreadyFound (std::list< std::vector< Node * > > &res, const std::vector< Node * > &startRes, Node node, std::map< Node , std::set< Node * > > &fastFinder)

Public Member Functions inherited from YACS::ENGINE::StaticDefinedComposedNode
bool	isPlacementPredictableB4Run () const

bool	isMultiplicitySpecified (unsigned &value) const

void	forceMultiplicity (unsigned value)

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

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

bool	isFinished ()

void	init (bool start=true)

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

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...

virtual bool	edAddDFLink (OutPort start, InPort end) throw (Exception)
	Connect an OutPort to an InPort and add the necessary control link. 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

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)

int	getNumberOfInputPorts () const

int	getNumberOfOutputPorts () const

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

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

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

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

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

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...

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 void	edUpdateState ()
	update the status of the node More...

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...

ComposedNode *	getRootNode () const throw (Exception)

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

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 ()

void	accept (Visitor *visitor)

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	exFailedState ()
	Notify this node that its execution has failed. More...

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

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	~Scheduler ()

Protected Member Functions
Node *	simpleClone (ComposedNode *father, bool editionOnly=true) const

bool	areAllSubNodesFinished () const

bool	areAllSubNodesDone () const

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

void	checkNoCyclePassingThrough (Node *node) throw (Exception)

std::vector< std::pair < OutGate , InGate > >	getSetOfInternalCFLinks () const

YACS::Event	updateStateOnFinishedEventFrom (Node *node)

YACS::Event	updateStateOnFailedEventFrom (Node node, const Executor execInst)
	Notify this bloc that a node has failed. More...

void	initComputation () const

void	performCFComputationsOnlyOneLevel (LinkInfo &info) const

void	performCFComputations (LinkInfo &info) const

void	destructCFComputations (LinkInfo &info) const
	destroy recursively all results of initial computations. 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

bool	areLinked (Node start, Node end, bool fw) const
	Check if two nodes are linked. More...

bool	arePossiblyRunnableAtSameTime (Node start, Node end) const
	Check if two nodes can run in parallel. More...

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

void	seekOkAndUseless1 (std::vector< Node * > &okAndUseless1, std::set< Node * > &allNodes) const

void	seekUseless2 (std::vector< Node * > &useless2, std::set< Node * > &allNodes) const

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

	StaticDefinedComposedNode (const StaticDefinedComposedNode &other, ComposedNode *father)

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

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 void	checkLinkPossibility (OutPort start, const std::list< ComposedNode > &pointsOfViewStart, InPort end, const std::list< ComposedNode > &pointsOfViewEnd) throw (Exception)

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

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

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)

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)

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 void	exForwardFailed ()

virtual void	exForwardFinished ()

Static Protected Member Functions
static void	verdictForOkAndUseless1 (const std::map< Node , std::list< OutPort > > &pool, InputPort end, const std::vector< Node > &candidates, unsigned char &alreadyFed, bool direction, LinkInfo &info)

static void	verdictForCollapses (const std::map< Node , std::list< OutPort > > &pool, InputPort end, const std::set< Node > &candidates, unsigned char &alreadyFed, bool direction, LinkInfo &info)

Protected Attributes
std::list< Node * >	_setOfNode

std::map< Node , std::set < Node > > *	_fwLinks
	For internal calculations. More...

std::map< Node , std::set < Node > > *	_bwLinks
	For internal calculations. More...

Static Private Member Functions
static void	findUselessLinksIn (const std::list< std::vector< Node * > > &res, LinkInfo &info)

template<bool direction>
static unsigned	appendIfAlreadyFound (std::list< std::vector< Node * > > &res, const std::vector< Node * > &startRes, Node node, std::map< Node , std::set< Node * > > &fastFinder)

static void	updateWithNewFind (const std::vector< Node * > &path, std::map< Node , std::set< Node > > &fastFinder)

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 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

Detailed Description

Composed node to group elementary and composed nodes.

Definition at line 30 of file Bloc.hxx.

Constructor & Destructor Documentation

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

Definition at line 46 of file Bloc.cxx.

References _setOfNode, YACS::ENGINE::ComposedNode::edAddCFLink(), YACS::ENGINE::ComposedNode::edAddLink(), YACS::ENGINE::ComposedNode::getChildByName(), YACS::ENGINE::ComposedNode::getChildName(), YACS::ENGINE::Node::getInPort(), YACS::ENGINE::ComposedNode::getLowestCommonAncestor(), YACS::ENGINE::Port::getNode(), YACS::ENGINE::ComposedNode::getOutPort(), YACS::ENGINE::ComposedNode::getPortName(), getSetOfInternalCFLinks(), and YACS::ENGINE::ComposedNode::getSetOfInternalLinks().

Referenced by simpleClone().

                                                                    :StaticDefinedComposedNode(other,father),_fwLinks(0),_bwLinks(0)
 {
   for(list<Node *>::const_iterator iter=other._setOfNode.begin();iter!=other._setOfNode.end();iter++)
     _setOfNode.push_back((*iter)->simpleClone(this,editionOnly));
 
   //CF Linking
   vector< pair<OutGate *, InGate *> > cfLinksToReproduce=other.getSetOfInternalCFLinks();
   vector< pair<OutGate *, InGate *> >::iterator iter1=cfLinksToReproduce.begin();
   for(;iter1!=cfLinksToReproduce.end();iter1++)
     edAddCFLink(getChildByName(other.getChildName((*iter1).first->getNode())),getChildByName(other.getChildName((*iter1).second->getNode())));
 
   //Data + DataStream linking
   vector< pair<OutPort *, InPort *> > linksToReproduce=other.getSetOfInternalLinks();
   vector< pair<OutPort *, InPort *> >::iterator iter2=linksToReproduce.begin();
   for(;iter2!=linksToReproduce.end();iter2++)
     {
       OutPort* pout = iter2->first;
       InPort* pin = iter2->second;
       if(&other == getLowestCommonAncestor(pout->getNode(), pin->getNode()))
       {
         edAddLink(getOutPort(other.getPortName(pout)),getInPort(other.getPortName(pin)));
       }
     }
 }

Bloc::Bloc ( const std::string & name )

Create a Bloc node with a given name.

Parameters

name	: the given name

Definition at line 75 of file Bloc.cxx.

                                :StaticDefinedComposedNode(name),_fwLinks(0),_bwLinks(0)
 {
 }

Bloc::~Bloc ( )

virtual

Definition at line 79 of file Bloc.cxx.

References _bwLinks, _fwLinks, and _setOfNode.

 {
   for(list<Node *>::iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
     delete *iter;
   delete _fwLinks;
   delete _bwLinks;
 }

Member Function Documentation

void Bloc::accept ( Visitor * visitor )

virtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::Proc.

Definition at line 445 of file Bloc.cxx.

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

 {
   visitor->visitBloc(this);
 }

template<bool direction>

static unsigned YACS::ENGINE::Bloc::appendIfAlreadyFound	(	std::list< std::vector< Node * > > &	res,
		const std::vector< Node * > &	startRes,
		Node *	node,
		std::map< Node , std::set< Node > > &	fastFinder
	)

staticprivate

template<bool direction>

unsigned YACS::ENGINE::Bloc::appendIfAlreadyFound	(	std::list< std::vector< Node * > > &	res,
		const std::vector< Node * > &	startRes,
		Node *	node,
		std::map< Node , std::set< Node > > &	fastFinder
	)

Internal method for CF computation. Given 'fastFinder' it searched 'node' to see if an already found path in 'res' go through 'node'. If true all paths are deduced and append to res and 'fastFinder' is updated for next turn.

Definition at line 125 of file Bloc.hxx.

References CORBAEngineTest::i, PMMLBasicsTestLauncher::ret, and updateWithNewFind().

     {
       std::map<Node *, std::set<Node *> >::iterator iter=fastFinder.find(node);
       if(iter==fastFinder.end())
         return 0;
       unsigned ret=0;
       std::vector<std::pair<std::set<Node *>::iterator, std::set<Node *>::iterator > > li;
       std::pair<std::set<Node *>::iterator, std::set<Node *>::iterator> ipr(((*iter).second).begin(),((*iter).second).end());
       li.push_back(ipr);
       std::vector<Node *> work(startRes);
       std::list< std::vector<Node *> >::iterator where=res.end(); where--;
       std::list< std::vector<Node *> >::iterator updates=where;
       while(!li.empty())
         {
           if(li.back().first!=li.back().second)
             {
               work.push_back(*(li.back().first));
               if(CFDirectionVisTraits<direction>::getNexts(work.back()).empty())
                 {
                   where=res.insert(where,work);
                   ret++;
                   li.back().first++;
                   work.pop_back();
                 }
               else
                 {
                   std::set<Node *>& s=fastFinder[*(li.back().first)];
                   std::pair<std::set<Node *>::iterator, std::set<Node *>::iterator> pr(s.begin(),s.end());
                   li.push_back(pr);
                 }
             }
           else
             {
               work.pop_back();
               li.pop_back();
               if(!li.empty())
                 li.back().first++;
             }
         }
       updates--;
       for(unsigned i=0;i<ret;i++,updates--)
         updateWithNewFind(*updates,fastFinder);
       return ret;
     }

bool Bloc::areAllSubNodesDone ( ) const

protected

Definition at line 286 of file Bloc.cxx.

References _setOfNode, YACS::DISABLED, and YACS::DONE.

Referenced by updateStateOnFailedEventFrom(), and updateStateOnFinishedEventFrom().

 {
   for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
     {
       if((*iter)->_state == YACS::DONE)continue;
       if((*iter)->_state == YACS::DISABLED)continue;
       return false;
     }
   return true;
 }

bool Bloc::areAllSubNodesFinished ( ) const

protected

Definition at line 297 of file Bloc.cxx.

References _setOfNode, YACS::DISABLED, YACS::DONE, YACS::ERROR, YACS::FAILED, and YACS::INTERNALERR.

Referenced by updateStateOnFailedEventFrom(), and updateStateOnFinishedEventFrom().

 {
   for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
     {
       if((*iter)->_state == YACS::DONE)continue;
       if((*iter)->_state == YACS::FAILED)continue;
       if((*iter)->_state == YACS::DISABLED)continue;
       if((*iter)->_state == YACS::ERROR)continue;
       if((*iter)->_state == YACS::INTERNALERR)continue;
       return false;
     }
   return true;
 }

bool Bloc::areLinked	(	Node *	start,
		Node *	end,
		bool	fw
	)		const

protected

Check if two nodes are linked.

'start' and 'end' must be direct son of 'this'. Typically used for data link.

Parameters

start	: start node
end	: end node
fw	indicates if it is a forward link searched (true : default value) or a backward link serach.

Returns: if true or false

Definition at line 625 of file Bloc.cxx.

Referenced by checkControlDependancy().

 {
   set<Node *>& nexts=fw ? (*_fwLinks)[start] : (*_bwLinks)[start];
   return nexts.find(end)!=nexts.end();
 }

bool Bloc::arePossiblyRunnableAtSameTime	(	Node *	start,
		Node *	end
	)		const

protected

Check if two nodes can run in parallel.

Typically used for stream link. 'start' and 'end' must be direct son of 'this'.

Parameters

start	: start node
end	: end node

Returns: true or false

Definition at line 639 of file Bloc.cxx.

Referenced by checkControlDependancy().

 {
   set<Node *>& nexts=(*_fwLinks)[start];
   set<Node *>& preds=(*_bwLinks)[start];
   return nexts.find(end)==nexts.end() && preds.find(end)==preds.end();
 }

void Bloc::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	: end port
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	: collected information

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 654 of file Bloc.cxx.

References YACS::ENGINE::E_COLLAPSE_DFDS, YACS::ENGINE::ComposedNode::FED_DS_ST, YACS::ENGINE::ComposedNode::FED_ST, YACS::ENGINE::ComposedNode::FREE_ST, YACS::ENGINE::ComposedNode::isInMyDescendance(), YACS::ENGINE::LinkInfo::pushErrLink(), seekOkAndUseless1(), seekUseless2(), verdictForCollapses(), and verdictForOkAndUseless1().

Referenced by verdictForCollapses().

 {
   if(alreadyFed==FREE_ST || alreadyFed==FED_ST)
     {
       map<Node *,list <OutPort *> > classPerNodes;
       for(list< OutPort *>::const_iterator iter1=starts.begin();iter1!=starts.end();iter1++)
         classPerNodes[isInMyDescendance((*iter1)->getNode())].push_back(*iter1);
       set<Node *> allNodes;
       for(map<Node *,list <OutPort *> >::iterator iter2=classPerNodes.begin();iter2!=classPerNodes.end();iter2++)
         allNodes.insert((*iter2).first);
       vector<Node *> okAndUseless1,useless2;
       seekOkAndUseless1(okAndUseless1,allNodes);
       seekUseless2(useless2,allNodes);//after this point allNodes contains collapses
       verdictForOkAndUseless1(classPerNodes,end,okAndUseless1,alreadyFed,direction,info);
       verdictForCollapses(classPerNodes,end,allNodes,alreadyFed,direction,info);
       verdictForOkAndUseless1(classPerNodes,end,useless2,alreadyFed,direction,info);
     }
   else if(alreadyFed==FED_DS_ST)
     for(list< OutPort *>::const_iterator iter1=starts.begin();iter1!=starts.end();iter1++)
       info.pushErrLink(*iter1,end,E_COLLAPSE_DFDS);
 }

void Bloc::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

WARNING Needs call of performCFComputations before beeing called. Perform updates of containers regarding attributes of link 'start' -> 'end' and check the correct linking. The output is in info struct.

Parameters

start	: start port
end	: end port
cross	:
fw	out parameter being append if start -> end link is a forward link without cross type DF/DS.
fwCross	out parameter being append if start -> end link is a forward link with cross type DF/DS.
bw	out parameter being append if start -> end link is a backward link.
info	out parameter being informed about eventual errors.

Implements YACS::ENGINE::ComposedNode.

Definition at line 589 of file Bloc.cxx.

References areLinked(), arePossiblyRunnableAtSameTime(), YACS::ENGINE::E_DS_LINK_UNESTABLISHABLE, YACS::ENGINE::E_UNPREDICTABLE_FED, YACS::ENGINE::Port::getNode(), YACS::ENGINE::ComposedNode::isInMyDescendance(), and YACS::ENGINE::LinkInfo::pushErrLink().

 {
   if(!cross)
     {
       Node *startN=isInMyDescendance(start->getNode());
       Node *endN=isInMyDescendance(end->getNode());
       if(startN==endN)
         bw[(ComposedNode *)this].push_back(start);
       else if(areLinked(startN,endN,true))
         fw[(ComposedNode *)this].push_back(start);
       else
         if(areLinked(startN,endN,false))
           bw[(ComposedNode *)this].push_back(start);
         else
           info.pushErrLink(start,end,E_UNPREDICTABLE_FED);
     }
   else//DFDS detected
     if(arePossiblyRunnableAtSameTime(isInMyDescendance(start->getNode()),isInMyDescendance(end->getNode())))
       fwCross.push_back(start);
     else
       info.pushErrLink(start,end,E_DS_LINK_UNESTABLISHABLE);
 }

void Bloc::checkNoCyclePassingThrough ( Node * node ) throw (Exception)

protectedvirtual

Note: Checks that in the forest from 'node' there are NO back-edges. WARNING : When using this method 'node' has to be checked in order to be part of direct children of 'this'.

Implements YACS::ENGINE::ComposedNode.

Definition at line 336 of file Bloc.cxx.

References insertNodeChildrenInSet().

 {
   set<Node *> currentNodesToTest;
   //don't insert node to test in set. 
   //If it is present after insertion of connected nodes we have a loop
   //collect all connected nodes
   insertNodeChildrenInSet(node,currentNodesToTest);
   //try to insert node
   if(!(currentNodesToTest.insert(node)).second)
     throw Exception("Cycle has been detected",1);
 }

void Bloc::destructCFComputations ( LinkInfo & info ) const

protectedvirtual

destroy recursively all results of initial computations.

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 569 of file Bloc.cxx.

References _bwLinks, _fwLinks, and YACS::ENGINE::ComposedNode::destructCFComputations().

Referenced by removeRecursivelyRedundantCL().

 {
   StaticDefinedComposedNode::destructCFComputations(info);
   delete _fwLinks; _fwLinks=0;
   delete _bwLinks; _bwLinks=0;
 }

bool Bloc::edAddChild ( Node * node ) throw (Exception)

virtual

Add a child node to the bloc.

Parameters

node,: the node to add to the bloc

Returns: a boolean flag indicating if the node has been added

If node is already a direct child of current bloc, do nothing. If node is a child of another bloc, throw exception. If node name already used in bloc, throw exception. Publish inputPorts in current bloc and ancestors.

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 174 of file Bloc.cxx.

References YACS::ENGINE::Node::_father.

Referenced by YACS::HMI::SubjectNode::registerUndoDestroy().

 {
   if(isNodeAlreadyAggregated(node))
     {
       if(node->_father==this)
         return false;
       else
         {
           string what = "Bloc::edAddChild : node "; what += node->getName();
           what += " is already grand children of node";
           throw Exception(what);
         }
     }
 
   if(node->_father)
     {
       string what = "Bloc::edAddChild: node is not orphan: "; what += node->getName();
       throw Exception(what);
     }
   
   checkNoCrossHierachyWith(node);
 
   if(isNameAlreadyUsed(node->getName()))
     {
       string what("Bloc::edAddChild : name "); what+=node->getName(); 
       what+=" already exists in the scope of "; what+=_name;
       throw Exception(what);
     }
   
   node->_father=this;
   _setOfNode.push_back(node);
   //should we also set _modified flag for node ??
   ComposedNode *iter=node->_father;
   //set the _modified flag so that latter on edUpdateState (eventually called by isValid) refresh state
   //better call it at end
   modified();
   return true;
 }

std::list<Node *> YACS::ENGINE::Bloc::edGetDirectDescendants ( ) const

inlinevirtual

Implements YACS::ENGINE::ComposedNode.

Definition at line 53 of file Bloc.hxx.

Referenced by YACS::HMI::GuiEditor::PutGraphInBloc().

53 { return _setOfNode; }

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

virtual

Remove 'node' from the set of direct children.

Exceptions

If	'node' is NOT the son of 'this'.

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 218 of file Bloc.cxx.

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

 {
   StaticDefinedComposedNode::edRemoveChild(node);
   list<Node *>::iterator iter=find(_setOfNode.begin(),_setOfNode.end(),node);
   if(iter!=_setOfNode.end())
     {
       _setOfNode.erase(iter);
       modified();
     }
 }

void Bloc::exUpdateState ( )

virtual

Update the bloc state.

Update the '_state' attribute. Typically called by 'this->_inGate' when 'this->_inGate' is ready. Contrary to Node::exUpdateState no check done on inputs because internal linked DF inputports are not valid yet.

Reimplemented from YACS::ENGINE::Node.

Definition at line 151 of file Bloc.cxx.

References YACS::ENGINE::Node::_inGate, _setOfNode, YACS::ENGINE::Node::_state, YACS::ACTIVATED, YACS::DISABLED, YACS::DONE, YACS::ENGINE::InGate::exIsReady(), and YACS::ENGINE::Node::setState().

Referenced by YACS::ENGINE::loadState(), and main().

 {
   if(_state == YACS::DISABLED)return;
   if(_state == YACS::DONE)return;
   if(_inGate.exIsReady())
     {
       setState(YACS::ACTIVATED);
       for(list<Node *>::iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
         if((*iter)->exIsControlReady())
           (*iter)->exUpdateState();
     }
 }

template<bool direction>

void YACS::ENGINE::Bloc::findAllNodesStartingFrom	(	Node *	start,
		std::set< Node * > &	result,
		std::map< Node , std::set< Node > > &	accelStr,
		LinkInfo &	info
	)		const

Definition at line 171 of file Bloc.hxx.

References findUselessLinksIn().

     {
       std::list< std::vector<Node *> > li;
       findAllPathsStartingFrom<direction>(start,li,accelStr);
       for(std::list< std::vector<Node *> >::const_iterator iter=li.begin();iter!=li.end();iter++)
         for(std::vector<Node *>::const_iterator iter2=(*iter).begin()+1;iter2!=(*iter).end();iter2++)
           result.insert(*iter2);
       if(direction)
         findUselessLinksIn(li,info);
     }

template<bool direction>

void YACS::ENGINE::Bloc::findAllPathsStartingFrom	(	Node *	start,
		std::list< std::vector< Node * > > &	vec,
		std::map< Node , std::set< Node > > &	accelStr
	)		const

Method for CF computation.DFS visitor is used. if direction is true forward visiting is performed, if false backward is performed.

Parameters

start	must be a direct descendant of 'this'.
vec	:
accelStr

Definition at line 191 of file Bloc.hxx.

References YACS::ENGINE::Node::_colour, YACS::Black, initComputation(), and updateWithNewFind().

     {
       initComputation();
       Node *current=start;
       int caseId=0;
       int idInCase=0;
       vec.push_back(std::vector<Node *>());
       typename CFDirectionVisTraits<direction>::Iterator iter;
       std::list< std::vector<Node *> >::iterator curLine=vec.begin();
       while(start->_colour!=YACS::Black)
         {
           (*curLine).push_back(current);
           idInCase++;
           //
           if(CFDirectionVisTraits<direction>::getNexts(current).empty())
             {
               
               vec.push_back(std::vector<Node *>((*curLine)));
               updateWithNewFind(*curLine,accelStr);
               current->_colour=YACS::Black;
               curLine++;
               if(idInCase>1)
                 {
                   idInCase-=2;
                   current=(*curLine)[idInCase];
                   (*curLine).pop_back();
                   (*curLine).pop_back();
                 }
               continue;
             }
           if(current->_colour==YACS::Black)
             {
               appendIfAlreadyFound<direction>(vec,(*curLine),current,accelStr);
               curLine=vec.end(); curLine--;
               current->_colour=YACS::Black;
               if(idInCase>1)
                 {
                   idInCase-=2;
                   current=(*curLine)[idInCase];
                   (*curLine).pop_back();
                   (*curLine).pop_back();
                 }
               continue;
             }
           for(iter=CFDirectionVisTraits<direction>::getNexts(current).begin();iter!=CFDirectionVisTraits<direction>::getNexts(current).end();iter++)
             if(!(*iter).second)
               break;
           if(iter==CFDirectionVisTraits<direction>::getNexts(current).end())
             {//Fail this branch should be forgotten go rev
               current->_colour=YACS::Black;
               (*curLine).pop_back();
               if(idInCase>1)
                 {
                   idInCase-=2;
                   current=(*curLine)[idInCase];
                   (*curLine).pop_back();
                 }
             }
           else
             {
               //Nothing to signal continuing in this direction hoping to find
               current=(*iter).first->getNode();
               (*iter).second=true;
             }
         }
       vec.pop_back();
     }

void Bloc::findUselessLinksIn	(	const std::list< std::vector< Node * > > &	res,
		LinkInfo &	info
	)

staticprivate

Internal method : After all paths have been found, useless CF links are searched

Definition at line 858 of file Bloc.cxx.

References YACS::ENGINE::LinkInfo::pushUselessCFLink().

Referenced by findAllNodesStartingFrom().

 {
   unsigned maxSize=0;
   list< vector<Node *> >::const_iterator whereToPeerAt;
   for(list< vector<Node *> >::const_iterator iter=res.begin();iter!=res.end();iter++)
     if((*iter).size()>maxSize)
       {
         maxSize=(*iter).size();
         whereToPeerAt=iter;
       }
   //
   if(maxSize>1)
     {
       vector<Node *>::const_iterator iter2=(*whereToPeerAt).begin();
       map<Node *,bool>::iterator iter4;
       set<Node *> searcher(iter2+1,(*whereToPeerAt).end());//to boost research
       for(;iter2!=((*whereToPeerAt).end()-2);iter2++)
         {
           list< pair<InGate *,bool> >& nexts=(*iter2)->getOutGate()->edMapInGate();
           for(list< pair<InGate *,bool> >::iterator iter4=nexts.begin();iter4!=nexts.end();iter4++)
             if((*iter4).first->getNode()!=*(iter2+1))
               if(searcher.find((*iter4).first->getNode())!=searcher.end())
                 info.pushUselessCFLink(*iter2,(*iter4).first->getNode());
           searcher.erase(*iter2);
         }
     }
 }

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

virtual

Implements YACS::ENGINE::ComposedNode.

Definition at line 277 of file Bloc.cxx.

Referenced by YACS::HMI::GuiEditor::PutGraphInBloc(), and YACS::HMI::GuiEditor::PutGraphInNode().

 {
   for (list<Node *>::const_iterator iter = _setOfNode.begin(); iter != _setOfNode.end(); iter++)
     if ((*iter)->getName() == name)
       return (*iter);
   string what("node "); what+= name ; what+=" is not a child of Bloc "; what += getName();
   throw Exception(what);
 }

std::list<Node *> YACS::ENGINE::Bloc::getChildren ( ) const

inline

Definition at line 52 of file Bloc.hxx.

Referenced by YACS::ENGINE::ProcCataLoader::loadCata(), YACS::HMI::CommandPutInComposedNode::localExecute(), and writeDot().

52 { return _setOfNode; }

int Bloc::getMaxLevelOfParallelism ( ) const

virtual

Returns the max level of parallelism is this. The max of parallelism is equal to the sum of the max parallelism level for all concurrent branches in this.

Implements YACS::ENGINE::Node.

Definition at line 454 of file Bloc.cxx.

References YACS::ENGINE::SetOfPoints::getMaxLevelOfParallelism(), PMMLBasicsTestLauncher::ret, YACS::ENGINE::SetOfPoints::simplify(), and splitIntoIndependantGraph().

 {
   std::vector< std::list<Node *> > r(splitIntoIndependantGraph());
   int ret(0);
   for(std::vector< std::list<Node *> >::const_iterator it=r.begin();it!=r.end();it++)
     {
       SetOfPoints sop(*it);
       sop.simplify();
       ret+=sop.getMaxLevelOfParallelism();
     }
   return ret;
 }

int Bloc::getNumberOfCFLinks ( ) const

Definition at line 114 of file Bloc.cxx.

References _setOfNode, and PMMLBasicsTestLauncher::ret.

 {
   int ret=0;
   for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
     ret+=(*iter)->getOutGate()->getNbOfInGatesConnected();
   return ret;
 }

void Bloc::getReadyTasks ( std::vector< Task * > & tasks )

virtual

Collect all nodes that are ready to execute.

Parameters

tasks : vector of tasks to collect ready nodes

Implements YACS::ENGINE::Node.

Definition at line 131 of file Bloc.cxx.

References _setOfNode, YACS::ENGINE::Node::_state, YACS::ACTIVATED, YACS::ENGINE::Node::setState(), and YACS::TOACTIVATE.

 {
   /*
    * ComposedNode state goes to ACTIVATED when one of its child has been ACTIVATED
    * To change this uncomment the following line
    * Then the father node will go to ACTIVATED state before its child node
    */
   if(_state==YACS::TOACTIVATE ) setState(YACS::ACTIVATED);
   if(_state==YACS::TOACTIVATE || _state==YACS::ACTIVATED)
     for(list<Node *>::iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
       (*iter)->getReadyTasks(tasks);
 }

std::vector< std::pair< OutGate *, InGate * > > Bloc::getSetOfInternalCFLinks ( ) const

protected

Definition at line 348 of file Bloc.cxx.

References _setOfNode, and PMMLBasicsTestLauncher::ret.

Referenced by Bloc().

 {
   vector< pair<OutGate *, InGate *> > ret;
   for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
     {
       list<InGate *> outCFLinksOfCurNode=(*iter)->_outGate.edSetInGate();
       for(list<InGate *>::iterator iter2=outCFLinksOfCurNode.begin();iter2!=outCFLinksOfCurNode.end();iter2++)
         ret.push_back(pair<OutGate *, InGate *>(&(*iter)->_outGate,*iter2));
     }
   return ret;
 }

void Bloc::init ( bool start = true )

virtual

Initialize the bloc.

Parameters

start : a boolean flag indicating the kind of initialization If start is true, it's a complete initialization with reinitialization of port values If start is false, there is no initialization of port values

Reimplemented from YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::SalomeProc.

Definition at line 93 of file Bloc.cxx.

References _setOfNode, and YACS::ENGINE::Node::init().

Referenced by YACS::ENGINE::SalomeProc::init(), YACS::ENGINE::loadState(), and main().

 {
   Node::init(start);
   for(list<Node *>::iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
     (*iter)->init(start);
 }

void Bloc::initComputation ( ) const

protected

Definition at line 676 of file Bloc.cxx.

References _setOfNode, and YACS::White.

Referenced by findAllPathsStartingFrom(), and removeRecursivelyRedundantCL().

 {
   for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
     {
       (*iter)->_colour=White;
       (*iter)->getInGate()->exReset();
       (*iter)->getOutGate()->exReset();
     }
 }

bool Bloc::isFinished ( )

virtual

Indicate if the bloc execution is finished.

The execution bloc is finished if all its child nodes are finished with or without error or if it is disabled (not to execute)

Implements YACS::ENGINE::Scheduler.

Definition at line 105 of file Bloc.cxx.

References YACS::ENGINE::Node::_state, YACS::DISABLED, YACS::DONE, YACS::ERROR, and YACS::FAILED.

 {
     if(_state==YACS::DONE)return true;
     if(_state==YACS::ERROR)return true;
     if(_state==YACS::FAILED)return true;
     if(_state==YACS::DISABLED)return true;
     return false;
 }

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

protectedvirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 311 of file Bloc.cxx.

References _setOfNode.

 {
   for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
     if((*iter)->getName()==name)
       return true;
   return false;
 }

void Bloc::performCFComputations ( LinkInfo & info ) const

protectedvirtual

Updates mutable structures _fwLinks and _bwLinks with the result of computation (CPU consuming method). _fwLinks is a map with a Node* as key and a set<Node*> as value. The set gives all nodes that are forwardly connected to the key node _bwLinks is a map for backward dependencies The method is : for all CF link (n1->n2) add n2 and _fwLinks[n2] in forward dependencies of n1 and _bwLinks[n1] add n1 and _bwLinks[n1] in backward dependencies of n2 and _fwLinks[n2] For useless links If a node is already in a forward dependency when adding and the direct link already exists so it's a useless link (see the code !)

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 563 of file Bloc.cxx.

References YACS::ENGINE::ComposedNode::performCFComputations(), and performCFComputationsOnlyOneLevel().

 {
   StaticDefinedComposedNode::performCFComputations(info);
   performCFComputationsOnlyOneLevel(info);
 }

void Bloc::performCFComputationsOnlyOneLevel ( LinkInfo & info ) const

protected

Definition at line 479 of file Bloc.cxx.

References _bwLinks, _fwLinks, _setOfNode, YACS::ENGINE::OutGate::edSetInGate(), YACS::ENGINE::Node::getOutGate(), YACS::ENGINE::LinkInfo::pushUselessCFLink(), and PMMLBasicsTestLauncher::ret.

Referenced by performCFComputations(), and removeRecursivelyRedundantCL().

 {
   delete _fwLinks;//Normally useless
   delete _bwLinks;//Normally useless
   _fwLinks=new map<Node *,set<Node *> >;
   _bwLinks=new map<Node *,set<Node *> >;
 
   //a set to store all CF links : used to find fastly if two nodes are connected
   std::set< std::pair< Node*, Node* > > links;
 
   for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)
     {
       Node* n1=*iter;
       std::list<InGate *> ingates=n1->getOutGate()->edSetInGate();
       for(std::list<InGate *>::const_iterator it2=ingates.begin();it2!=ingates.end();it2++)
         {
           //CF link : n1 -> (*it2)->getNode()
           Node* n2=(*it2)->getNode();
           links.insert(std::pair< Node*, Node* >(n1,n2));
           std::set<Node *> bwn1=(*_bwLinks)[n1];
           std::set<Node *> fwn1=(*_fwLinks)[n1];
           std::set<Node *> fwn2=(*_fwLinks)[n2];
           std::set<Node *> bwn2=(*_bwLinks)[n2];
           std::pair<std::set<Node*>::iterator,bool> ret;
           for(std::set<Node *>::const_iterator iter2=bwn1.begin();iter2!=bwn1.end();iter2++)
             {
               for(std::set<Node *>::const_iterator it3=fwn2.begin();it3!=fwn2.end();it3++)
                 {
                   ret=(*_fwLinks)[*iter2].insert(*it3);
                   if(ret.second==false)
                     {
                       //dependency already exists (*iter2) -> (*it3) : if a direct link exists it's a useless one
                       if(links.find(std::pair< Node*, Node* >(*iter2,*it3)) != links.end())
                         info.pushUselessCFLink(*iter2,*it3);
                     }
                 }
               ret=(*_fwLinks)[*iter2].insert(n2);
               if(ret.second==false)
                 {
                   //dependency already exists (*iter2) -> n2 : if a direct link exists it's a useless one
                   if(links.find(std::pair< Node*, Node* >(*iter2,n2)) != links.end())
                     info.pushUselessCFLink(*iter2,n2);
                 }
             }
           for(std::set<Node *>::const_iterator it3=fwn2.begin();it3!=fwn2.end();it3++)
             {
               ret=(*_fwLinks)[n1].insert(*it3);
               if(ret.second==false)
                 {
                   //dependency already exists n1 -> *it3 : if a direct link exists it's a useless one
                   if(links.find(std::pair< Node*, Node* >(n1,*it3)) != links.end())
                     info.pushUselessCFLink(n1,*it3);
                 }
             }
           ret=(*_fwLinks)[n1].insert(n2);
           if(ret.second==false)
             {
               //dependency already exists n1 -> n2 : it's a useless link
               info.pushUselessCFLink(n1,n2);
             }
 
           for(std::set<Node *>::const_iterator iter2=fwn2.begin();iter2!=fwn2.end();iter2++)
             {
               (*_bwLinks)[*iter2].insert(bwn1.begin(),bwn1.end());
               (*_bwLinks)[*iter2].insert(n1);
             }
           (*_bwLinks)[n2].insert(bwn1.begin(),bwn1.end());
           (*_bwLinks)[n2].insert(n1);
         }
     }
 }

void Bloc::removeRecursivelyRedundantCL ( )

virtual

This method recursively all redundant control links in this.

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 467 of file Bloc.cxx.

References destructCFComputations(), YACS::ENGINE::ComposedNode::edRemoveCFLink(), YACS::ENGINE::LinkInfo::getInfoUselessLinks(), YACS::ENGINE::I_CF_USELESS, initComputation(), performCFComputationsOnlyOneLevel(), and YACS::ENGINE::ComposedNode::removeRecursivelyRedundantCL().

 {
   StaticDefinedComposedNode::removeRecursivelyRedundantCL();
   LinkInfo info(I_CF_USELESS);
   initComputation();
   performCFComputationsOnlyOneLevel(info);
   std::set< std::pair<Node *, Node *> > linksToKill(info.getInfoUselessLinks());
   for(std::set< std::pair<Node *, Node *> >::const_iterator it=linksToKill.begin();it!=linksToKill.end();it++)
     edRemoveCFLink((*it).first,(*it).second);
   destructCFComputations(info);
 }

void Bloc::seekOkAndUseless1	(	std::vector< Node * > &	okAndUseless1,
		std::set< Node * > &	allNodes
	)		const

protected

WARNING use this method only after having called Bloc::performCFComputations method.

Parameters

okAndUseless1	out param contains at the end, the nodes without any collapse.
allNodes	in/out param. At the end, all the nodes in 'okAndUseless1' are deleted from 'allNodes'.

Definition at line 791 of file Bloc.cxx.

Referenced by checkCFLinks().

 {
   set<Node *>::iterator iter=allNodes.begin();
   while(iter!=allNodes.end())
     {
       set<Node *>& whereToFind=(*_bwLinks)[*iter];
       std::set<Node *>::iterator iter2;
       for(iter2=allNodes.begin();iter2!=allNodes.end();iter2++)
         if((*iter)!=(*iter2))
           if(whereToFind.find(*iter2)==whereToFind.end())
             break;
       if(iter2!=allNodes.end())
         iter++;
       else
         {
           okAndUseless1.push_back((*iter));
           allNodes.erase(iter);
           iter=allNodes.begin();
         }
     }
 }

void Bloc::seekUseless2	(	std::vector< Node * > &	useless2,
		std::set< Node * > &	allNodes
	)		const

protected

WARNING use this method only after having called Bloc::performCFComputations method. For params see Bloc::seekOkAndUseless1.

Definition at line 817 of file Bloc.cxx.

Referenced by checkCFLinks().

 {
   set<Node *>::iterator iter=allNodes.begin();
   while(iter!=allNodes.end())
     {
       set<Node *>& whereToFind=(*_fwLinks)[*iter];
       std::set<Node *>::iterator iter2;
       for(iter2=allNodes.begin();iter2!=allNodes.end();iter2++)
         if((*iter)!=(*iter2))
           if(whereToFind.find(*iter2)==whereToFind.end())
             break;
       if(iter2!=allNodes.end())
         {
           iter++;
         }
       else
         {
           useless2.push_back((*iter));
           allNodes.erase(iter);
           iter=allNodes.begin();
         }
     }
 }

Node * Bloc::simpleClone	(	ComposedNode *	father,
		bool	editionOnly = `true`
	)		const

protectedvirtual

Implements YACS::ENGINE::Node.

Definition at line 122 of file Bloc.cxx.

References Bloc().

 {
   return new Bloc(*this,father,editionOnly);
 }

std::vector< std::list< Node * > > Bloc::splitIntoIndependantGraph ( ) const

Definition at line 229 of file Bloc.cxx.

References YACS::ENGINE::Node::_colour, _setOfNode, YACS::Grey, PMMLBasicsTestLauncher::ret, and YACS::White.

Referenced by getMaxLevelOfParallelism().

 {
   std::size_t sz(_setOfNode.size());
   list<Node *>::const_iterator it=_setOfNode.begin();
   for(;it!=_setOfNode.end();it++)
     (*it)->_colour=White;
   it=_setOfNode.begin();
   std::vector< list<Node *> > ret;
   while(it!=_setOfNode.end())
     {
       Node *start(*it); start->_colour=Grey;
       ret.push_back(list<Node *>());
       list<Node *>& ll(ret.back());
       std::queue<Node *> fifo; fifo.push(start);
       while(!fifo.empty())
         {
           Node *cur(fifo.front()); fifo.pop();
           ll.push_back(cur);
           //
           OutGate *og(cur->getOutGate());
           list<InGate *> og2(og->edSetInGate());
           for(list<InGate *>::const_iterator it2=og2.begin();it2!=og2.end();it2++)
             {
               Node *cur2((*it2)->getNode());
               if(cur2->_colour==White)
                 {
                   cur2->_colour=Grey;
                   fifo.push(cur2);
                 }
             }
           //
           InGate *ig(cur->getInGate());
           list<OutGate *> bl(ig->getBackLinks());
           for(list<OutGate *>::const_iterator it3=bl.begin();it3!=bl.end();it3++)
             {
               Node *cur3((*it3)->getNode());
               if(cur3->_colour==White)
                 {
                   cur3->_colour=Grey;
                   fifo.push(cur3);
                 }
             }
         }
       for(it=_setOfNode.begin();it!=_setOfNode.end() && (*it)->_colour!=White;it++);
     }
   return ret;
 }

virtual std::string YACS::ENGINE::Bloc::typeName ( )

inlinevirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::Proc, and YACS::ENGINE::SalomeProc.

Definition at line 62 of file Bloc.hxx.

62 { return "YACS__ENGINE__Bloc"; }

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

protectedvirtual

Notify this bloc that a node has failed.

Parameters

node	: node that has emitted the event

Returns: the event to notify to bloc's father

Reimplemented from YACS::ENGINE::ComposedNode.

Definition at line 406 of file Bloc.cxx.

References YACS::ABORT, areAllSubNodesDone(), areAllSubNodesFinished(), YACS::DONE, YACS::ENGINE::Node::exForwardFailed(), YACS::FAILED, YACS::FINISH, YACS::NOEVENT, and YACS::ENGINE::Node::setState().

 {
   node->exForwardFailed();
   if(areAllSubNodesFinished())
     {
       setState(YACS::DONE);
       if(!areAllSubNodesDone()){
           setState(YACS::FAILED);
           return YACS::ABORT;
       }
       return YACS::FINISH;//notify to father node that 'this' has becomed finished.
     }
   return YACS::NOEVENT;
 }

YACS::Event Bloc::updateStateOnFinishedEventFrom ( Node * node )

protectedvirtual

Note: : Runtime called method. Indirectly called by StaticDefinedComposedNode::updateStateFrom which has dispatch to this method 'when event == FINISH'. WARNING Precondition : '_state == Running' and 'node->_father==this'(garanteed by StaticDefinedComposedNode::notifyFrom)

Calls the node's outgate OutGate::exNotifyDone if all nodes are not finished

Implements YACS::ENGINE::ComposedNode.

Definition at line 368 of file Bloc.cxx.

References YACS::ABORT, areAllSubNodesDone(), areAllSubNodesFinished(), DEBTRACE, YACS::DONE, YACS::ENGINE::Node::exForwardFailed(), YACS::ENGINE::Node::exForwardFinished(), YACS::FAILED, YACS::FINISH, YACS::ENGINE::Node::getName(), YACS::NOEVENT, YACS::ENGINE::Node::setState(), and YACS::Exception::what().

 {
   DEBTRACE("Bloc::updateStateOnFinishedEventFrom: " << node->getName());
   //ASSERT(node->_father==this)
   if(areAllSubNodesFinished())
     {
       setState(YACS::DONE);
       if(!areAllSubNodesDone())
         {
           setState(YACS::FAILED);
           return YACS::ABORT;
         }
       return YACS::FINISH;//notify to father node that 'this' has becomed finished.
     }
   //more job to do in 'this' bloc
   //Conversion exceptions can be thrown so catch them to control errors
   try
     {
       //notify the finished node to propagate to its following nodes
       node->exForwardFinished();
     }
   catch(YACS::Exception& ex)
     {
       //The node has failed to propagate. It must be put in error
       DEBTRACE("Bloc::updateStateOnFinishedEventFrom: " << ex.what());
       // notify the node it has failed
       node->exForwardFailed();
       setState(YACS::FAILED);
       return YACS::ABORT;
     }
   return YACS::NOEVENT;//no notification to father needed because from father point of view nothing happened.
 }

void Bloc::updateWithNewFind	(	const std::vector< Node * > &	path,
		std::map< Node , std::set< Node > > &	fastFinder
	)

staticprivate

Internal method : Given a succeful path : updates 'fastFinder'

Definition at line 844 of file Bloc.cxx.

Referenced by appendIfAlreadyFound(), and findAllPathsStartingFrom().

 {
   if(path.size()>=3)
     {
       vector<Node *>::const_iterator iter=path.begin(); iter++;
       vector<Node *>::const_iterator iter2=path.end(); iter2-=1;
       for(;iter!=iter2;iter++)
         fastFinder[*iter].insert(*(iter+1));
     }
 }

void Bloc::verdictForCollapses	(	const std::map< Node , std::list< OutPort > > &	pool,
		InputPort *	end,
		const std::set< Node * > &	candidates,
		unsigned char &	alreadyFed,
		bool	direction,
		LinkInfo &	info
	)

staticprotected

Part of final step for CF graph anylizing. This is the part of collapses nodes.

Parameters

pool	:
end	:
candidates	:
alreadyFed	in/out parameter. Indicates if 'end' ports is already and surely set or fed by an another port.
direction
info	: collected information

Definition at line 740 of file Bloc.cxx.

References checkCFLinks(), YACS::ENGINE::LinkInfo::endCollapseTransac(), YACS::ENGINE::ComposedNode::FED_ST, YACS::ENGINE::ComposedNode::FREE_ST, YACS::ENGINE::LinkInfo::pushWarnLink(), YACS::ENGINE::LinkInfo::startCollapseTransac(), YACS::ENGINE::W_BACK_COLLAPSE, YACS::ENGINE::W_BACK_COLLAPSE_AND_USELESS, YACS::ENGINE::W_BACK_COLLAPSE_EL, YACS::ENGINE::W_BACK_COLLAPSE_EL_AND_USELESS, YACS::ENGINE::W_COLLAPSE, YACS::ENGINE::W_COLLAPSE_AND_USELESS, YACS::ENGINE::W_COLLAPSE_EL, and YACS::ENGINE::W_COLLAPSE_EL_AND_USELESS.

Referenced by checkCFLinks().

 {
   info.startCollapseTransac();
   for(set<Node *>::const_iterator iter=candidates.begin();iter!=candidates.end();iter++)
     {
       const list<OutPort *>& mySet=(*pool.find(*iter)).second;
       if(mySet.size()==1)
         {
           if(alreadyFed==FREE_ST)
             info.pushWarnLink(*(mySet.begin()),end,direction ? W_COLLAPSE : W_BACK_COLLAPSE);
           else if(alreadyFed==FED_ST)
             info.pushWarnLink(*(mySet.begin()),end,direction ? W_COLLAPSE_AND_USELESS : W_BACK_COLLAPSE_EL_AND_USELESS);
         }
       else
         {
           if(dynamic_cast<ElementaryNode *>(*iter))
             {
               WarnReason reason;
               if(alreadyFed==FREE_ST)
                 reason=direction ? W_COLLAPSE_EL : W_BACK_COLLAPSE_EL;
               else if(alreadyFed==FED_ST)
                 reason=direction ? W_COLLAPSE_EL_AND_USELESS : W_BACK_COLLAPSE_EL_AND_USELESS;
               for(list<OutPort *>::const_iterator iter2=mySet.begin();iter2!=mySet.end();iter2++)    
                 info.pushWarnLink(*iter2,end,reason);
             }
           else
             {
               ((ComposedNode *)(*iter))->checkCFLinks(mySet,end,alreadyFed,direction,info);//Thanks to recursive model!
               WarnReason reason;
               if(alreadyFed==FREE_ST)
                 reason=direction ? W_COLLAPSE : W_BACK_COLLAPSE;
               else if(alreadyFed==FED_ST)
                 reason=direction ? W_COLLAPSE_AND_USELESS : W_BACK_COLLAPSE_AND_USELESS;
               for(list<OutPort *>::const_iterator iter2=mySet.begin();iter2!=mySet.end();iter2++)    
                 info.pushWarnLink(*iter2,end,reason);
             }
         }
     }
   if(!candidates.empty())
     if(alreadyFed==FREE_ST)
       alreadyFed=FED_ST;
   info.endCollapseTransac();
 }

void Bloc::verdictForOkAndUseless1	(	const std::map< Node , std::list< OutPort > > &	pool,
		InputPort *	end,
		const std::vector< Node * > &	candidates,
		unsigned char &	alreadyFed,
		bool	direction,
		LinkInfo &	info
	)

staticprotected

Part of final step for CF graph anylizing. This is the part of non collapse nodes.

Parameters

pool	:
end	:
candidates	:
alreadyFed	in/out parameter. Indicates if 'end' ports is already and surely set or fed by an another port.
direction
info	: collected information

Definition at line 695 of file Bloc.cxx.

References YACS::ENGINE::ComposedNode::FED_ST, YACS::ENGINE::ComposedNode::FREE_ST, YACS::ENGINE::I_BACK, YACS::ENGINE::I_BACK_USELESS, YACS::ENGINE::I_USELESS, YACS::ENGINE::LinkInfo::pushInfoLink(), YACS::ENGINE::LinkInfo::pushWarnLink(), YACS::ENGINE::W_BACK_COLLAPSE_EL, YACS::ENGINE::W_BACK_COLLAPSE_EL_AND_USELESS, YACS::ENGINE::W_COLLAPSE_EL, and YACS::ENGINE::W_COLLAPSE_EL_AND_USELESS.

Referenced by checkCFLinks().

 {
   for(vector<Node *>::const_iterator iter=candidates.begin();iter!=candidates.end();iter++)
     {
       const list<OutPort *>& mySet=(*pool.find(*iter)).second;
       if(mySet.size()==1)
         {
           if(alreadyFed==FREE_ST)
             {
               alreadyFed=FED_ST;//This the final choice. General case !
               if(!direction)
                 info.pushInfoLink(*(mySet.begin()),end,I_BACK);
             }
           else if(alreadyFed==FED_ST)
               info.pushInfoLink(*(mySet.begin()),end,direction ? I_USELESS : I_BACK_USELESS);//Second or more turn in case of alreadyFed==FREE_ST before call of this method
         }
       else
         {
           if(dynamic_cast<ElementaryNode *>(*iter))
             {
               WarnReason reason;
               if(alreadyFed==FREE_ST)
                 reason=direction ? W_COLLAPSE_EL : W_BACK_COLLAPSE_EL;
               else if(alreadyFed==FED_ST)
                 reason=direction ? W_COLLAPSE_EL_AND_USELESS : W_BACK_COLLAPSE_EL_AND_USELESS;
               for(list<OutPort *>::const_iterator iter2=mySet.begin();iter2!=mySet.end();iter2++)    
                 info.pushWarnLink(*iter2,end,reason);
             }
           else
             ((ComposedNode *)(*iter))->checkCFLinks(mySet,end,alreadyFed,direction,info);//Thanks to recursive model!
         }
     }
 }

void Bloc::writeDot ( std::ostream & os ) const

virtual

Dump to the input stream a dot representation of the node.

Parameters

os	: the input stream

Reimplemented from YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::Proc.

Definition at line 421 of file Bloc.cxx.

References getChildren(), YACS::ENGINE::Node::getColorState(), YACS::ENGINE::Node::getEffectiveState(), YACS::ENGINE::Node::getId(), YACS::ENGINE::Node::getQualifiedName(), p, and CORBAEngineTest::state.

Referenced by YACS::ENGINE::Proc::writeDot().

 {
   os << "  subgraph cluster_" << getId() << "  {\n" ;
   list<Node *>nodes=getChildren();
   for(list<Node *>::const_iterator iter=nodes.begin();iter!=nodes.end();iter++)
     {
       (*iter)->writeDot(os);
       string p=(*iter)->getId();
       //not connected node
       if((*iter)->_inGate._backLinks.size() == 0) os << getId() << " -> " << p << ";\n";
       list<Node *>outnodes = (*iter)->getOutNodes();
       for(list<Node *>::const_iterator itout=outnodes.begin();itout!=outnodes.end();itout++)
         {
           os << p << " -> " << (*itout)->getId() << ";\n";
         }
     }
   os << "}\n" ;
   os << getId() << "[fillcolor=\"" ;
   YACS::StatesForNode state=getEffectiveState();
   os << getColorState(state);
   os << "\" label=\"" << "Bloc:" ;
   os << getQualifiedName() <<"\"];\n";
 }

Member Data Documentation

std::map<Node *,std::set<Node *> >* YACS::ENGINE::Bloc::_bwLinks

mutableprotected

For internal calculations.

Definition at line 37 of file Bloc.hxx.

Referenced by destructCFComputations(), performCFComputationsOnlyOneLevel(), and ~Bloc().

std::map<Node *,std::set<Node *> >* YACS::ENGINE::Bloc::_fwLinks

mutableprotected

For internal calculations.

Definition at line 35 of file Bloc.hxx.

Referenced by destructCFComputations(), performCFComputationsOnlyOneLevel(), and ~Bloc().

std::list<Node *> YACS::ENGINE::Bloc::_setOfNode

protected

Definition at line 33 of file Bloc.hxx.

Referenced by areAllSubNodesDone(), areAllSubNodesFinished(), Bloc(), exUpdateState(), getNumberOfCFLinks(), getReadyTasks(), getSetOfInternalCFLinks(), init(), initComputation(), isNameAlreadyUsed(), performCFComputationsOnlyOneLevel(), splitIntoIndependantGraph(), and ~Bloc().

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

src/engine/Bloc.hxx
src/engine/Bloc.cxx

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation