#include <SalomeHPContainerTools.hxx>

Collaboration diagram for YACS::ENGINE::SalomeHPContainerVectOfHelper:

[legend]

Public Member Functions
std::size_t	size () const

void	resize (std::size_t sz)

std::size_t	getNumberOfFreePlace () const

void	allocateFor (const std::vector< const Task * > &nodes)

void	allocateForCrude (const std::vector< std::pair< const Task *, std::size_t >> &nodes)

std::size_t	release (const Task *node)

std::size_t	locateTask (const Task *node) const

const SalomeContainerMonoHelper *	at (std::size_t pos) const

SalomeContainerMonoHelper *	at (std::size_t pos)

const SalomeContainerMonoHelper *	getHelperOfTaskThreadSafe (const SalomeHPContainer cont, const Task node) const

const SalomeContainerMonoHelper *	getHelperOfTask (const Task *node) const

SalomeContainerMonoHelper *	getHelperOfTaskThreadSafe (SalomeHPContainer cont, const Task node)

SalomeContainerMonoHelper *	getHelperOfTask (const Task *node)

std::vector< std::string >	getKernelContainerNames (const SalomeHPContainer *cont) const

Private Member Functions
void	checkNoCurrentWork () const

void	checkPosInVec (std::size_t pos) const

Private Attributes
std::vector< bool >	_whichOccupied

std::vector< BASES::AutoRefCnt< YACS::ENGINE::SalomeContainerMonoHelper > >	_launchModeType

std::map< const Task *, std::size_t >	_currentlyWorking

Detailed Description

Definition at line 38 of file SalomeHPContainerTools.hxx.

Member Function Documentation

◆ allocateFor()

void SalomeHPContainerVectOfHelper::allocateFor ( const std::vector< const Task * > & nodes )

Definition at line 47 of file SalomeHPContainerTools.cxx.

 {
   for(std::vector<const Task *>::const_iterator it=nodes.begin();it!=nodes.end();it++)
     {
       if(!(*it))
         continue;
       if(_currentlyWorking.find(*it)!=_currentlyWorking.end())
         throw Exception("Searching to allocate for a ServiceNode instance already declared as allocated !");
       std::vector<bool>::iterator it2(std::find(_whichOccupied.begin(),_whichOccupied.end(),false));
       if(it2==_whichOccupied.end())
         throw Exception("All ressources are already occupied ! You are expected to wait for released resources !");
       std::size_t pos(std::distance(_whichOccupied.begin(),it2));
       _currentlyWorking[*it]=pos; _whichOccupied[pos]=true;
     }
 }

References _currentlyWorking, _whichOccupied, and gui.graph::distance().

◆ allocateForCrude()

void SalomeHPContainerVectOfHelper::allocateForCrude ( const std::vector< std::pair< const Task *, std::size_t >> & nodes )

Definition at line 63 of file SalomeHPContainerTools.cxx.

 {
   for(auto it : nodes)
     {
       std::size_t workerId(it.second);
       if(workerId>=size())
         throw Exception("SalomeHPContainerVectOfHelper::allocateForCrude : Internal error ! WorkerId is greater or equal to size of HPCont !");
       if(_whichOccupied[workerId])
         throw Exception("SalomeHPContainerVectOfHelper::allocateForCrude : Mismatch between Playground info and HPContainer info !");
     }
   for(auto it : nodes)
     {
       const Task *task(it.first);
       std::size_t workerId(it.second);
       _currentlyWorking[task]=workerId;
       _whichOccupied[workerId]=true;
     }
 }

References _currentlyWorking, _whichOccupied, and size().

Referenced by YACS::ENGINE::SalomeHPContainer::allocateFor().

◆ at() [1/2]

SalomeContainerMonoHelper* YACS::ENGINE::SalomeHPContainerVectOfHelper::at ( std::size_t pos )

inline

Definition at line 49 of file SalomeHPContainerTools.hxx.

49 { checkPosInVec(pos); return _launchModeType[pos]; }

YACS::ENGINE::SalomeHPContainerVectOfHelper::_launchModeType

std::vector< BASES::AutoRefCnt< YACS::ENGINE::SalomeContainerMonoHelper > > _launchModeType

Definition: SalomeHPContainerTools.hxx:60

YACS::ENGINE::SalomeHPContainerVectOfHelper::checkPosInVec

void checkPosInVec(std::size_t pos) const

Definition: SalomeHPContainerTools.cxx:151

References _launchModeType, and checkPosInVec().

◆ at() [2/2]

const SalomeContainerMonoHelper* YACS::ENGINE::SalomeHPContainerVectOfHelper::at ( std::size_t pos ) const

inline

Definition at line 48 of file SalomeHPContainerTools.hxx.

48 { checkPosInVec(pos); return _launchModeType[pos]; }

References _launchModeType, and checkPosInVec().

Referenced by YACS::ENGINE::SalomeHPContainer::shutdown().

◆ checkNoCurrentWork()

void SalomeHPContainerVectOfHelper::checkNoCurrentWork ( ) const

private

Definition at line 141 of file SalomeHPContainerTools.cxx.

 {
   for(std::map<const Task *,std::size_t >::const_iterator it=_currentlyWorking.begin();it!=_currentlyWorking.end();it++)
     if((*it).first)
       throw Exception("Something wrong a node is still declared to be using the ressource !");
   for(std::vector< YACS::BASES::AutoRefCnt<SalomeContainerMonoHelper> >::const_iterator it=_launchModeType.begin();it!=_launchModeType.end();it++)
     if((*it)->isAlreadyStarted(0))
       throw Exception("Some of the containers have be started ! Please shutdown them before !");
 }

