X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2FSalomeHPContainer.cxx;fp=src%2Fruntime%2FSalomeHPContainer.cxx;h=1cbc1e00092b30fac83ef58999f59611f8617026;hb=a0acdf424abd100a06e663528d6e7c7f4d269a67;hp=8e86b3abee2219073d546b6c6d15f2e3a4fb61f0;hpb=d211688052f32d421ebd6aecace6b17bef3a6aed;p=modules%2Fyacs.git diff --git a/src/runtime/SalomeHPContainer.cxx b/src/runtime/SalomeHPContainer.cxx index 8e86b3abe..1cbc1e000 100644 --- a/src/runtime/SalomeHPContainer.cxx +++ b/src/runtime/SalomeHPContainer.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2006-2019 CEA/DEN, EDF R&D +// Copyright (C) 2006-2016 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 @@ -21,7 +21,6 @@ #include "SalomeHPComponent.hxx" #include "SalomeContainerTmpForHP.hxx" #include "AutoLocker.hxx" -#include "AutoRefCnt.hxx" #include @@ -29,238 +28,108 @@ using namespace YACS::ENGINE; const char SalomeHPContainer::KIND[]="HPSalome"; -SalomeHPContainerBase::SalomeHPContainerBase(SalomeHPContainerVectOfHelper *resShared):_launchModeType(resShared),_shutdownLevel(999) +SalomeHPContainer::SalomeHPContainer():_shutdownLevel(999) { } -SalomeHPContainerBase::SalomeHPContainerBase(const SalomeHPContainerBase& other):_shutdownLevel(999),_launchModeType(new SalomeHPContainerVectOfHelper),_initScript(other._initScript) +SalomeHPContainer::SalomeHPContainer(const SalomeHPContainer& other):_componentNames(other._componentNames),_shutdownLevel(999),_sct(other._sct),_initScript(other._initScript) { } -SalomeHPContainer *SalomeHPContainerBase::getTheBoss() +void SalomeHPContainer::setSizeOfPool(int sz) { - HomogeneousPoolContainer *ret(this); - while(ret->getDirectFather()) - ret=ret->getDirectFather(); - SalomeHPContainer *retC(dynamic_cast(ret)); - if(!retC) - throw Exception("SalomeHPContainerBase::getTheBoss : unexpected type of object !"); - return retC; + _launchModeType.resize(sz); } -const SalomeHPContainer *SalomeHPContainerBase::getTheBoss() const +int SalomeHPContainer::getSizeOfPool() const { - const HomogeneousPoolContainer *ret(this); - while(ret->getDirectFather()) - ret=ret->getDirectFather(); - const SalomeHPContainer *retC(dynamic_cast(ret)); - if(!retC) - throw Exception("SalomeHPContainerBase::getTheBoss : unexpected type of object !"); - return retC; + return _launchModeType.size(); } -void SalomeHPContainerBase::startInternal(const Task *askingNode, SalomeContainerToolsBase& sct, const std::vector& compoNames) +std::size_t SalomeHPContainer::getNumberOfFreePlace() const { - SalomeContainerMonoHelper *helper(_launchModeType->getHelperOfTaskThreadSafe(askingNode)); - SalomeContainerTools::Start(compoNames,helper,sct,_shutdownLevel,this,askingNode); + return _launchModeType.getNumberOfFreePlace(); } -void SalomeHPContainerBase::shutdown(int level) +void SalomeHPContainer::allocateFor(const std::vector& nodes) { - if(level < _shutdownLevel) - return; - _shutdownLevel=999; - _launchModeType->shutdown(); + _launchModeType.allocateFor(nodes); } -SalomeHPContainerBase::SalomeHPContainerBase(SalomeHPContainerVectOfHelper *resShared, bool isRefEaten):_launchModeType(resShared) +void SalomeHPContainer::release(const Task *node) { - if(!isRefEaten) - if(_launchModeType.isNotNull()) - _launchModeType->incrRef(); + _launchModeType.release(node); } -bool SalomeHPContainerBase::isAlreadyStarted(const Task *askingNode) const +SalomeHPContainer::~SalomeHPContainer() { - const SalomeContainerMonoHelper *helper(_launchModeType->getHelperOfTaskThreadSafe(askingNode)); - return helper->isAlreadyStarted(askingNode); } -void SalomeHPContainerBase::release(const Task *node) +void SalomeHPContainer::lock() { - _launchModeType->release(node); + _mutex.lock(); } -void SalomeHPContainerBase::lock() +void SalomeHPContainer::unLock() { - _launchModeType->lock(); + _mutex.unLock(); } -void SalomeHPContainerBase::unLock() +std::string SalomeHPContainer::getKind() const { - _launchModeType->unLock(); + return KIND; } -void SalomeHPContainerBase::setSizeOfPool(int sz) +std::string SalomeHPContainer::getDiscreminantStrOfThis(const Task *askingNode) const { - _launchModeType->resize(sz); + YACS::BASES::AutoCppPtr tmpCont(SalomeContainerTmpForHP::BuildFrom(this,askingNode)); + return tmpCont->getDiscreminantStrOfThis(askingNode); } -int SalomeHPContainerBase::getSizeOfPool() const +bool SalomeHPContainer::isAlreadyStarted(const Task *askingNode) const { - return _launchModeType->size(); + const SalomeContainerMonoHelper *helper(_launchModeType.getHelperOfTaskThreadSafe(this,askingNode)); + return helper->isAlreadyStarted(askingNode); } -void SalomeHPContainerBase::setProperty(const std::string& name,const std::string& value) +void SalomeHPContainer::start(const Task *askingNode) throw(YACS::Exception) { - if(name==AOC_ENTRY)//no sense to set it ! It is always true ! ignore it ! - return ; - else if(name==SIZE_OF_POOL_KEY) - { - std::istringstream iss(value); - int val(0); - iss >> val; - setSizeOfPool(val); - } - else if(name==INITIALIZE_SCRIPT_KEY) - { - _initScript=value; - } - else - getTheBoss()->getContainerInfo().setProperty(name,value); + SalomeContainerMonoHelper *helper(_launchModeType.getHelperOfTaskThreadSafe(this,askingNode)); + SalomeContainerTools::Start(_componentNames,helper,_sct,_shutdownLevel,this,askingNode); } -std::string SalomeHPContainerBase::getProperty(const std::string& name) const +void SalomeHPContainer::shutdown(int level) { - if(name==AOC_ENTRY) - { - return std::string("1"); - } - else if(name==SIZE_OF_POOL_KEY) - { - std::ostringstream oss; oss << getSizeOfPool(); - return oss.str(); - } - else if(name==INITIALIZE_SCRIPT_KEY) + if(level < _shutdownLevel) + return; + _shutdownLevel=999; + for(std::size_t i=0;i<_launchModeType.size();i++) { - return _initScript; + SalomeContainerMonoHelper *helper(_launchModeType.at(i)); + helper->shutdown(); } - else - return getTheBoss()->getContainerInfo().getProperty(name); -} - -std::map SalomeHPContainerBase::getProperties() const -{ - std::map ret(getTheBoss()->getContainerInfo().getProperties()); - std::ostringstream oss; oss << getSizeOfPool(); - ret[SIZE_OF_POOL_KEY]=oss.str(); - if(!_initScript.empty()) - ret[INITIALIZE_SCRIPT_KEY]=_initScript; - return ret; -} - -void SalomeHPContainerBase::clearProperties() -{ - _initScript.clear(); - getTheBoss()->getContainerInfo().clearProperties(); } -std::string SalomeHPContainerBase::getPlacementId(const Task *askingNode) const +std::string SalomeHPContainer::getPlacementId(const Task *askingNode) const { const SalomeContainerMonoHelper *helper(0); { - YACS::BASES::AutoLocker alckCont(const_cast(this)); - helper=_launchModeType->getHelperOfTask(askingNode); + YACS::BASES::AutoLocker alckCont(const_cast(this)); + helper=_launchModeType.getHelperOfTask(askingNode); } return SalomeContainerTools::GetPlacementId(helper,this,askingNode); } -std::string SalomeHPContainerBase::getFullPlacementId(const Task *askingNode) const +std::string SalomeHPContainer::getFullPlacementId(const Task *askingNode) const { const SalomeContainerMonoHelper *helper(0); { - YACS::BASES::AutoLocker alckCont(const_cast(this)); - helper=_launchModeType->getHelperOfTask(askingNode); + YACS::BASES::AutoLocker alckCont(const_cast(this)); + helper=_launchModeType.getHelperOfTask(askingNode); } return SalomeContainerTools::GetFullPlacementId(helper,this,askingNode); } -std::map SalomeHPContainerBase::getResourceProperties(const std::string& name) const -{ - return getTheBoss()->getResourceProperties(name); -} - -void SalomeHPContainerBase::addComponentName(const std::string& name) -{ - getTheBoss()->addComponentNameSpe(name); -} - -void SalomeHPContainerBase::checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception) -{ - getTheBoss()->checkCapabilityToDealWith(inst); -} - -YACS::BASES::AutoRefCnt SalomeHPContainerBase::decorate(YACS::BASES::AutoConstRefCnt pd) -{ - YACS::BASES::AutoRefCnt ret(new SalomeHPContainerShared(pd,_launchModeType,this)); - return ret; -} - -Engines::Container_var SalomeHPContainerBase::getContainerPtr(const Task *askingNode) const -{ - const SalomeContainerMonoHelper *helper(0); - { - YACS::BASES::AutoLocker alck(const_cast(this)); - helper=_launchModeType->getHelperOfTask(askingNode); - } - return helper->getContainer(NULL); -} - -std::vector SalomeHPContainerBase::getKernelContainerNames() const -{ - return _launchModeType->getKernelContainerNames(); -} - -//////////////// - -SalomeHPContainer::SalomeHPContainer():SalomeHPContainerBase(new SalomeHPContainerVectOfHelper) -{ -} - -SalomeHPContainer::SalomeHPContainer(const SalomeHPContainer& other):SalomeHPContainerBase(other),_sct(other._sct),_componentNames(other._componentNames) -{ -} - -std::size_t SalomeHPContainer::getNumberOfFreePlace() const -{ - return _launchModeType->getNumberOfFreePlace(); -} - -void SalomeHPContainer::allocateFor(const std::vector& nodes) -{ - _launchModeType->allocateFor(nodes); -} - -SalomeHPContainer::~SalomeHPContainer() -{ -} - -std::string SalomeHPContainer::getKind() const -{ - return KIND; -} - -std::string SalomeHPContainer::getDiscreminantStrOfThis(const Task *askingNode) const -{ - YACS::BASES::AutoCppPtr tmpCont(SalomeContainerTmpForHP::BuildFrom(this,askingNode)); - return tmpCont->getDiscreminantStrOfThis(askingNode); -} - -void SalomeHPContainer::start(const Task *askingNode) throw(YACS::Exception) -{ - startInternal(askingNode,_sct,_componentNames); -} - /*! * It is not a bug here ! clone for homogeneous container is not supposed to be copied ! */ @@ -275,100 +144,84 @@ Container *SalomeHPContainer::cloneAlways() const return new SalomeHPContainer(*this); } -int SalomeHPContainer::getNumberOfCoresPerWorker() const -{ - return _sct.getNumberOfCoresPerWorker(); -} - -std::map SalomeHPContainer::getResourceProperties(const std::string& name) const -{ - return _sct.getResourceProperties(name); -} - -void SalomeHPContainer::addComponentNameSpe(const std::string& name) -{ - _componentNames.push_back(name); -} - -void SalomeHPContainer::checkCapabilityToDealWithSpe(const ComponentInstance *inst) const throw(YACS::Exception) -{ - if(inst->getKind()!=SalomeHPComponent::KIND) - throw Exception("SalomeHPContainer::checkCapabilityToDealWithSpe : SalomeContainer is not able to deal with this type of ComponentInstance."); -} - -void SalomeHPContainer::forYourTestsOnly(ForTestOmlyHPContCls *data) const -{ - data->setContainerType("HPContainer"); -} - -////////////////////////////////// - -SalomeHPContainerShared::SalomeHPContainerShared(YACS::BASES::AutoConstRefCnt pd, SalomeHPContainerVectOfHelper *resShared, SalomeHPContainerBase *directFather):SalomeHPContainerBase(resShared,false),_pd(pd) -{ - if(!directFather) - throw Exception("SalomeHPContainerShared : NULL pointer not allowed !"); - _directFather.takeRef(directFather); -} - -std::string SalomeHPContainerShared::getKind() const -{ - return SalomeHPContainer::KIND; -} - -void SalomeHPContainerShared::prepareMaskForExecution() const +void SalomeHPContainer::setProperty(const std::string& name,const std::string& value) { - _idsOfKernelContainers=_pd->computeWorkerIdsCovered(getNumberOfCoresPerWorker()); + if(name==AOC_ENTRY)//no sense to set it ! It is always true ! ignore it ! + return ; + else if(name==SIZE_OF_POOL_KEY) + { + std::istringstream iss(value); + int val(0); + iss >> val; + setSizeOfPool(val); + } + else if(name==INITIALIZE_SCRIPT_KEY) + { + _initScript=value; + } + else + _sct.setProperty(name,value); } -/*! - * It is not a bug here ! clone for homogeneous container is not supposed to be copied ! - */ -Container *SalomeHPContainerShared::clone() const +std::string SalomeHPContainer::getProperty(const std::string& name) const { - incrRef(); - return const_cast(this); + if(name==AOC_ENTRY) + { + return std::string("1"); + } + else if(name==SIZE_OF_POOL_KEY) + { + std::ostringstream oss; oss << getSizeOfPool(); + return oss.str(); + } + else if(name==INITIALIZE_SCRIPT_KEY) + { + return _initScript; + } + else + return _sct.getProperty(name); } -Container *SalomeHPContainerShared::cloneAlways() const +void SalomeHPContainer::clearProperties() { - throw Exception("SalomeHPContainerShared::cloneAlways : you are not supposed to be in this situation ! This type of container has only existence during execution !"); + _initScript.clear(); + _sct.clearProperties(); } -std::string SalomeHPContainerShared::getName() const +void SalomeHPContainer::addComponentName(const std::string& name) { - return getTheBoss()->getName(); + _componentNames.push_back(name); } -std::string SalomeHPContainerShared::getDiscreminantStrOfThis(const Task *askingNode) const +std::map SalomeHPContainer::getProperties() const { - return getTheBoss()->getDiscreminantStrOfThis(askingNode); + std::map ret(_sct.getProperties()); + std::ostringstream oss; oss << getSizeOfPool(); + ret[SIZE_OF_POOL_KEY]=oss.str(); + if(!_initScript.empty()) + ret[INITIALIZE_SCRIPT_KEY]=_initScript; + return ret; } -void SalomeHPContainerShared::start(const Task *askingNode) throw(YACS::Exception) +std::map SalomeHPContainer::getResourceProperties(const std::string& name) const { - SalomeContainerToolsSpreadOverTheResDecorator sct(&getTheBoss()->getContainerInfo(),_pd->getPlayGround(),_launchModeType,askingNode); - startInternal(askingNode,sct,getTheBoss()->getComponentNames()); + return _sct.getResourceProperties(name); } -void SalomeHPContainerShared::allocateFor(const std::vector& nodes) +void SalomeHPContainer::checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception) { - _launchModeType->allocateForAmong(_idsOfKernelContainers,nodes); + if(inst->getKind()!=SalomeHPComponent::KIND) + throw Exception("SalomeHPContainer::checkCapabilityToDealWith : SalomeContainer is not able to deal with this type of ComponentInstance."); } -std::size_t SalomeHPContainerShared::getNumberOfFreePlace() const +std::vector SalomeHPContainer::getKernelContainerNames() const { - return _launchModeType->getNumberOfFreePlaceAmong(_idsOfKernelContainers); + throw Exception("FIXME"); + //return _launchModeType->getKernelContainerNames(); } -void SalomeHPContainerShared::forYourTestsOnly(ForTestOmlyHPContCls *data) const +int SalomeHPContainer::getNumberOfCoresPerWorker() const { - data->setContainerType("HPContainerShared"); - data->setPD(_pd); - data->setIDS(_idsOfKernelContainers); -} - -/* - * SalomeHPContainerVectOfHelper is an holder of vector of SalomeContainerMonoHelper (holding itself a Kernel Container) - * SalomeContainerTools is a Engines::ContainerParameters holder. It is the data keeper for GiveContainer invokation. - * - */ + throw Exception("FIXME"); + //return _sct.getNumberOfCoresPerWorker(); +} \ No newline at end of file