using namespace std;
using namespace YACS::ENGINE;
+const char Container::KIND_ENTRY[]="container_kind";
+
Container::Container():_isAttachedOnCloning(false),_proc(0)
{
}
virtual ~Container();
#endif
public:
+ virtual std::string getKind() const = 0;
//Execution only methods
virtual std::string getDiscreminantStrOfThis(const Task *askingNode) const;
virtual bool isAlreadyStarted(const Task *askingNode) const = 0;
void setProc(Proc* proc) { _proc = proc; }
Proc* getProc() { return _proc; }
virtual void shutdown(int level) = 0;
+ static const char KIND_ENTRY[];
protected:
std::string _name;
mutable bool _isAttachedOnCloning;
using namespace YACS::ENGINE;
+const char HomogeneousPoolContainer::SIZE_OF_POOL_KEY[]="SizeOfPool";
+
void HomogeneousPoolContainer::attachOnCloning() const
{
_isAttachedOnCloning=true;
bool isAttachedOnCloning() const;
//
virtual void setSizeOfPool(int sz) = 0;
+ virtual int getSizeOfPool() const = 0;
virtual std::size_t getNumberOfFreePlace() const = 0;
virtual void allocateFor(const std::vector<const Task *>& nodes) = 0;
virtual void release(const Task *node) = 0;
+ static const char SIZE_OF_POOL_KEY[];
protected:
HomogeneousPoolContainer();
#ifndef SWIG
/*!
* \param xmlSchemaFile: the file name
*/
-void Proc::saveSchema(std::string xmlSchemaFile)
+void Proc::saveSchema(const std::string& xmlSchemaFile)
{
VisitorSaveSchema vss(this);
vss.openFileSchema(xmlSchemaFile);
/*!
* \param xmlStateFile: the file name
*/
-void Proc::saveState(std::string xmlStateFile)
+void Proc::saveState(const std::string& xmlStateFile)
{
VisitorSaveState vst(this);
vst.openFileDump(xmlStateFile);
* \param kind: the container kind (depends on runtime)
* \return the created Container
*/
-Container* Proc::createContainer(const std::string& name,const std::string& kind)
+Container *Proc::createContainer(const std::string& name, const std::string& kind)
{
- Container* co= getRuntime()->createContainer(kind);
+ Container *co(getRuntime()->createContainer(kind));
co->setName(name);
if(containerMap.count(name)!=0)
containerMap[name]->decrRef();
class ComponentInstance;
class Logger;
- class YACSLIBENGINE_EXPORT Proc: public Bloc
+ class YACSLIBENGINE_EXPORT Proc : public Bloc
{
public:
Proc(const std::string& name);
virtual TypeCode *createSequenceTc (const std::string& id, const std::string& name,
TypeCode *content);
virtual TypeCode *createStructTc (const std::string& id, const std::string& name);
- virtual TypeCode* getTypeCode(const std::string& name);
+ virtual TypeCode *getTypeCode(const std::string& name);
virtual void setTypeCode(const std::string& name,TypeCode *t);
- virtual Container* createContainer(const std::string& name,const std::string& kind="");
- virtual ComponentInstance* createComponentInstance(const std::string& componame,
+ virtual Container *createContainer(const std::string& name, const std::string& kind="");
+ virtual ComponentInstance *createComponentInstance(const std::string& componame,
const std::string& name="",
const std::string& kind="");
virtual void addComponentInstance(ComponentInstance* inst, const std::string& name="",bool resetCtr=false);
virtual void removeContainer(Container* cont);
virtual void accept(Visitor *visitor);
virtual Proc *getProc();
- virtual const Proc * getProc() const;
+ virtual const Proc *getProc() const;
YACS::StatesForNode getNodeState(int numId);
std::string getNodeProgress(int numId);
virtual bool getEdition(){return _edition;}
virtual void setEdition(bool edition);
virtual void modified();
- virtual void saveSchema(std::string xmlSchemaFile);
- virtual void saveState(std::string xmlStateFile);
+ virtual void saveSchema(const std::string& xmlSchemaFile);
+ virtual void saveState(const std::string& xmlStateFile);
protected:
bool _edition;
int _compoinstctr;
{
}
+std::string ContainerTest::getKind() const
+{
+ return std::string();
+}
+
std::string ContainerTest::getPlacementInfo() const
{
ostringstream stream;
{
}
+std::string ContainerTest2::getKind() const
+{
+ return std::string();
+}
+
bool ContainerTest2::isAlreadyStarted(const Task *askingNode) const
{
return _alreadyStarted;
{
public:
ContainerTest();
+ std::string getKind() const;
std::string getPlacementInfo() const;
// implementation of compulsary methods
bool isAlreadyStarted(const Task *askingNode) const;
{
public:
ContainerTest2();
+ std::string getKind() const;
// implementation of compulsary methods
bool isAlreadyStarted(const Task *askingNode) const;
void start(const Task *askingNode) throw(Exception);
{
string name = it->first;
_out << indent(depth) << "<container name=\"" << name << "\">" << endl;
+ _out << indent(depth+1) << "<property name=\"" << Container::KIND_ENTRY << "\" value=\"" << it->second->getKind() << "\"/>" << endl;
map<string, string> properties = (it->second)->getProperties();
map<string, string>::iterator itm;
for(itm = properties.begin(); itm != properties.end(); ++itm)
}
}
-void VisitorSaveState::openFileDump(std::string xmlDump) throw(YACS::Exception)
+void VisitorSaveState::openFileDump(const std::string& xmlDump) throw(YACS::Exception)
{
_out.open(xmlDump.c_str(), ios::out);
if (!_out)
public:
VisitorSaveState(ComposedNode *root);
virtual ~VisitorSaveState();
- void openFileDump(std::string xmlDump) throw(Exception);
+ void openFileDump(const std::string& xmlDump) throw(Exception);
void closeFileDump();
virtual void visitBloc(Bloc *node);
virtual void visitElementaryNode(ElementaryNode *node);
using namespace YACS::ENGINE;
+char CppContainer::KIND[]="Cpp";
+
//#define _DEVDEBUG_
#include "YacsTrace.hxx"
_mutex.unLock();
}
+std::string CppContainer::getKind() const
+{
+ return KIND;
+}
+
bool CppContainer::isAlreadyStarted(const Task *askingNode) const
{
return NULL != _trueCont;
public:
CppContainer();
virtual ~CppContainer();
+ std::string getKind() const;
bool isAlreadyStarted(const Task *askingNode) const;
void start(const Task *askingNode) throw (YACS::Exception);
void shutdown(int level);
std::map<std::string,std::string> getProperties() const { return std::map<std::string,std::string>(); }
std::map<std::string,std::string> getResourceProperties(const std::string& name) const { return std::map<std::string,std::string>(); }
//
+ public:
+ static char KIND[];
protected:
YACS::BASES::Mutex _mutex;
LocalContainer * _trueCont;
Container *RuntimeSALOME::createContainer(const std::string& kind)
{
- if(kind == "" || kind == SalomeComponent::KIND)
+ if(kind == "" || kind == SalomeContainer::KIND)
return new SalomeContainer;
if(kind==SalomeHPContainer::KIND)
return new SalomeHPContainer;
- else if (kind == CppComponent::KIND)
+ else if (kind == CppContainer::KIND)
return new CppContainer;
std::string msg="Container kind ("+kind+") unknown";
throw Exception(msg);
using namespace YACS::ENGINE;
using namespace std;
+const char SalomeContainer::KIND[]="Salome";
+
SalomeContainer::SalomeContainer():_launchModeType(new SalomeContainerMonoHelper),_shutdownLevel(999)
{
}
_mutex.unLock();
}
+std::string SalomeContainer::getKind() const
+{
+ return KIND;
+}
+
Container *SalomeContainer::clone() const
{
if(_isAttachedOnCloning)
void lock();
//! For thread safety for concurrent load operation on same Container.
void unLock();
+ std::string getKind() const;
bool isAlreadyStarted(const Task *askingNode) const;
Engines::Container_ptr getContainerPtr(const Task *askingNode) const;
void start(const Task *askingNode) throw (Exception);
// Helper methods
std::map<std::string,std::string> getResourceProperties(const std::string& name) const;
std::map<std::string,std::string> getProperties() const;
+ static const char KIND[];
protected:
#ifndef SWIG
virtual ~SalomeContainer();
_launchModeType.resize(sz);
}
+int SalomeHPContainer::getSizeOfPool() const
+{
+ return _launchModeType.size();
+}
+
std::size_t SalomeHPContainer::getNumberOfFreePlace() const
{
return _launchModeType.getNumberOfFreePlace();
_mutex.unLock();
}
+std::string SalomeHPContainer::getKind() const
+{
+ return KIND;
+}
+
std::string SalomeHPContainer::getDiscreminantStrOfThis(const Task *askingNode) const
{
YACS::BASES::AutoCppPtr<SalomeContainerTmpForHP> tmpCont(SalomeContainerTmpForHP::BuildFrom(this,askingNode));
void SalomeHPContainer::setProperty(const std::string& name,const std::string& value)
{
- _sct.setProperty(name,value);
+ if(name==SIZE_OF_POOL_KEY)
+ {
+ std::istringstream iss(value);
+ int val(0);
+ iss >> val;
+ setSizeOfPool(val);
+ }
+ else
+ _sct.setProperty(name,value);
}
std::string SalomeHPContainer::getProperty(const std::string& name) const
{
- return _sct.getProperty(name);
+ if(name==SIZE_OF_POOL_KEY)
+ {
+ std::ostringstream oss; oss << getSizeOfPool();
+ return oss.str();
+ }
+ else
+ return _sct.getProperty(name);
}
void SalomeHPContainer::clearProperties()
std::map<std::string,std::string> SalomeHPContainer::getProperties() const
{
- return _sct.getProperties();
+ std::map<std::string,std::string> ret(_sct.getProperties());
+ std::ostringstream oss; oss << getSizeOfPool();
+ ret[SIZE_OF_POOL_KEY]=oss.str();
+ return ret;
}
std::map<std::string,std::string> SalomeHPContainer::getResourceProperties(const std::string& name) const
SalomeHPContainer(const SalomeHPContainer& other);
//HP specific part
void setSizeOfPool(int sz);
+ int getSizeOfPool() const;
std::size_t getNumberOfFreePlace() const;
void allocateFor(const std::vector<const Task *>& nodes);
void release(const Task *node);
//! For thread safety for concurrent load operation on same Container.
void unLock();
//
+ std::string getKind() const;
std::string getDiscreminantStrOfThis(const Task *askingNode) const;
bool isAlreadyStarted(const Task *askingNode) const;
void start(const Task *askingNode) throw(Exception);
{
for (int i = 0; attr[i]; i += 2)
{
- if(std::string(attr[i]) == "state")this->state(attr[i+1]);
- if(std::string(attr[i]) == "name")name(attr[i+1]);
+ if(std::string(attr[i]) == "state")
+ this->state(attr[i+1]);
+ if(std::string(attr[i]) == "name")
+ name(attr[i+1]);
}
}
- virtual void pre ()
+ virtual void pre()
{
std::string name("proc");
currentProc=theRuntime->createProc(name);
currentProc->names.push_back("");
}
- virtual void name (const std::string& name)
+ virtual void name(const std::string& name)
{
currentProc->setName(name);
}
- virtual void type (const mytype& t)
+ virtual void type(const mytype& t)
{
DEBTRACE( "type_set" );
YACS::ENGINE::TypeCode* tt=currentProc->createType(t._name,t._kind);
tt->decrRef();
}
- virtual void sequence (ENGINE::TypeCode* const& t)
+ virtual void sequence(ENGINE::TypeCode* const& t)
{
DEBTRACE( "sequence_set" );
t->decrRef();
}
- virtual void objref (ENGINE::TypeCode* const& t)
+ virtual void objref(ENGINE::TypeCode* const& t)
{
DEBTRACE( "objref_set" );
t->decrRef();
}
- virtual void struct_ (ENGINE::TypeCode* const& t)
+ virtual void struct_(ENGINE::TypeCode* const& t)
{
DEBTRACE( "struct_set" );
t->decrRef();
}
- virtual void componentinstance (const mycomponentinstance& t)
+ virtual void componentinstance(const mycomponentinstance& t)
{
DEBTRACE( "componentinstance: " << t._name );
YACS::ENGINE::ComponentInstance* inst=currentProc->createComponentInstance(t._component,t._name,t._kind);
inst->decrRef();
}
- virtual void container (const mycontainer& t)
+ virtual void container(const mycontainer& t)
{
DEBTRACE( "container_set: " << t._name )
std::vector<machine>::const_iterator iter;
}
else
{
- YACS::ENGINE::Container* cont=currentProc->createContainer(t._name);
// Set all properties for this container
- std::map<std::string, std::string>::const_iterator pt;
+ std::string kindOfContainer;
+ std::map<std::string, std::string>::const_iterator pt(t._props.find(std::string(ENGINE::Container::KIND_ENTRY)));
+ if(pt!=t._props.end())
+ kindOfContainer=pt->second;
+ YACS::ENGINE::Container *cont(currentProc->createContainer(t._name,kindOfContainer));
for(pt=t._props.begin();pt!=t._props.end();pt++)
- cont->setProperty((*pt).first,(*pt).second);
+ if((*pt).second!=ENGINE::Container::KIND_ENTRY)
+ cont->setProperty((*pt).first,(*pt).second);
cont->decrRef();
}
}
- T post(){return this->_bloc;}
+ T post() { return this->_bloc; }
};
template <class T> proctypeParser<T> proctypeParser<T>::procParser;
{
DEBTRACE( "server_loadcontainer: " << name )
this->_node=(YACS::ENGINE::ServerNode*)theRuntime->createFuncNode("DistPython",this->_name);
- YACS::ENGINE::Container *cont=currentProc->createContainer(this->_node->getEffectiveKindOfServer());
- cont->setName(name);
- this->_node->setContainer(cont);
- cont->decrRef();
+ std::map<std::string,YACS::ENGINE::Container *>::const_iterator it(currentProc->containerMap.find(name));
+ if(it!=currentProc->containerMap.end())
+ {
+ this->_node->setContainer((*it).second);
+ }
+ else
+ {
+ YACS::ENGINE::Container *cont=currentProc->createContainer(this->_node->getEffectiveKindOfServer());
+ cont->setName(name);
+ this->_node->setContainer(cont);
+ cont->decrRef();
+ }
}
virtual void script (const myfunc& f)
{