virtual std::map<std::string,std::string> getProperties() const = 0;
virtual std::map<std::string,std::string> getResourceProperties(const std::string& name) const = 0;
virtual void setProperties(const std::map<std::string,std::string>& properties);
- std::string getName() const { return _name; }
+ virtual std::string getName() const { return _name; }
//! \b WARNING ! name is used in edition to identify different containers, it is not the runtime name of the container
void setName(std::string name) { _name = name; }
void setProc(Proc* proc) { _proc = proc; }
virtual ServiceInlineNode *createSInlineNode(const std::string& kind, const std::string& name);
virtual ComponentInstance* createComponentInstance(const std::string& name,
const std::string& kind="");
+#ifndef SWIG
virtual Container *createContainer(const std::string& kind="");
+#endif
virtual WhileLoop* createWhileLoop(const std::string& name);
virtual ForLoop* createForLoop(const std::string& name);
virtual OptimizerLoop* createOptimizerLoop(const std::string& name,const std::string& algLib,
_trueCont=Engines::Container::_nil();
}
+std::string SalomeContainerMonoHelper::getKernelContainerName() const
+{
+ if(CORBA::is_nil(_trueCont))
+ return std::string("NULL");
+ CORBA::String_var containerName(_trueCont->name());
+ std::string ret(containerName);
+ return ret;
+}
+
SalomeContainerMonoHelper::~SalomeContainerMonoHelper()
{
}
void setContainer(const Task *askingNode, Engines::Container_var cont);
bool isKernelContNull() const;
void shutdown();
+ std::string getKernelContainerName() const;
private:
~SalomeContainerMonoHelper();
public:
return helper->getContainer(NULL);
}
+std::vector<std::string> SalomeHPContainerBase::getKernelContainerNames() const
+{
+ return _launchModeType->getKernelContainerNames();
+}
+
////////////////
SalomeHPContainer::SalomeHPContainer():SalomeHPContainerBase(new SalomeHPContainerVectOfHelper)
throw Exception("SalomeHPContainerShared::cloneAlways : you are not supposed to be in this situation ! This type of container has only existence during execution !");
}
+std::string SalomeHPContainerShared::getName() const
+{
+ return getTheBoss()->getName();
+}
+
+std::string SalomeHPContainerShared::getDiscreminantStrOfThis(const Task *askingNode) const
+{
+ return getTheBoss()->getDiscreminantStrOfThis(askingNode);
+}
+
void SalomeHPContainerShared::start(const Task *askingNode) throw(Exception)
{
SalomeContainerToolsSpreadOverTheResDecorator sct(&getTheBoss()->getContainerInfo(),_pd->getPlayGround(),_launchModeType,askingNode);
void addComponentName(const std::string& name);
void checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception);
Engines::Container_var getContainerPtr(const Task *askingNode) const;
+ std::vector<std::string> getKernelContainerNames() const;
public:
int getShutdownLev() const { return _shutdownLevel; }
YACS::BASES::AutoRefCnt<HomogeneousPoolContainer> decorate(YACS::BASES::AutoConstRefCnt<PartDefinition> pd);
int getNumberOfCoresPerWorker() const { return _directFather->getNumberOfCoresPerWorker(); }
void prepareMaskForExecution() const;
void forYourTestsOnly(ForTestOmlyHPContCls *data) const;
+ std::string getName() const;
+ std::string getDiscreminantStrOfThis(const Task *askingNode) const;
public:
std::string getKind() const;
void start(const Task *askingNode) throw(Exception);
(*it)->shutdown();
}
+std::vector<std::string> SalomeHPContainerVectOfHelper::getKernelContainerNames() const
+{
+ std::vector<std::string> ret;
+ {
+ YACS::BASES::AutoLocker<SalomeHPContainerVectOfHelper> alck(const_cast<SalomeHPContainerVectOfHelper *>(this));
+ std::size_t sz(_launchModeType.size());
+ ret.resize(sz);
+ for(std::size_t i=0;i<sz;i++)
+ {
+ ret[i]=_launchModeType[i]->getKernelContainerName();
+ }
+ }
+ return ret;
+}
+
void SalomeHPContainerVectOfHelper::lock()
{
_mutex.lock();
void lock();
//! For thread safety for concurrent load operation on same Container.
void unLock();
+ public:
+ std::vector<std::string> getKernelContainerNames() const;
private:
~SalomeHPContainerVectOfHelper() { }
void checkNoCurrentWork() const;
Py_DECREF(pyapi);
%}
+%{
+static PyObject *convertContainer2(YACS::ENGINE::Container *cont, int owner=0)
+{
+ if(!cont)
+ return SWIG_NewPointerObj((void*)cont,SWIGTYPE_p_YACS__ENGINE__Container, owner);
+ if(dynamic_cast<YACS::ENGINE::SalomeHPContainer *>(cont))
+ {
+ return SWIG_NewPointerObj((void*)dynamic_cast<YACS::ENGINE::SalomeHPContainer *>(cont),SWIGTYPE_p_YACS__ENGINE__SalomeHPContainer, owner);
+ }
+ if(dynamic_cast<YACS::ENGINE::SalomeContainer *>(cont))
+ {
+ return SWIG_NewPointerObj((void*)dynamic_cast<YACS::ENGINE::SalomeContainer *>(cont),SWIGTYPE_p_YACS__ENGINE__SalomeContainer, owner);
+ }
+ return SWIG_NewPointerObj((void*)cont,SWIGTYPE_p_YACS__ENGINE__Container, owner);
+}
+%}
+
// ----------------------------------------------------------------------------
#ifdef SWIGPYTHON
%rename(OptimizerAlgSync) YACS::ENGINE::PyOptimizerAlgBase;
%rename(OptimizerAlgASync) YACS::ENGINE::PyOptimizerAlgASync;
%include "PyOptimizerAlg.hxx"
+
+%extend YACS::ENGINE::RuntimeSALOME
+{
+ PyObject *createContainer(const std::string& kind="")
+ {
+ YACS::ENGINE::Container *ret(self->createContainer(kind));
+ return convertContainer2(ret);
+ }
+}
exe.RunW(p,0)
assert(p.getState()==pilot.DONE)
pass
+
+ def test3(self):
+ """ First test coming from the big boss."""
+ SALOMERuntime.RuntimeSALOME.setRuntime()
+ r=SALOMERuntime.getSALOMERuntime()
+ pg=pilot.PlayGround()
+ pg.loadFromKernelCatalog()
+ assert(len(pg.getData())!=0)
+ p=r.createProc("p0")
+ td=p.createType("double","double")
+ tdd=p.createSequenceTc("seqdouble","seqdouble",td)
+ hp1=r.createContainer("HPSalome") ; hp1.setName("HP1")
+ #
+ n0=r.createScriptNode("Salome","n0")
+ n0.setExecutionMode("local")
+ out0_0=n0.edAddOutputPort("o1",tdd)
+ n0.setScript("""o1=[float(i)+0.1 for i in range(1000)]""")
+ p.edAddChild(n0)
+ #
+ n1_0=r.createForEachLoop("n1_0",td)
+ n2_0=r.createForEachLoop("n2_0",td)
+ p.edAddChild(n1_0)
+ p.edAddChild(n2_0)
+ p.edAddCFLink(n0,n1_0)
+ p.edAddCFLink(n1_0,n2_0)
+ p.edAddLink(out0_0,n1_0.edGetSeqOfSamplesPort())
+ p.edAddLink(out0_0,n2_0.edGetSeqOfSamplesPort())
+ ##
+ n1_0_sc=r.createScriptNode("Salome","n1_0_sc")
+ n1_0.edAddChild(n1_0_sc)
+ n1_0_sc.setExecutionMode("remote")
+ n1_0_sc.setScript("""2*i1""")
+ i1_0_sc=n1_0_sc.edAddInputPort("i1",td)
+ p.edAddLink(n1_0.edGetSamplePort(),i1_0_sc)
+ n1_0_sc.setContainer(hp1)
+ ##
+ n2_0_sc=r.createScriptNode("Salome","n2_0_sc")
+ n2_0.edAddChild(n2_0_sc)
+ n2_0_sc.setExecutionMode("remote")
+ n2_0_sc.setScript("""2*i1""")
+ i2_0_sc=n2_0_sc.edAddInputPort("i1",td)
+ p.edAddLink(n2_0.edGetSamplePort(),i2_0_sc)
+ n2_0_sc.setContainer(hp1)
+ ##
+ hp1.setProperty("nb_proc_per_node","1")
+ pg.setData([("localhost",3)])
+ p.fitToPlayGround(pg)########### ZE CALL
+ assert(hp1.getSizeOfPool()==3)
+ fyto=pilot.ForTestOmlyHPContCls()
+ n1_0_sc.getContainer().forYourTestsOnly(fyto)
+ assert(fyto.getContainerType()=="HPContainerShared")
+ pd=fyto.getPD()
+ assert(isinstance(pd,pilot.AllPartDefinition))
+ assert(fyto.getIDS()==(0,1,2))
+ fyto=pilot.ForTestOmlyHPContCls()
+ n2_0_sc.getContainer().forYourTestsOnly(fyto)
+ assert(fyto.getContainerType()=="HPContainerShared")
+ pd=fyto.getPD()
+ assert(isinstance(pd,pilot.AllPartDefinition))
+ assert(fyto.getIDS()==(0,1,2))
+ assert(n1_0.edGetNbOfBranchesPort().getPyObj()==3)
+ assert(n2_0.edGetNbOfBranchesPort().getPyObj()==3)
+ #
+ exe=pilot.ExecutorSwig()
+ assert(p.getState()==pilot.READY)
+ exe.RunW(p,0)
+ assert(len(set(hp1.getKernelContainerNames()))==3)
+ pass
pass
