-// Copyright (C) 2006-2016 CEA/DEN, EDF R&D
+// Copyright (C) 2006-2022 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
const char DynParaLoop::NAME_OF_SPLITTED_SEQ_OUT[] = "evalSamples";
const char DynParaLoop::OLD_NAME_OF_SPLITTED_SEQ_OUT[] = "SmplPrt"; // For backward compatibility with 5.1.4
-const char DynParaLoop::NAME_OF_NUMBER_OF_BRANCHES[]="nbBranches";
-
-DynParaLoop::DynParaLoop(const std::string& name, TypeCode *typeOfDataSplitted)
+DynParaLoop::DynParaLoop(const std::string& name, TypeCode *typeOfDataSplitted, std::unique_ptr<NbBranchesAbstract>&& branchManager)
: ComposedNode(name),_node(0),_initNode(0),_finalizeNode(0),_nbOfEltConsumed(0),
- _nbOfBranches(NAME_OF_NUMBER_OF_BRANCHES,this,Runtime::_tc_int),
- _splittedPort(NAME_OF_SPLITTED_SEQ_OUT,this,typeOfDataSplitted),_initializingCounter(0),_unfinishedCounter(0),_failedCounter(0)
+ _nbOfBranches(std::move(branchManager)),
+ _splittedPort(NAME_OF_SPLITTED_SEQ_OUT,this,typeOfDataSplitted),_initializingCounter(0),_unfinishedCounter(0),_failedCounter(0),_weight(), _loopWeight(0)
{
+ _weight.setDefaultLoop();
}
DynParaLoop::~DynParaLoop()
}
DynParaLoop::DynParaLoop(const DynParaLoop& other, ComposedNode *father, bool editionOnly)
- : ComposedNode(other,father), _nbOfBranches(other._nbOfBranches,this),
+ : ComposedNode(other,father),_nbOfBranches(other._nbOfBranches->copy(this)),
_splittedPort(other._splittedPort,this), _node(0), _initNode(0), _finalizeNode(0),
- _nbOfEltConsumed(0),_initializingCounter(0),_unfinishedCounter(0),_failedCounter(0)
+ _nbOfEltConsumed(0),_initializingCounter(0),_unfinishedCounter(0),_failedCounter(0),_weight(other._weight), _loopWeight(other._loopWeight)
{
if(other._node)
_node=other._node->clone(this,editionOnly);
_node->init(start);
if (_initNode) _initNode->init(start);
if (_finalizeNode) _finalizeNode->init(start);
- _nbOfBranches.exInit(start);
+ _nbOfBranches->exInit(start);
_splittedPort.exInit();
_nbOfEltConsumed=0;
_failedCounter=0;
* \param end : the InPort to connect
* \return true if a new link has been created, false otherwise.
*/
-bool DynParaLoop::edAddDFLink(OutPort *start, InPort *end) throw(YACS::Exception)
+bool DynParaLoop::edAddDFLink(OutPort *start, InPort *end)
{
return edAddLink(start,end);
}
return ret;
}
-OutPort *DynParaLoop::getOutPort(const std::string& name) const throw(YACS::Exception)
+OutPort *DynParaLoop::getOutPort(const std::string& name) const
{
if (name == NAME_OF_SPLITTED_SEQ_OUT || name == OLD_NAME_OF_SPLITTED_SEQ_OUT)
return (OutPort *)&_splittedPort;
}
-OutputPort *DynParaLoop::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort *DynParaLoop::getOutputPort(const std::string& name) const
{
if (name == NAME_OF_SPLITTED_SEQ_OUT || name == OLD_NAME_OF_SPLITTED_SEQ_OUT)
return (OutputPort *)&_splittedPort;
return removeNode(_finalizeNode);
}
-void DynParaLoop::edRemoveChild(Node *node) throw(YACS::Exception)
+void DynParaLoop::edRemoveChild(Node *node)
{
ComposedNode::edRemoveChild(node);
if(node==_node)
modified();
}
-bool DynParaLoop::edAddChild(Node *DISOWNnode) throw(YACS::Exception)
+bool DynParaLoop::edAddChild(Node *DISOWNnode)
{
return edSetNode(DISOWNnode);
}
std::list<InputPort *> DynParaLoop::getSetOfInputPort() const
{
list<InputPort *> ret=ComposedNode::getSetOfInputPort();
- ret.push_back((InputPort *)&_nbOfBranches);
+ InputPort *port(_nbOfBranches->getPort());
+ if(port)
+ ret.push_back(port);
return ret;
}
-InputPort *DynParaLoop::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *DynParaLoop::getInputPort(const std::string& name) const
{
- if(name==NAME_OF_NUMBER_OF_BRANCHES)
- return (InputPort *)&_nbOfBranches;
+ if(_nbOfBranches->isMyName(name))
+ return _nbOfBranches->getPort();
return ComposedNode::getInputPort(name);
}
std::list<InputPort *> DynParaLoop::getLocalInputPorts() const
{
list<InputPort *> ret=ComposedNode::getLocalInputPorts();
- ret.push_back((InputPort *)&_nbOfBranches);
+ InputPort *port(_nbOfBranches->getPort());
+ if(port)
+ ret.push_back(port);
return ret;
}
-unsigned DynParaLoop::getNumberOfBranchesCreatedDyn() const throw(YACS::Exception)
+unsigned DynParaLoop::getNumberOfBranchesCreatedDyn() const
{
if(_execNodes.empty())
throw Exception("ForEachLoop::getNumberOfBranches : No branches created dynamically ! - ForEachLoop needs to run or to be runned to call getNumberOfBranches");
return _execNodes.size();
}
-Node *DynParaLoop::getChildByShortName(const std::string& name) const throw(YACS::Exception)
+Node *DynParaLoop::getChildByShortName(const std::string& name) const
{
if (_node && name == _node->getName())
return _node;
throw Exception(what);
}
-Node *DynParaLoop::getChildByNameExec(const std::string& name, unsigned id) const throw(YACS::Exception)
+Node *DynParaLoop::getChildByNameExec(const std::string& name, unsigned id) const
{
if(id>=getNumberOfBranchesCreatedDyn())
throw Exception("ForEachLoop::getChildByNameExec : invalid id - too large compared with dynamically created branches.");
if(portToSet)//portToSet==0 in case of portToSet==_splitterNode._dataPortToDispatch of ForEach
{
portToSet->put((const void *)val);
- portToSet->edNotifyReferencedBy(0);//This is to indicate that somewhere somebody deals with this inputport
+ portToSet->edNotifyReferencedBy(nullptr,false);//This is to indicate that somewhere somebody deals with this inputport
//even if no direct physical link exists. This exclusively for _execNodes[branchNb]::init on the next turn of loop.
+ //false is put as 2nd parameter to tell to portToSet, do not touch to the data in case of squeezeMemory.
}
}
}
return FINALIZE_NODE;
}
+void DynParaLoop::setWeight(double loopWeight)
+{
+ if(loopWeight<=0.)
+ throw Exception("DynParaLoop::setWeight : invalid input value !");
+ _loopWeight=loopWeight;
+}
+
+ComplexWeight* DynParaLoop::getWeight()
+{
+ if (_loopWeight>0.)
+ _weight.setLoopWeight(_loopWeight, _node->getMaxLevelOfParallelism()); // not done in setWeight because _node can be null at that time
+ return &_weight;
+}
+
bool DynParaLoop::isMultiplicitySpecified(unsigned& value) const
{
- if(_nbOfBranches.edIsManuallyInitialized())
- if(_nbOfBranches.edGetNumberOfLinks()==0)
- {
- value=_nbOfBranches.getIntValue();
- return true;
- }
- return false;
+ return _nbOfBranches->isMultiplicitySpecified(value);
}
void DynParaLoop::forceMultiplicity(unsigned value)
{
- _nbOfBranches.edRemoveAllLinksLinkedWithMe();
- _nbOfBranches.edInit((int)value);
+ _nbOfBranches->forceMultiplicity(value);
}
void DynParaLoop::buildDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView)
}
void DynParaLoop::checkLinkPossibility(OutPort *start, const std::list<ComposedNode *>& pointsOfViewStart,
- InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) throw(YACS::Exception)
+ InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd)
{
ComposedNode::checkLinkPossibility(start, pointsOfViewStart, end, pointsOfViewEnd);
Node * startNode = isInMyDescendance(start->getNode());
return 0;
}
-void DynParaLoop::checkBasicConsistency() const throw(YACS::Exception)
+void DynParaLoop::checkBasicConsistency() const
{
DEBTRACE("DynParaLoop::checkBasicConsistency");
ComposedNode::checkBasicConsistency();
}
for(vector<Node *>::iterator iter=_execNodes.begin();iter!=_execNodes.end();iter++)
{
- std::string rep=(*iter)->getErrorReport();
- if(rep != "")
+ if(*iter)
{
- report=report+rep+"\n";
+ std::string rep=(*iter)->getErrorReport();
+ if(rep != "")
+ {
+ report=report+rep+"\n";
+ }
}
}
for(vector<Node *>::iterator iter=_execFinalizeNodes.begin();iter!=_execFinalizeNodes.end();iter++)
int DynParaLoop::getMaxLevelOfParallelism() const
{
- return _nbOfBranches.getIntValue() * _node->getMaxLevelOfParallelism();
+ return _nbOfBranches->getIntValue() * _node->getMaxLevelOfParallelism();
+}
+
+void DynParaLoop::partitionRegardingDPL(const PartDefinition *pd, std::map<ComposedNode *, YACS::BASES::AutoRefCnt<PartDefinition> >& zeMap)
+{
+ YACS::BASES::AutoRefCnt<PartDefinition> pd2(pd->copy());
+ zeMap[this]=pd2;
+ if(_node)
+ _node->partitionRegardingDPL(pd,zeMap);
}
void DynParaLoop::shutdown(int level)
