void removeRecursivelyRedundantCL();
void partitionRegardingDPL(const PartDefinition *pd, std::map<ComposedNode *, YACS::BASES::AutoRefCnt<PartDefinition> >& zeMap);
void fitToPlayGround(const PlayGround *pg);
+ void propagePlayGround(const PlayGround *pg);
protected:
bool areAllSubNodesFinished() const;
bool areAllSubNodesDone() const;
(*it)->setSizeOfPool(pg->getNumberOfWorkers((*it)->getNumberOfCoresPerWorker()));
//FIXME
}
+
+void Bloc::propagePlayGround(const PlayGround *pg)
+{
+ static const char MSG[]="Bloc::propagePlayGround : Not implemented yet for this type of node !";
+ class MyVisitor : public Visitor
+ {
+ public:
+ MyVisitor(ComposedNode *root):Visitor(root) { }
+ void visitBloc(Bloc *node) { node->ComposedNode::accept(this); }
+ void visitElementaryNode(ElementaryNode *node) { }
+ void visitForEachLoop(ForEachLoop *node) { throw YACS::Exception(MSG); }
+ void visitForEachLoopDyn(ForEachLoopDyn *node) { }
+ void visitOptimizerLoop(OptimizerLoop *node) { throw YACS::Exception(MSG); }
+ void visitDynParaLoop(DynParaLoop *node) { throw YACS::Exception(MSG); }
+ void visitForLoop(ForLoop *node) { throw YACS::Exception(MSG); }
+ void visitInlineNode(InlineNode *node)
+ {
+ Container *cont(node->getContainer());
+ HomogeneousPoolContainer *cont2(dynamic_cast<HomogeneousPoolContainer *>(cont));
+ if(!cont2)
+ return ;
+ _cont2.insert(cont2);
+ }
+ void visitInlineFuncNode(InlineFuncNode *node) { throw YACS::Exception(MSG); }
+ void visitLoop(Loop *node) { throw YACS::Exception(MSG); }
+ void visitProc(Proc *node) { node->ComposedNode::accept(this); }
+ void visitServiceNode(ServiceNode *node) { throw YACS::Exception(MSG); }
+ void visitServerNode(ServerNode *node) { throw YACS::Exception(MSG); }
+ void visitServiceInlineNode(ServiceInlineNode *node) { throw YACS::Exception(MSG); }
+ void visitSwitch(Switch *node) { throw YACS::Exception(MSG); }
+ void visitWhileLoop(WhileLoop *node) { throw YACS::Exception(MSG); }
+ void visitPresetNode(DataNode *node) { throw YACS::Exception(MSG); }
+ void visitOutNode(DataNode *node) { throw YACS::Exception(MSG); }
+ void visitStudyInNode(DataNode *node) { throw YACS::Exception(MSG); }
+ void visitStudyOutNode(DataNode *node) { throw YACS::Exception(MSG); }
+ public:
+ std::set< HomogeneousPoolContainer * > _cont2;
+ };
+ MyVisitor vis(this);
+ this->accept(&vis);
+ for(auto cont : vis._cont2)
+ cont->assignPG(pg);
+}
\ No newline at end of file
throw Exception("An HomogeneousPoolContainer cannot be detached on cloning #2 !");
}
+void HomogeneousPoolContainer::assignPG(const PlayGround *pg)
+{
+ _pg.takeRef(pg);
+}
+
void HomogeneousPoolContainer::dettachOnCloning() const
{
_isAttachedOnCloning=true;
void dettachOnCloning() const;
bool isAttachedOnCloning() const;
void setAttachOnCloningStatus(bool val) const;
+ void assignPG(const PlayGround *pg);
//
virtual void setSizeOfPool(int sz) = 0;
virtual int getSizeOfPool() const = 0;
#ifndef SWIG
virtual ~HomogeneousPoolContainer();
#endif
+ private:
+ YACS::BASES::AutoConstRefCnt<PlayGround> _pg;
};
}
}
{
std::ostringstream oss;
std::size_t sz(0);
- for(std::vector< std::pair<std::string,int> >::const_iterator it=_data.begin();it!=_data.end();it++)
- sz=std::max(sz,(*it).first.length());
- for(std::vector< std::pair<std::string,int> >::const_iterator it=_data.begin();it!=_data.end();it++)
+ for(auto it : _data)
+ sz=std::max(sz,it.name().length());
+ for(auto it : _data)
{
- oss << " - " << std::setw(10) << (*it).first << " : " << (*it).second << std::endl;
+ oss << " - " << std::setw(10) << it.name() << " : " << it.nbCores() << std::endl;
}
return oss.str();
}
void PlayGround::setData(const std::vector< std::pair<std::string,int> >& defOfRes)
{
- _data=defOfRes;
+ _data=std::vector<Resource>(defOfRes.begin(),defOfRes.end());
checkCoherentInfo();
}
int PlayGround::getNumberOfCoresAvailable() const
{
int ret(0);
- for(std::vector< std::pair<std::string,int> >::const_iterator it=_data.begin();it!=_data.end();it++)
- ret+=(*it).second;
+ for(auto it : _data)
+ ret+=it.nbCores();
return ret;
}
if(nbCoresPerCont<1)
throw Exception("PlayGround::getMaxNumberOfContainersCanBeHostedWithoutOverlap : invalid nbCoresPerCont. Must be >=1 !");
int ret(0);
- for(std::vector< std::pair<std::string,int> >::const_iterator it=_data.begin();it!=_data.end();it++)
- ret+=(*it).second/nbCoresPerCont;
+ for(auto it : _data)
+ ret+=it.nbCores()/nbCoresPerCont;
return ret;
}
{
std::size_t sz(_data.size()),i(0);
std::vector<int> ret(sz+1); ret[0]=0;
- for(std::vector< std::pair<std::string,int> >::const_iterator it=_data.begin();it!=_data.end();it++,i++)
- ret[i+1]=ret[i]+(*it).second;
+ for(auto it=_data.begin();it!=_data.end();it++,i++)
+ ret[i+1]=ret[i]+it->nbCores();
return ret;
}
void PlayGround::checkCoherentInfo() const
{
std::set<std::string> s;
- for(std::vector< std::pair<std::string,int> >::const_iterator it=_data.begin();it!=_data.end();it++)
+ for(auto it : _data)
{
- s.insert((*it).first);
- if((*it).second<0)
+ s.insert(it.name());
+ if(it.nbCores()<0)
throw Exception("Presence of negative int value !");
}
if(s.size()!=_data.size())
{
std::size_t posBg(0),posWorker(0);
std::vector<std::size_t> ret;
- for(std::vector< std::pair<std::string,int> >::const_iterator it=_data.begin();it!=_data.end();it++)
+ for(auto it : _data)
{
- int nbWorker((*it).second/nbCoresPerComp);
+ int nbWorker(it.nbCores()/nbCoresPerComp);
for(int j=0;j<nbWorker;j++,posWorker++)
{
std::vector<bool>::const_iterator it2(std::find(coreFlags.begin()+posBg+j*nbCoresPerComp,coreFlags.begin()+posBg+(j+1)*nbCoresPerComp,false));
if(it2==coreFlags.begin()+posBg+(j+1)*nbCoresPerComp)
ret.push_back(posWorker);
}
- posBg+=(*it).second;
+ posBg+=it.nbCores();
}
return ret;
}
std::size_t sz2(_data.size());
std::vector<int> deltas(sz2+1); deltas[0]=0;
for(std::size_t i=0;i<sz2;i++)
- deltas[i+1]=deltas[i]+(_data[i].second)/nbProcPerNode;
+ deltas[i+1]=deltas[i]+(_data[i].nbCores())/nbProcPerNode;
int zePos(0);
while(zePos<sz2 && (workerId<deltas[zePos] || workerId>=deltas[zePos+1]))
zePos++;
std::string PlayGround::deduceMachineFrom(int workerId, int nbProcPerNode) const
{
int zePos(fromWorkerIdToResId(workerId,nbProcPerNode));
- return _data[zePos].first;
+ return _data[zePos].name();
}
/*!
{
namespace ENGINE
{
- class PartDefinition;
+ class PartDefinition;
+
+ class YACSLIBENGINE_EXPORT Resource
+ {
+ public:
+ Resource(const std::string& name, int nbCores):_name(name),_nbCores(nbCores),_occupied(_nbCores,false) { }
+ Resource(const std::pair<std::string,int>& p):_name(p.first),_nbCores(p.second),_occupied(_nbCores,false) { }
+ std::pair<std::string,int> toPair() const { return {_name,_nbCores}; }
+ int nbCores() const { return _nbCores; }
+ std::string name() const { return _name; }
+ private:
+ std::string _name;
+ int _nbCores;
+ std::vector<bool> _occupied;
+ };
+
+
+ class ResourceIterator : public std::iterator<
+ std::input_iterator_tag, // iterator_category
+ Resource, // value_type
+ long, // difference_type
+ const Resource*, // pointer
+ std::pair<std::string,int> > // reference
+ {
+ const std::vector< Resource > *_vec;
+ std::size_t _num;
+ public:
+ explicit ResourceIterator(const std::vector< Resource > *vec, const std::size_t num) : _vec(vec),_num(num) { }
+ ResourceIterator& operator++() { _num++; return *this; }
+ bool operator==(ResourceIterator other) const { return _num == other._num; }
+ bool operator!=(ResourceIterator other) const { return !(*this == other); }
+ reference operator*() const { return (*_vec)[_num].toPair(); }
+ };
class YACSLIBENGINE_EXPORT PlayGround : public RefCounter
{
public:
- PlayGround(const std::vector< std::pair<std::string,int> >& defOfRes):_data(defOfRes) { checkCoherentInfo(); }
+ PlayGround(const std::vector< std::pair<std::string,int> >& defOfRes):_data(defOfRes.begin(),defOfRes.end()) { checkCoherentInfo(); }
PlayGround() { }
std::string printSelf() const;
void loadFromKernelCatalog();
- std::vector< std::pair<std::string,int> > getData() const { return _data; }
+ std::vector< std::pair<std::string,int> > getData() const { return std::vector< std::pair<std::string,int> >(ResourceIterator(&_data,0),ResourceIterator(&_data,_data.size())); }
void setData(const std::vector< std::pair<std::string,int> >& defOfRes);
int getNumberOfCoresAvailable() const;
int getMaxNumberOfContainersCanBeHostedWithoutOverlap(int nbCoresPerCont) const;
private:
~PlayGround();
private:
- std::vector< std::pair<std::string,int> > _data;
+ std::vector< Resource > _data;
};
class YACSLIBENGINE_EXPORT PartDefinition : public RefCounter
return std::string(_params.container_name);
}
+int SalomeContainerTools::getNumberOfCoresPerWorker() const
+{
+ return _params.resource_params.nb_proc_per_node;
+}
+
void SalomeContainerTools::setContainerName(const std::string& name)
{
SetContainerNameOf(_params,name);
void addToResourceList(const std::string& name);
public:
std::string getContainerName() const;
+ int getNumberOfCoresPerWorker() const;
void setContainerName(const std::string& name);
std::string getNotNullContainerName(const Container *contPtr, const Task *askingNode, bool& isEmpty) const;
std::string getHostName() const;
Engines::ContainerParameters getParameters() const { return _params; }
+
static void SetContainerNameOf(Engines::ContainerParameters& params, const std::string& name);
public:
static void Start(const std::vector<std::string>& compoNames, SalomeContainerHelper *schelp, SalomeContainerTools& sct, int& shutdownLevel, const Container *cont, const Task *askingNode);
std::vector<std::string> SalomeHPContainer::getKernelContainerNames() const
{
- throw Exception("FIXME");
- //return _launchModeType->getKernelContainerNames();
+ return _launchModeType.getKernelContainerNames(this);
}
int SalomeHPContainer::getNumberOfCoresPerWorker() const
{
- throw Exception("FIXME");
- //return _sct.getNumberOfCoresPerWorker();
+ return _sct.getNumberOfCoresPerWorker();
}
\ No newline at end of file
td=p.createType("double","double")
ti=p.createType("int","int")
cont=p.createContainer("gg","HPSalome")
-cont.setSizeOfPool(4)
+cont.setProperty("nb_proc_per_node","1")
+#
+pg=pilot.PlayGround()
+#pg.loadFromKernelCatalog()
+pg.setData([("localhost",8)])
+#
+#cont.setSizeOfPool(4)
cont.setProperty("name","localhost")
cont.setProperty("hostname","localhost")
ti=p.createType("int","int")
p=l.load(fname)
p.saveSchema(fname2)
p.init()
-ex=pilot.ExecutorSwig()
+p.propagePlayGround(pg)
+"""ex=pilot.ExecutorSwig()
assert(p.getState()==pilot.READY)
stt = datetime.datetime.now()
ex.RunW(p,0)
print(str(datetime.datetime.now()-stt))
assert(p.getState()==pilot.DONE)
o4=p.getChildByName("n2").getOutputPort("o4")
-assert(o4.getPyObj()==[0, 5, 10, 15, 20, 25, 30, 35])
+assert(o4.getPyObj()==[0, 5, 10, 15, 20, 25, 30, 35])"""
# Ideal ForEachDyn time = 22 s
# ForEach time = 40 s"""
\ No newline at end of file
--- /dev/null
+import pilot
+import SALOMERuntime
+import loader
+import datetime
+
+fname="testFEDyn.xml"
+fname2="REtestFEDyn.xml"
+SALOMERuntime.RuntimeSALOME.setRuntime()
+l=loader.YACSLoader()
+r=SALOMERuntime.getSALOMERuntime()
+p=r.createProc("prTest1")
+td=p.createType("double","double")
+ti=p.createType("int","int")
+cont=p.createContainer("gg","HPSalome")
+cont.setProperty("nb_proc_per_node","1")
+#
+pg=pilot.PlayGround()
+#pg.loadFromKernelCatalog()
+pg.setData([("localhost",8)])
+#
+cont.setSizeOfPool(1)
+cont.setProperty("name","localhost")
+cont.setProperty("hostname","localhost")
+ti=p.createType("int","int")
+tsi=p.createSequenceTc("seqint","seqint",ti)
+# Level0
+n0=r.createScriptNode("","n0")
+o0=n0.edAddOutputPort("o0",tsi)
+n0.setScript("o0=[ elt for elt in range(8) ]")
+p.edAddChild(n0)
+n1=r.createForEachLoopDyn("n1",ti)#Dyn
+#n1.getInputPort("nbBranches").edInitPy(2)
+n10=r.createScriptNode("","n10")
+n10.setExecutionMode("remote")
+n10.setContainer(cont)
+n1.edAddChild(n10)
+n10.setScript("""
+import time
+time.sleep(0.1)
+o2=2*i1
+""")
+i1=n10.edAddInputPort("i1",ti)
+o2=n10.edAddOutputPort("o2",ti)
+p.edAddChild(n1)
+p.edAddLink(o0,n1.edGetSeqOfSamplesPort())
+p.edAddLink(n1.edGetSamplePort(),i1)
+p.edAddCFLink(n0,n1)
+n2=r.createScriptNode("","n2")
+n2.setScript("o4=i3")
+i3=n2.edAddInputPort("i3",tsi)
+o4=n2.edAddOutputPort("o4",tsi)
+n2.setScript("o4=[a for a in i3]")
+p.edAddChild(n2)
+p.edAddCFLink(n1,n2)
+p.edAddLink(o2,i3)
+#
+p.saveSchema(fname)
+p=l.load(fname)
+p.saveSchema(fname2)
+p.init()
+ex=pilot.ExecutorSwig()
+assert(p.getState()==pilot.READY)
+stt = datetime.datetime.now()
+ex.RunW(p,0)
+print(str(datetime.datetime.now()-stt))
+assert(p.getState()==pilot.DONE)
+o4=p.getChildByName("n2").getOutputPort("o4")
+assert(o4.getPyObj()==[0, 2, 4, 6, 8, 10, 12, 14])
+# Ideal ForEachDyn time = 22 s
+# ForEach time = 40 s"""
\ No newline at end of file
