src/engine/DynParaLoop.cxx

   1 // Copyright (C) 2006-2015  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "DynParaLoop.hxx"
  21 #include "LinkInfo.hxx"
  22 #include "OutPort.hxx"
  23 #include "Container.hxx"
  24 #include "ComponentInstance.hxx"
  25 #include "ServiceNode.hxx"
  26 #include "InlineNode.hxx"
  27 #include "ElementaryNode.hxx"
  28 #include "Visitor.hxx"
  29
  30 #include <list>
  31 #include <vector>
  32
  33 //#define _DEVDEBUG_
  34 #include "YacsTrace.hxx"
  35
  36 using namespace std;
  37 using namespace YACS::ENGINE;
  38
  39 const char DynParaLoop::NAME_OF_SPLITTED_SEQ_OUT[] = "evalSamples";
  40 const char DynParaLoop::OLD_NAME_OF_SPLITTED_SEQ_OUT[] = "SmplPrt"; // For backward compatibility with 5.1.4
  41
  42 const char DynParaLoop::NAME_OF_NUMBER_OF_BRANCHES[]="nbBranches";
  43
  44 DynParaLoop::DynParaLoop(const std::string& name, TypeCode *typeOfDataSplitted)
  45   : ComposedNode(name),_node(0),_initNode(0),_finalizeNode(0),_nbOfEltConsumed(0),
  46     _nbOfBranches(NAME_OF_NUMBER_OF_BRANCHES,this,Runtime::_tc_int),
  47     _splittedPort(NAME_OF_SPLITTED_SEQ_OUT,this,typeOfDataSplitted),_initializingCounter(0),_unfinishedCounter(0),_failedCounter(0)
  48 {
  49 }
  50
  51 DynParaLoop::~DynParaLoop()
  52 {
  53   delete _node;
  54   delete _initNode;
  55   delete _finalizeNode;
  56 }
  57
  58 DynParaLoop::DynParaLoop(const DynParaLoop& other, ComposedNode *father, bool editionOnly)
  59   : ComposedNode(other,father), _nbOfBranches(other._nbOfBranches,this),
  60     _splittedPort(other._splittedPort,this), _node(0), _initNode(0), _finalizeNode(0),
  61     _nbOfEltConsumed(0),_initializingCounter(0),_unfinishedCounter(0),_failedCounter(0)
  62 {
  63   if(other._node)
  64     _node=other._node->clone(this,editionOnly);
  65   if(other._initNode)
  66     _initNode=other._initNode->clone(this,editionOnly);
  67   if(other._finalizeNode)
  68     _finalizeNode = other._finalizeNode->clone(this,editionOnly);
  69   const AnyOutputPort& startOfLinksToReproduce=other._splittedPort;
  70   set<InPort *> endsOfLinksToReproduce=startOfLinksToReproduce.edSetInPort();
  71   for(set<InPort *>::iterator iter=endsOfLinksToReproduce.begin();iter!=endsOfLinksToReproduce.end();iter++)
  72     edAddLink(&_splittedPort,getInPort(other.getPortName(*iter)));
  73 }
  74
  75 Node *DynParaLoop::edSetNode(Node *node)
  76 {
  77   return checkConsistencyAndSetNode(_node, node);
  78 }
  79
  80 //! This method is used to factorize methods edSetNode, edSetInitNode and edSetFinalizeNode
  81 Node * DynParaLoop::checkConsistencyAndSetNode(Node* &nodeToReplace, Node* node)
  82 {
  83   if (node == NULL || nodeToReplace == node)
  84     return 0;
  85   if (node->_father)
  86     throw Exception(string("Can't set node: node ") + node->getName() + " is not orphan.");
  87   if (_node && _node != nodeToReplace && _node->getName() == node->getName())
  88     throw Exception(string("Can't set node: node ") + node->getName() +
  89                     " has the same name than exec node already in " + _name + ".");
  90   if (_initNode && _initNode != nodeToReplace && _initNode->getName() == node->getName())
  91     throw Exception(string("Can't set node: node ") + node->getName() +
  92                     " has the same name than init node already in " + _name + ".");
  93   if (_finalizeNode && _finalizeNode != nodeToReplace && _finalizeNode->getName() == node->getName())
  94     throw Exception(string("Can't set node: node ") + node->getName() +
  95                     " has the same name than finalize node already in " + _name + ".");
  96   checkNoCrossHierachyWith(node);
  97   ComposedNode::edRemoveChild(nodeToReplace);
  98   Node * ret = nodeToReplace;
  99   nodeToReplace = node;
 100   nodeToReplace->_father = this;
 101   // set _modified flag so that edUpdateState can refresh state
 102   modified();
 103   return ret;
 104 }
 105
 106 void DynParaLoop::init(bool start)
 107 {
 108   ComposedNode::init(start);
 109   if(!_node)
 110     {
 111       string what("DynParaLoop::init : no node specified for ForEachLoop with name "); what +=_name;
 112       throw Exception(what);
 113     }
 114   _node->init(start);
 115   if (_initNode) _initNode->init(start);
 116   if (_finalizeNode) _finalizeNode->init(start);
 117   _nbOfBranches.exInit(start);
 118   _splittedPort.exInit();
 119   _nbOfEltConsumed=0;
 120   _failedCounter=0;
 121 }
 122
 123 Node *DynParaLoop::edSetInitNode(Node *node)
 124 {
 125   return checkConsistencyAndSetNode(_initNode, node);
 126 }
 127
 128 Node * DynParaLoop::edSetFinalizeNode(Node * node)
 129 {
 130   return checkConsistencyAndSetNode(_finalizeNode, node);
 131 }
 132
 133 //! Connect an OutPort to an InPort and add control link if necessary
 134 /*!
 135  * Connect the ports with a data link (edAddLink)
 136  * In a Loop don't add control flow link : use this only to add data back links
 137  *
 138  * \param start : the OutPort to connect
 139  * \param end : the InPort to connect
 140  * \return  true if a new link has been created, false otherwise.
 141  */
 142 bool DynParaLoop::edAddDFLink(OutPort *start, InPort *end) throw(YACS::Exception)
 143 {
 144   return edAddLink(start,end);
 145 }
 146
 147 int DynParaLoop::getNumberOfInputPorts() const
 148 {
 149   return ComposedNode::getNumberOfInputPorts()+1;
 150 }
 151
 152 int DynParaLoop::getNumberOfOutputPorts() const
 153 {
 154   return ComposedNode::getNumberOfOutputPorts()+1;
 155 }
 156
 157 std::list<OutputPort *> DynParaLoop::getSetOfOutputPort() const
 158 {
 159   list<OutputPort *> ret=ComposedNode::getSetOfOutputPort();
 160   ret.push_back((OutputPort *)&_splittedPort);
 161   return ret;
 162 }
 163
 164 std::list<OutputPort *> DynParaLoop::getLocalOutputPorts() const
 165 {
 166   list<OutputPort *> ret=ComposedNode::getLocalOutputPorts();
 167   ret.push_back((OutputPort *)&_splittedPort);
 168   return ret;
 169 }
 170
 171 OutPort *DynParaLoop::getOutPort(const std::string& name) const throw(YACS::Exception)
 172 {
 173   if (name == NAME_OF_SPLITTED_SEQ_OUT || name == OLD_NAME_OF_SPLITTED_SEQ_OUT)
 174     return (OutPort *)&_splittedPort;
 175   return ComposedNode::getOutPort(name);
 176 }
 177
 178
 179 OutputPort *DynParaLoop::getOutputPort(const std::string& name) const throw(YACS::Exception)
 180 {
 181   if (name == NAME_OF_SPLITTED_SEQ_OUT || name == OLD_NAME_OF_SPLITTED_SEQ_OUT)
 182     return (OutputPort *)&_splittedPort;
 183   return ComposedNode::getOutputPort(name);
 184 }
 185
 186 bool DynParaLoop::isPlacementPredictableB4Run() const
 187 {
 188   return false;
 189 }
 190
 191 Node *DynParaLoop::edRemoveNode()
 192 {
 193   return removeNode(_node);
 194 }
 195
 196 //! This method is used to factorize methods edRemoveNode, edRemoveInitNode and edRemoveFinalizeNode
 197 Node * DynParaLoop::removeNode(Node* &nodeToRemove)
 198 {
 199   if (!nodeToRemove)
 200     return NULL;
 201   ComposedNode::edRemoveChild(nodeToRemove);
 202   Node * ret = nodeToRemove;
 203   nodeToRemove = NULL;
 204   modified();
 205   return ret;
 206 }
 207
 208 Node *DynParaLoop::edRemoveInitNode()
 209 {
 210   return removeNode(_initNode);
 211 }
 212
 213 Node * DynParaLoop::edRemoveFinalizeNode()
 214 {
 215   return removeNode(_finalizeNode);
 216 }
 217
 218 void DynParaLoop::edRemoveChild(Node *node) throw(YACS::Exception)
 219 {
 220   ComposedNode::edRemoveChild(node);
 221   if(node==_node)
 222     _node=0;
 223   if(node==_initNode)
 224     _initNode=0;
 225   if(node==_finalizeNode)
 226     _finalizeNode=0;
 227   modified();
 228 }
 229
 230 bool DynParaLoop::edAddChild(Node *DISOWNnode) throw(YACS::Exception)
 231 {
 232   return edSetNode(DISOWNnode);
 233 }
 234
 235 std::list<Node *> DynParaLoop::edGetDirectDescendants() const
 236 {
 237   list<Node *> ret;
 238   if(_node)
 239     ret.push_back(_node);
 240   if(_initNode)
 241     ret.push_back(_initNode);
 242   if(_finalizeNode)
 243     ret.push_back(_finalizeNode);
 244   return ret;
 245 }
 246
 247 std::list<InputPort *> DynParaLoop::getSetOfInputPort() const
 248 {
 249   list<InputPort *> ret=ComposedNode::getSetOfInputPort();
 250   ret.push_back((InputPort *)&_nbOfBranches);
 251   return ret;
 252 }
 253
 254 InputPort *DynParaLoop::getInputPort(const std::string& name) const throw(YACS::Exception)
 255 {
 256   if(name==NAME_OF_NUMBER_OF_BRANCHES)
 257     return (InputPort *)&_nbOfBranches;
 258   return ComposedNode::getInputPort(name);
 259 }
 260
 261 std::list<InputPort *> DynParaLoop::getLocalInputPorts() const
 262 {
 263   list<InputPort *> ret=ComposedNode::getLocalInputPorts();
 264   ret.push_back((InputPort *)&_nbOfBranches);
 265   return ret;
 266 }
 267
 268 unsigned DynParaLoop::getNumberOfBranchesCreatedDyn() const throw(YACS::Exception)
 269 {
 270   if(_execNodes.empty())
 271     throw Exception("ForEachLoop::getNumberOfBranches : No branches created dynamically ! - ForEachLoop needs to run or to be runned to call getNumberOfBranches");
 272   else
 273     return _execNodes.size();
 274 }
 275
 276 Node *DynParaLoop::getChildByShortName(const std::string& name) const throw(YACS::Exception)
 277 {
 278   if (_node && name == _node->getName())
 279     return _node;
 280   if (_initNode && name == _initNode->getName())
 281     return  _initNode;
 282   if (_finalizeNode && name == _finalizeNode->getName())
 283     return  _finalizeNode;
 284   std::string what("node "); what+= name ; what+=" is not a child of DynParaLoop node "; what += getName();
 285   throw Exception(what);
 286 }
 287
 288 Node *DynParaLoop::getChildByNameExec(const std::string& name, unsigned id) const throw(YACS::Exception)
 289 {
 290   if(id>=getNumberOfBranchesCreatedDyn())
 291     throw Exception("ForEachLoop::getChildByNameExec : invalid id - too large compared with dynamically created branches.");
 292   if (_node && name == _node->getName())
 293     return _execNodes[id];
 294   if (_initNode && name == _initNode->getName())
 295     return _execInitNodes[id];
 296   if (_finalizeNode && name == _finalizeNode->getName())
 297     return _execFinalizeNodes[id];
 298   std::string what("node "); what+= name ; what+=" is not a child of DynParaLoop node "; what += getName();
 299   throw Exception(what);
 300 }
 301
 302 void DynParaLoop::cleanDynGraph()
 303 {
 304   vector<Node *>::iterator iter;
 305   for(iter=_execNodes.begin() ; iter!=_execNodes.end() ; iter++)
 306     delete *iter;
 307   _execNodes.clear();
 308   for(iter=_execInitNodes.begin() ; iter!=_execInitNodes.end() ; iter++)
 309     delete *iter;
 310   _execInitNodes.clear();
 311   for(iter=_execFinalizeNodes.begin() ; iter!=_execFinalizeNodes.end() ; iter++)
 312     delete *iter;
 313   _execFinalizeNodes.clear();
 314 }
 315
 316 /*!
 317  * This method applies on newly cloned on exec nodes (_execNodes/_execInitNodes)
 318  * the setting of input ports coming from outside of 'this'
 319  */
 320 void DynParaLoop::prepareInputsFromOutOfScope(int branchNb)
 321 {
 322   set< InPort * > portsToSetVals=getAllInPortsComingFromOutsideOfCurrentScope();
 323
 324   // This tweak is to fix problems with nested dynamic loops where links are not cloned properly
 325   list<InPort *> temp = getSetOfInPort();
 326   for(list<InPort *>::iterator iter2=temp.begin();iter2!=temp.end();iter2++)
 327     {
 328       if ((*iter2)->edSetOutPort().size() == 1 && *(*iter2)->edSetOutPort().begin() == NULL)
 329         {
 330           portsToSetVals.insert(*iter2);
 331         }
 332     }
 333
 334   // local input ports are not candidates for dynamically duplicated inport.
 335   list<InputPort *> localPorts = getLocalInputPorts();
 336   for(list<InputPort *>::iterator iter = localPorts.begin() ; iter != localPorts.end() ; iter++)
 337     portsToSetVals.erase(*iter);
 338   for(set< InPort * >::iterator iter=portsToSetVals.begin();iter!=portsToSetVals.end();iter++)
 339     {
 340       InputPort *curPortCasted=(InputPort *) *iter;//Cast granted by ForEachLoop::buildDelegateOf(InPort)
 341       void *val=curPortCasted->get();
 342       InputPort *portToSet=getDynInputPortByAbsName(branchNb,getInPortName(*iter),true);
 343       if(portToSet)//portToSet==0 in case of portToSet==_splitterNode._dataPortToDispatch of ForEach
 344         {
 345           portToSet->put((const void *)val);
 346           portToSet->edNotifyReferencedBy(0);//This is to indicate that somewhere somebody deals with this inputport
 347           //even if no direct physical link exists. This exclusively for _execNodes[branchNb]::init on the next turn of loop.
 348         }
 349     }
 350 }
 351
 352 void DynParaLoop::putValueOnBranch(Any *val, unsigned branchId, bool first)
 353 {
 354   bool isDispatched = false;
 355   set<InPort *> inPrtLkdWthSplttdPrt=_splittedPort.edSetInPort();
 356   for(set<InPort *>::iterator iter=inPrtLkdWthSplttdPrt.begin();iter!=inPrtLkdWthSplttdPrt.end();iter++)
 357     {
 358       std::string portNameOnCurPrt=getPortName(*iter);
 359       InputPort *portOnGivenBranch=getDynInputPortByAbsName(branchId,portNameOnCurPrt,first);//Cast granted because impossible to have cross protocol with _splittedPort
 360       //see OptimizerLoop::buildDelegateOf
 361       if(portOnGivenBranch)
 362         {
 363           if(first)
 364             portOnGivenBranch->edNotifyReferencedBy(0);
 365           InputPort *traducer=getRuntime()->adapt(portOnGivenBranch,
 366                                                   Runtime::RUNTIME_ENGINE_INTERACTION_IMPL_NAME,_splittedPort.edGetType());
 367           traducer->put((const void *)val);
 368           isDispatched = true;
 369           if(traducer!=portOnGivenBranch)
 370             delete traducer;
 371         }
 372     }
 373   if ( isDispatched )
 374     {
 375       Any *tmp=val->clone();
 376       _splittedPort.setValue(tmp);
 377       tmp->decrRef();
 378     }
 379 }
 380
 381 DynParaLoop::TypeOfNode DynParaLoop::getIdentityOfNotifyerNode(const Node *node, unsigned& id)
 382 {
 383   vector<Node *>::iterator iter;
 384   id=0;
 385   for (iter=_execNodes.begin() ; iter!=_execNodes.end() ; iter++,id++)
 386     if (*iter==node)
 387       return WORK_NODE;
 388   id=0;
 389   for (iter=_execInitNodes.begin() ; iter!=_execInitNodes.end() ; iter++,id++)
 390     if (*iter==node)
 391       return INIT_NODE;
 392   id=0;
 393   for (iter=_execFinalizeNodes.begin() ; iter!=_execFinalizeNodes.end() ; iter++,id++)
 394     if (*iter==node)
 395       return FINALIZE_NODE;
 396 }
 397
 398 bool DynParaLoop::isMultiplicitySpecified(unsigned& value) const
 399 {
 400   if(_nbOfBranches.edIsManuallyInitialized())
 401     if(_nbOfBranches.edGetNumberOfLinks()==0)
 402       {
 403         value=_nbOfBranches.getIntValue();
 404         return true;
 405       }
 406   return false;
 407 }
 408
 409 void DynParaLoop::forceMultiplicity(unsigned value)
 410 {
 411   _nbOfBranches.edRemoveAllLinksLinkedWithMe();
 412   _nbOfBranches.edInit((int)value);
 413 }
 414
 415 void DynParaLoop::buildDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView)
 416 {
 417   string typeOfPortInstance=port->getNameOfTypeOfCurrentInstance();
 418   if(typeOfPortInstance!=InputPort::NAME)
 419     throw Exception("DynParaLoop::buildDelegateOf : A link with datastream end inside DynParaLoop this is not possible");
 420 }
 421
 422 void DynParaLoop::buildDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView)
 423 {
 424   if(_initNode)
 425     if(isInMyDescendance(port.first->getNode())==_initNode)
 426       throw Exception("DynParaLoop::buildDelegateOf : uncorrect ForEach link : a link starting from init node can't leave the scope of ForEachLoop node it belongs to.");
 427   if(port.first==&_splittedPort)
 428     throw Exception("DynParaLoop::buildDelegateOf : uncorrect ForEach link : splitted port must be link within the scope of ForEachLoop node it belongs to.");
 429 }
 430
 431 void DynParaLoop::checkCFLinks(const std::list<OutPort *>& starts, InputPort *end, unsigned char& alreadyFed, bool direction, LinkInfo& info) const
 432 {
 433   const char what[]="DynParaLoop::checkCFLinks : internal error.";
 434   //First dealing checkCFLinks forwarding...
 435   if(isInMyDescendance(end->getNode())==0)//no chance that _splittedPort is in starts due to buildDelegate.
 436     solveObviousOrDelegateCFLinks(starts,end,alreadyFed,direction,info);
 437   else
 438     {//no forwarding here.
 439       if(starts.size()!=1)
 440         throw Exception(what);
 441       //ASSERT(direction) : see DynParaLoop::checkControlDependancy only 'fw' filled.
 442       if(*(starts.begin())!=&_splittedPort)
 443         throw Exception(what);
 444       if(alreadyFed==FREE_ST)
 445         alreadyFed=FED_ST;
 446       else if(alreadyFed==FED_ST)
 447         {//Shame ! splittedPort fills a port already fed...
 448           info.pushInfoLink(*(starts.begin()),end,I_USELESS);
 449         }
 450     }
 451 }
 452
 453 /*!
 454  * \param start : start port
 455  * \param end : end port
 456  * \param cross indicates if start -> end link is a DS link behind.
 457  * \param fw out parameter.
 458  * \param fwCross out parameter storing links where a cross has been detected.
 459  * \param bw out parameter where backward links are stored.
 460  * \param info : collected information
 461  */
 462 void DynParaLoop::checkControlDependancy(OutPort *start, InPort *end, bool cross,
 463                                          std::map < ComposedNode *,  std::list < OutPort * >, SortHierarc >& fw,
 464                                          std::vector<OutPort *>& fwCross,
 465                                          std::map< ComposedNode *, std::list < OutPort *>, SortHierarc >& bw,
 466                                          LinkInfo& info) const
 467 {
 468   if(start==&_splittedPort)
 469     fw[(ComposedNode *)this].push_back(start);
 470   else
 471     throw Exception("DynParaLoop::checkControlDependancy : Internal error occured - should never been called !");
 472 }
 473
 474 /*!
 475  * \note : For a given name 'name' of port in absolute form from this, returns the corresponding InputPort
 476  *         instance of the port for the branch # 'branchNb'.
 477  *         The port can be part of _node or _initNode if it exists (if 'initNodeAdmitted' is true).
 478  *         \b WARNING : no check performed on  'branchNb' value to see if it is compatible with size of '_execNodes'.
 479  *         This method is called to dispatch value on each InputPort linked to this->._splitterNode._splittedPort
 480  */
 481 InputPort *DynParaLoop::getDynInputPortByAbsName(int branchNb, const std::string& name, bool initNodeAdmitted)
 482 {
 483   string portName, nodeName;
 484   splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,true);
 485   Node *staticChild = getChildByName(nodeName);
 486   Node *desc=isInMyDescendance(staticChild);
 487   if(desc==_node)
 488     {
 489       splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,false);
 490       return _execNodes[branchNb]->getInputPort(portName);
 491     }
 492   else if(desc==_initNode)
 493     if(initNodeAdmitted)
 494       {
 495         splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,false);
 496         return _execInitNodes[branchNb]->getInputPort(portName);
 497       }
 498   return 0;
 499 }
 500
 501 void DynParaLoop::checkBasicConsistency() const throw(YACS::Exception)
 502 {
 503   DEBTRACE("DynParaLoop::checkBasicConsistency");
 504   ComposedNode::checkBasicConsistency();
 505   if(!_node)
 506     throw Exception("For a dynamic loop, internal node is mandatory");
 507 }
 508
 509 std::string DynParaLoop::getErrorReport()
 510 {
 511   DEBTRACE("DynParaLoop::getErrorReport: " << getName() << " " << _state);
 512   YACS::StatesForNode effectiveState=getEffectiveState();
 513
 514   if(effectiveState != YACS::INVALID &&  effectiveState != YACS::ERROR && effectiveState != YACS::FAILED)
 515     return "";
 516
 517   std::string report="<error node= " + getName();
 518   switch(effectiveState)
 519     {
 520     case YACS::INVALID:
 521       report=report+" state= INVALID";
 522       break;
 523     case YACS::ERROR:
 524       report=report+" state= ERROR";
 525       break;
 526     case YACS::FAILED:
 527       report=report+" state= FAILED";
 528       break;
 529     default:
 530       break;
 531     }
 532   report=report + ">\n" ;
 533   if(_errorDetails != "")
 534     report=report+_errorDetails+"\n";
 535
 536   if(_execNodes.empty())
 537     {
 538       // edition node
 539       list<Node *> constituents=edGetDirectDescendants();
 540       for(list<Node *>::iterator iter=constituents.begin(); iter!=constituents.end(); iter++)
 541         {
 542           std::string rep=(*iter)->getErrorReport();
 543           if(rep != "")
 544             {
 545               report=report+rep+"\n";
 546             }
 547         }
 548     }
 549   else
 550     {
 551       // execution nodes
 552       for(vector<Node *>::iterator iter=_execInitNodes.begin();iter!=_execInitNodes.end();iter++)
 553         {
 554           std::string rep=(*iter)->getErrorReport();
 555           if(rep != "")
 556             {
 557               report=report+rep+"\n";
 558             }
 559         }
 560       for(vector<Node *>::iterator iter=_execNodes.begin();iter!=_execNodes.end();iter++)
 561         {
 562           std::string rep=(*iter)->getErrorReport();
 563           if(rep != "")
 564             {
 565               report=report+rep+"\n";
 566             }
 567         }
 568       for(vector<Node *>::iterator iter=_execFinalizeNodes.begin();iter!=_execFinalizeNodes.end();iter++)
 569         {
 570           std::string rep=(*iter)->getErrorReport();
 571           if(rep != "")
 572             {
 573               report=report+rep+"\n";
 574             }
 575         }
 576     }
 577
 578   report=report+"</error>";
 579   return report;
 580 }
 581
 582 void DynParaLoop::forwardExecStateToOriginalBody(Node *execNode)
 583 {
 584   unsigned int id;
 585   Node * origNode = NULL;
 586   switch (getIdentityOfNotifyerNode(execNode,id))
 587     {
 588     case INIT_NODE:
 589     {
 590       origNode = _initNode;
 591       break;
 592     }
 593     case WORK_NODE:
 594     {
 595       origNode = _node;
 596       break;
 597     }
 598     case FINALIZE_NODE:
 599     {
 600       origNode = _finalizeNode;
 601       break;
 602     }
 603     default:
 604       YASSERT(false)
 605     }
 606
 607   YASSERT(origNode != NULL)
 608   origNode->setState(execNode->getState());
 609   origNode->setErrorDetails(execNode->getErrorDetails());
 610
 611   ComposedNode* compNode = dynamic_cast<ComposedNode*>(origNode);
 612   ComposedNode* compNodeExe = dynamic_cast<ComposedNode*>(execNode);
 613   if (compNode && compNodeExe)
 614     {
 615       list<Node *> aChldn = compNodeExe->getAllRecursiveConstituents();
 616       list<Node *>::iterator iter=aChldn.begin();
 617       for(;iter!=aChldn.end();iter++)
 618         {
 619           Node* node=compNode->getChildByName(compNodeExe->getChildName(*iter));
 620           node->setState((*iter)->getState());
 621           node->setErrorDetails((*iter)->getErrorDetails());
 622         }
 623     }
 624 }
 625
 626 //! Method used to notify the node that a child node has failed
 627 /*!
 628  * Update the current state and return the change state
 629  *
 630  *  \param node : the child node that has failed
 631  *  \return the state change
 632  */
 633 YACS::Event DynParaLoop::updateStateOnFailedEventFrom(Node *node, const Executor *execInst)
 634 {
 635   DEBTRACE("DynParaLoop::updateStateOnFailedEventFrom " << node->getName());
 636   setState(YACS::FAILED);
 637   forwardExecStateToOriginalBody(node);
 638   unsigned int id;
 639   switch (getIdentityOfNotifyerNode(node,id))
 640     {
 641     case INIT_NODE:
 642     {
 643       _node->setState(YACS::FAILED);
 644       if (_finalizeNode != NULL) _finalizeNode->setState(YACS::FAILED);
 645       break;
 646     }
 647     case WORK_NODE:
 648     {
 649       if (_finalizeNode != NULL) _finalizeNode->setState(YACS::FAILED);
 650       break;
 651     }
 652     }
 653   return YACS::ABORT;
 654 }
 655
 656 //! Clone nodes and make their placement consistent with the placement of the original ones.
 657 /*!
 658  *  For instance, if two original nodes are placed on a component comp1 in a container cont1
 659  *  and a third one is placed on a component comp2 in the container cont1, the clones of the two
 660  *  first nodes will be placed on a component comp3 in a container cont2 and the third clone
 661  *  will be placed on a component comp4 in the container cont2.
 662  */
 663 vector<Node *> DynParaLoop::cloneAndPlaceNodesCoherently(const vector<Node *> & origNodes)
 664 {
 665   DEBTRACE("Begin cloneAndPlaceNodesCoherently")
 666   vector<Node *> clones;
 667   DeploymentTree treeToDup;
 668   vector<list<ElementaryNode *> > origElemNodeList;
 669   for (int i=0 ; i<origNodes.size() ; i++)
 670     {
 671       DEBTRACE("Cloning node " << i)
 672       if (origNodes[i] == NULL)
 673         {
 674           DEBTRACE("Cloning node " << i << ", NULL" )
 675           clones.push_back(NULL);
 676           origElemNodeList.push_back(list<ElementaryNode *>());
 677         }
 678       else
 679         {
 680           DEBTRACE("Cloning node " << i << "," << origNodes[i]->getName())
 681           clones.push_back(origNodes[i]->simpleClone(this, false));
 682           list<ElementaryNode *> tasks = origNodes[i]->getRecursiveConstituents();
 683           origElemNodeList.push_back(tasks);
 684           for (list< ElementaryNode *>::iterator iter=tasks.begin() ; iter!=tasks.end() ; iter++)
 685             treeToDup.appendTask(*iter, (*iter)->getDynClonerIfExists(this));
 686         }
 687     }
 688
 689   DEBTRACE("Placing nodes...")
 690   vector<Container *> conts=treeToDup.getAllContainers();
 691
 692   //iterate on all containers
 693   for(vector<Container *>::iterator iterCt=conts.begin();iterCt!=conts.end();iterCt++)
 694     {
 695       DEBTRACE("Container " << ((*iterCt)?(*iterCt)->getName():"NULL"))
 696       vector<ComponentInstance *> comps=treeToDup.getComponentsLinkedToContainer(*iterCt);
 697       Container *contCloned=0;
 698       if((*iterCt))
 699         contCloned=(*iterCt)->clone();
 700
 701       //iterate on all component instances linked to the container
 702       for(vector<ComponentInstance *>::iterator iterCp=comps.begin();iterCp!=comps.end();iterCp++)
 703         {
 704           DEBTRACE("Component " << (*iterCp)->getCompoName())
 705           vector<Task *> tasks=treeToDup.getTasksLinkedToComponent(*iterCp);
 706           ComponentInstance *curCloned=(*iterCp)->clone();
 707           DEBTRACE("Assign container " << (*iterCp)->getCompoName())
 708           curCloned->setContainer(contCloned);
 709           for(vector<Task *>::iterator iterT=tasks.begin();iterT!=tasks.end();iterT++)
 710             {
 711               DEBTRACE("Task " << ((ElementaryNode *)(*iterT))->getName())
 712               int i = 0;
 713               ElementaryNode * origElemNode = NULL;
 714               for (i=0 ; i<origNodes.size() ; i++)
 715                 if (origNodes[i] != NULL)
 716                   {
 717                     DEBTRACE("Looking in original node " << i)
 718                     list<ElementaryNode *>::iterator res=find(origElemNodeList[i].begin(),
 719                                                               origElemNodeList[i].end(),
 720                                                               (ElementaryNode *)(*iterT));
 721                     if (res != origElemNodeList[i].end()) {
 722                       origElemNode = *res;
 723                       break;
 724                     }
 725                   }
 726
 727               YASSERT(origElemNode != NULL)
 728               DEBTRACE("Found task in node " << i)
 729               ServiceNode * nodeC = NULL;
 730               if (origNodes[i] == origElemNode)
 731                 nodeC = (ServiceNode *)clones[i];
 732               else
 733                 {
 734                   string childName = ((ComposedNode *)origNodes[i])->getChildName(origElemNode);
 735                   nodeC = (ServiceNode *)clones[i]->getChildByName(childName);
 736                 }
 737               DEBTRACE("Assign component: " << (*iterCp)->getCompoName() << "," << nodeC->getName())
 738               nodeC->setComponent(curCloned);
 739             }
 740           curCloned->decrRef();
 741         }
 742
 743       // iterate on all tasks linked to the container
 744       vector<Task *> tasks=treeToDup.getTasksLinkedToContainer(*iterCt);
 745       for(vector<Task *>::iterator iterT=tasks.begin();iterT!=tasks.end();iterT++)
 746         {
 747           DEBTRACE("Task " << ((ElementaryNode *)(*iterT))->getName())
 748           int i = 0;
 749           ElementaryNode * origElemNode = NULL;
 750           for (i=0 ; i<origNodes.size() ; i++)
 751             if (origNodes[i] != NULL)
 752               {
 753                 DEBTRACE("Looking in original node " << i)
 754                 list<ElementaryNode *>::iterator res=find(origElemNodeList[i].begin(),
 755                                                           origElemNodeList[i].end(),
 756                                                           (ElementaryNode *)(*iterT));
 757                 if (res != origElemNodeList[i].end())
 758                   {
 759                     origElemNode = *res;
 760                     break;
 761                   }
 762               }
 763           YASSERT(origElemNode != NULL)
 764           DEBTRACE("Found task in node " << i)
 765           InlineFuncNode * nodeC = NULL;
 766           if (origNodes[i] == origElemNode)
 767             {
 768               nodeC = (InlineFuncNode *)clones[i];
 769             }
 770           else
 771             {
 772               string childName = ((ComposedNode *)origNodes[i])->getChildName(origElemNode);
 773               nodeC = (InlineFuncNode *)clones[i]->getChildByName(childName);
 774             }
 775           DEBTRACE("Assign container " << nodeC->getName() << "," << contCloned->getName())
 776           nodeC->setContainer(contCloned);
 777         }
 778
 779       // ended with current container
 780       if(contCloned)
 781         contCloned->decrRef();
 782     }
 783
 784   DEBTRACE("End cloneAndPlaceNodesCoherently")
 785   return clones;
 786 }
 787
 788 void DynParaLoop::accept(Visitor *visitor)
 789 {
 790   visitor->visitDynParaLoop(this);
 791 }
 792
 793 Node * DynParaLoop::getInitNode()
 794 {
 795   return _initNode;
 796 }
 797
 798 Node * DynParaLoop::getExecNode()
 799 {
 800   return _node;
 801 }
 802
 803 Node * DynParaLoop::getFinalizeNode()
 804 {
 805   return _finalizeNode;
 806 }
 807
 808 int DynParaLoop::getMaxLevelOfParallelism() const
 809 {
 810   return _nbOfBranches.getIntValue();
 811 }
 812
 813 void DynParaLoop::shutdown(int level)
 814 {
 815   if(level==0)return;
 816   if(!_node) return;
 817
 818   std::vector<Node *>::iterator iter;
 819   for (iter=_execNodes.begin() ; iter!=_execNodes.end() ; iter++)
 820     (*iter)->shutdown(level);
 821   for (iter=_execInitNodes.begin() ; iter!=_execInitNodes.end() ; iter++)
 822     (*iter)->shutdown(level);
 823   for (iter=_execFinalizeNodes.begin() ; iter!=_execFinalizeNodes.end() ; iter++)
 824     (*iter)->shutdown(level);
 825 }