References _currentlyWorking, and _launchModeType.

Referenced by resize().

◆ checkPosInVec()

void SalomeHPContainerVectOfHelper::checkPosInVec ( std::size_t pos ) const

private

Definition at line 151 of file SalomeHPContainerTools.cxx.

 {
   if(pos<0 || pos>=_launchModeType.size())
     throw Exception("The task has been found, but its id is not in the correct range ! resize of of container size during run ?");
 }

References _launchModeType.

Referenced by at(), and locateTask().

◆ getHelperOfTask() [1/2]

SalomeContainerMonoHelper * SalomeHPContainerVectOfHelper::getHelperOfTask ( const Task * node )

Definition at line 121 of file SalomeHPContainerTools.cxx.

 {
   return _launchModeType[locateTask(node)];
 }

References _launchModeType, and locateTask().

◆ getHelperOfTask() [2/2]

const SalomeContainerMonoHelper * SalomeHPContainerVectOfHelper::getHelperOfTask ( const Task * node ) const

Definition at line 110 of file SalomeHPContainerTools.cxx.

 {
   return _launchModeType[locateTask(node)];
 }

References _launchModeType, and locateTask().

Referenced by YACS::ENGINE::SalomeHPContainer::getFullPlacementId(), and YACS::ENGINE::SalomeHPContainer::getPlacementId().

◆ getHelperOfTaskThreadSafe() [1/2]

const SalomeContainerMonoHelper * SalomeHPContainerVectOfHelper::getHelperOfTaskThreadSafe	(	const SalomeHPContainer *	cont,
		const Task *	node
	)		const

Definition at line 104 of file SalomeHPContainerTools.cxx.

 {
   YACS::BASES::AutoLocker<Container> alck(const_cast<SalomeHPContainer *>(cont));
   return _launchModeType[locateTask(node)];
 }

References _launchModeType, and locateTask().

Referenced by YACS::ENGINE::SalomeHPContainer::isAlreadyStarted(), and YACS::ENGINE::SalomeHPContainer::start().

◆ getHelperOfTaskThreadSafe() [2/2]

SalomeContainerMonoHelper * SalomeHPContainerVectOfHelper::getHelperOfTaskThreadSafe	(	SalomeHPContainer *	cont,
		const Task *	node
	)

Definition at line 115 of file SalomeHPContainerTools.cxx.

 {
   YACS::BASES::AutoLocker<Container> alck(cont);
   return _launchModeType[locateTask(node)];
 }

References _launchModeType, and locateTask().

◆ getKernelContainerNames()

std::vector< std::string > SalomeHPContainerVectOfHelper::getKernelContainerNames ( const SalomeHPContainer * cont ) const

Definition at line 126 of file SalomeHPContainerTools.cxx.

 {
   std::vector<std::string> ret;
   {
     YACS::BASES::AutoLocker<Container> alck(const_cast<SalomeHPContainer *>(cont));
     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;
 }

References _launchModeType, and yacsorb.CORBAEngineTest::i.

Referenced by YACS::ENGINE::SalomeHPContainer::getKernelContainerNames().

◆ getNumberOfFreePlace()

std::size_t SalomeHPContainerVectOfHelper::getNumberOfFreePlace ( ) const

Definition at line 42 of file SalomeHPContainerTools.cxx.

 {
   return std::count(_whichOccupied.begin(),_whichOccupied.end(),false);
 }

References _whichOccupied.

◆ locateTask()

std::size_t SalomeHPContainerVectOfHelper::locateTask ( const Task * node ) const

Definition at line 94 of file SalomeHPContainerTools.cxx.

 {
   std::map< const Task *,std::size_t >::const_iterator it(_currentlyWorking.find(node));
   if(it==_currentlyWorking.end())
     throw Exception("current Node to be located is not marked as launched !");
   std::size_t ret((*it).second);
   checkPosInVec(ret);
   return ret;
 }

References _currentlyWorking, and checkPosInVec().

Referenced by getHelperOfTask(), getHelperOfTaskThreadSafe(), and YACS::ENGINE::SalomeContainerToolsDecorator::getParameters().

◆ release()

std::size_t SalomeHPContainerVectOfHelper::release ( const Task * node )

Definition at line 82 of file SalomeHPContainerTools.cxx.

 {
   if(!node)
     return std::numeric_limits<std::size_t>::max();
   std::map< const Task *,std::size_t >::iterator it(_currentlyWorking.find(node));
   if(it==_currentlyWorking.end())
     throw Exception("Request to release a resource not declared as working !");
   _whichOccupied[(*it).second]=false;
   _currentlyWorking.erase(it);
   return (*it).second;
 }

References _currentlyWorking, and _whichOccupied.

Referenced by YACS::ENGINE::SalomeHPContainer::release().

◆ resize()

void SalomeHPContainerVectOfHelper::resize ( std::size_t sz )

Definition at line 29 of file SalomeHPContainerTools.cxx.

 {
   std::size_t oldSize(_launchModeType.size());
   if(sz==oldSize)
     return;
   checkNoCurrentWork();
   _whichOccupied.resize(sz); std::fill(_whichOccupied.begin(),_whichOccupied.end(),false);
   _launchModeType.resize(sz);
   for(std::size_t i=oldSize;i<sz;i++)
       _launchModeType[i]=new SalomeContainerMonoHelper;
   _currentlyWorking.clear();
 }