#include <PlayGround.hxx>

Inheritance diagram for YACS::ENGINE::PlayGround:

Collaboration diagram for YACS::ENGINE::PlayGround:

[legend]

Public Member Functions
	PlayGround (const std::vector< std::pair< std::string, int > > &defOfRes)

	PlayGround ()

std::string	printSelf () const

void	loadFromKernelCatalog ()

std::vector< std::pair< std::string, int > >	getData () const

void	setData (const std::vector< std::pair< std::string, int > > &defOfRes)

int	getNumberOfCoresAvailable () const

int	getMaxNumberOfContainersCanBeHostedWithoutOverlap (int nbCoresPerCont) const

std::vector< int >	computeOffsets () const

std::vector< YACS::BASES::AutoRefCnt< PartDefinition > >	partition (const std::vector< std::pair< const PartDefinition , const ComplexWeight > > &parts, const std::vector< int > &nbCoresPerShot) const

int	fromWorkerIdToResId (int workerId, int nbProcPerNode) const

std::string	deduceMachineFrom (int workerId, int nbProcPerNode) const

int	getNumberOfWorkers (int nbCoresPerWorker) const

void	highlightOnIds (const std::vector< int > &coreIds, std::vector< bool > &v) const

std::vector< bool >	getFetchedCores (int nbCoresPerWorker) const

std::vector< std::size_t >	getWorkerIdsFullyFetchedBy (int nbCoresPerComp, const std::vector< bool > &coreFlags) const

std::size_t	getNumberOfFreePlace (int nbCoresPerCont) const

std::vector< std::size_t >	allocateFor (std::size_t nbOfPlacesToTake, int nbCoresPerCont) const

void	release (std::size_t workerId, int nbCoresPerCont) const

std::mutex &	getLocker () const

void	printMe () const

Public Member Functions inherited from YACS::ENGINE::RefCounter
unsigned int	getRefCnt () const

void	incrRef () const

bool	decrRef () const

Static Public Member Functions
static std::vector< int >	BuildVectOfIdsFromVecBool (const std::vector< bool > &v)

static std::vector< int >	GetIdsMatching (const std::vector< bool > &bigArr, const std::vector< bool > &pat)

Private Member Functions
std::vector< std::pair< const ComplexWeight *, int > >	bigToTiny (const std::vector< std::pair< const ComplexWeight *, int > > &weights, std::map< int, int > &saveOrder) const

std::vector< std::vector< int > >	backToOriginalOrder (const std::vector< std::vector< int > > &disorderVec, const std::map< int, int > &saveOrder) const

int	getCriticalPath (const std::vector< std::pair< const ComplexWeight *, int > > &weights, const std::vector< int > &maxNbOfCores) const

std::vector< std::vector< int > >	splitIntoParts (const std::vector< int > &coreIds, const std::vector< std::pair< const ComplexWeight *, int > > &weights) const

std::vector< int >	takePlace (int maxNbOfCoresToAlloc, int nbCoresPerShot, std::vector< bool > &distributionOfCores, bool lastOne=false) const

void	checkCoherentInfo () const

	~PlayGround ()

Private Attributes
std::mutex	_locker

std::vector< Resource >	_data

Additional Inherited Members
Static Public Attributes inherited from YACS::ENGINE::RefCounter
static unsigned int	_totalCnt =0

Protected Member Functions inherited from YACS::ENGINE::RefCounter
	RefCounter ()

	RefCounter (const RefCounter &other)

virtual	~RefCounter ()

Protected Attributes inherited from YACS::ENGINE::RefCounter
unsigned int	_cnt

Detailed Description

Definition at line 76 of file PlayGround.hxx.

Constructor & Destructor Documentation

◆ PlayGround() [1/2]

YACS::ENGINE::PlayGround::PlayGround ( const std::vector< std::pair< std::string, int > > & defOfRes )

inline

Definition at line 79 of file PlayGround.hxx.

79 :_data(defOfRes.begin(),defOfRes.end()) { checkCoherentInfo(); }

YACS::ENGINE::PlayGround::checkCoherentInfo

void checkCoherentInfo() const

Definition: PlayGround.cxx:157

YACS::ENGINE::PlayGround::_data

std::vector< Resource > _data

Definition: PlayGround.hxx:115

◆ PlayGround() [2/2]

YACS::ENGINE::PlayGround::PlayGround ( )

inline

Definition at line 80 of file PlayGround.hxx.

80 { }

◆ ~PlayGround()

PlayGround::~PlayGround ( )

private

Definition at line 584 of file PlayGround.cxx.

585 {

586 }

Member Function Documentation

◆ allocateFor()

std::vector< std::size_t > PlayGround::allocateFor	(	std::size_t	nbOfPlacesToTake,
		int	nbCoresPerCont
	)		const

Definition at line 194 of file PlayGround.cxx.

 {
   std::vector<std::size_t> ret;
   std::size_t nbOfPlacesToTakeCpy(nbOfPlacesToTake),offset(0);
   for(const auto& res : _data)
     {
       std::vector<std::size_t> contIdsInRes(res.allocateFor(nbOfPlacesToTakeCpy,nbCoresPerCont));
       std::for_each(contIdsInRes.begin(),contIdsInRes.end(),[offset](std::size_t& val) { val += offset; });
       ret.insert(ret.end(),contIdsInRes.begin(),contIdsInRes.end());
       offset += static_cast<std::size_t>(res.nbCores()/nbCoresPerCont);
     }
   if( ( nbOfPlacesToTakeCpy!=0 ) || ( ret.size()!=nbOfPlacesToTake ) )
     throw Exception("PlayGround::allocateFor : internal error ! Promised place is not existing !");
   return ret;
 }

References _data.

◆ backToOriginalOrder()

std::vector< std::vector< int > > PlayGround::backToOriginalOrder	(	const std::vector< std::vector< int > > &	disorderVec,
		const std::map< int, int > &	saveOrder
	)		const

private

Definition at line 451 of file PlayGround.cxx.

 {
   std::vector< std::vector<int> > ret;
   std::size_t sz(disorderVec.size());
   if (disorderVec.size()!=saveOrder.size())
     throw Exception("PlayGround::backToOriginalOrder : incoherent vector size !");
   for (int i=0; i<sz; i++)
       ret.push_back(disorderVec[saveOrder.at(i)]);
   return ret;
 }

References yacsorb.CORBAEngineTest::i.

Referenced by splitIntoParts().

◆ bigToTiny()

std::vector< std::pair< const ComplexWeight *, int > > PlayGround::bigToTiny	(	const std::vector< std::pair< const ComplexWeight *, int > > &	weights,
		std::map< int, int > &	saveOrder
	)		const

private

Definition at line 427 of file PlayGround.cxx.

 {
   int maxCoresPerShot(0), rankMax(0);
   int i(0);
   std::vector< std::pair <const ComplexWeight *, int> > ret;
   std::size_t sz(weights.size());
   while (ret.size()<sz)
     {
       for(std::vector<std::pair <const ComplexWeight *, int> >::const_iterator it=weights.begin();it!=weights.end();it++,i++)
         {
           if ((maxCoresPerShot<(*it).second) && (saveOrder.find(i)==saveOrder.end()))
             {
               maxCoresPerShot=(*it).second;
               rankMax=i;
             }
         }
       ret.push_back(std::pair <const ComplexWeight *, int>(weights[rankMax].first,weights[rankMax].second));
       saveOrder[rankMax]=ret.size()-1;
       maxCoresPerShot=0;
       i=0;
     }
   return ret;   
 }

References yacsorb.CORBAEngineTest::i.

Referenced by splitIntoParts().

◆ BuildVectOfIdsFromVecBool()

std::vector< int > PlayGround::BuildVectOfIdsFromVecBool ( const std::vector< bool > & v )

static

Definition at line 234 of file PlayGround.cxx.

 {
   std::size_t sz(std::count(v.begin(),v.end(),true)),i(0);
   std::vector<int> ret(sz);
   std::vector<bool>::const_iterator it(v.begin());
   while(i<sz)
     {
       it=std::find(it,v.end(),true);
       ret[i++]=std::distance(v.begin(),it);
       it++;
     }
   return ret;
 }

References gui.graph::distance(), and yacsorb.CORBAEngineTest::i.

Referenced by partition(), and YACS::ENGINE::PartDefinition::stashPart().

◆ checkCoherentInfo()

void PlayGround::checkCoherentInfo ( ) const

private

Definition at line 157 of file PlayGround.cxx.

 {
   std::set<std::string> s;
   for(auto it : _data)
     {
       s.insert(it.name());
       if(it.nbCores()<0)
         throw Exception("Presence of negative int value !");
     }
   if(s.size()!=_data.size())
     throw Exception("host names entries must be different each other !");
 }

References _data.

Referenced by setData().

◆ computeOffsets()

std::vector< int > PlayGround::computeOffsets ( ) const

Definition at line 148 of file PlayGround.cxx.

 {
   std::size_t sz(_data.size()),i(0);
   std::vector<int> ret(sz+1); ret[0]=0;
   for(auto it=_data.begin();it!=_data.end();it++,i++)
     ret[i+1]=ret[i]+it->nbCores();
   return ret;
 }

References _data, and yacsorb.CORBAEngineTest::i.

Referenced by takePlace().

◆ deduceMachineFrom()

std::string PlayGround::deduceMachineFrom	(	int	workerId,
		int	nbProcPerNode
	)		const

you must garantee coherence between PlayGround::deduceMachineFrom, PlayGround::getNumberOfWorkers, and PartDefinition::computeWorkerIdsCovered

Definition at line 570 of file PlayGround.cxx.

 {
   int zePos(fromWorkerIdToResId(workerId,nbProcPerNode));
   return _data[zePos].name();
 }

References _data, and fromWorkerIdToResId().

Referenced by YACS::ENGINE::SalomeContainerToolsDecorator::getParameters().

◆ fromWorkerIdToResId()

int PlayGround::fromWorkerIdToResId	(	int	workerId,
		int	nbProcPerNode
	)		const

Definition at line 553 of file PlayGround.cxx.

 {
   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].nbCores())/nbProcPerNode;
   int zePos(0);
   while(zePos<sz2 && (workerId<deltas[zePos] || workerId>=deltas[zePos+1]))
     zePos++;
   if(zePos==sz2)
     zePos=workerId%sz2;
   return zePos;
 }

References _data, and yacsorb.CORBAEngineTest::i.

Referenced by deduceMachineFrom().

◆ getCriticalPath()

int PlayGround::getCriticalPath	(	const std::vector< std::pair< const ComplexWeight *, int > > &	weights,
		const std::vector< int > &	maxNbOfCores
	)		const

private

Definition at line 462 of file PlayGround.cxx.

 {
   double maxWeight(0.);
   double pathWeight(0.);
   int rankMaxPath(-1);
   if ((weights.size()!=nbOfCoresAllocated.size()) || (weights.size()==0))
     throw Exception("PlayGround::getCriticalPath : internal error !");
   int i=0;
   for(std::vector<std::pair <const ComplexWeight *, int> >::const_iterator it=weights.begin();it!=weights.end();it++,i++)
     {
       if (nbOfCoresAllocated[i]==0)
         throw Exception("PlayGround::getCriticalPath : nbOfCoresAllocated is null! error !");
       if (!(*it).first->isDefaultValue())
         {
               pathWeight=(*it).first->calculateTotalLength(nbOfCoresAllocated[i]);
               if (pathWeight > maxWeight)
                 {
                   maxWeight=pathWeight;
                   rankMaxPath=i;
                 }
         }         
     }
   return rankMaxPath;
 } 

References yacsorb.CORBAEngineTest::i.

Referenced by splitIntoParts().

◆ getData()

std::vector< std::pair<std::string,int> > YACS::ENGINE::PlayGround::getData ( ) const

inline

Definition at line 83 of file PlayGround.hxx.

83 { return std::vector< std::pair<std::string,int> >(ResourceIterator(&_data,0),ResourceIterator(&_data,_data.size())); }

◆ getFetchedCores()

std::vector<bool> YACS::ENGINE::PlayGround::getFetchedCores ( int nbCoresPerWorker ) const

◆ GetIdsMatching()

std::vector< int > PlayGround::GetIdsMatching	(	const std::vector< bool > &	bigArr,
		const std::vector< bool > &	pat
	)

static

Definition at line 170 of file PlayGround.cxx.

 {
   std::vector<int> ret;
   std::size_t szp(pat.size());
   std::size_t sz(bigArr.size()/szp);
   for(std::size_t i=0;i<sz;i++)
     {
       std::vector<bool> t(bigArr.begin()+i*szp,bigArr.begin()+(i+1)*szp);
       if(t==pat)
         ret.push_back(i);
     }
   return ret;
 }

References yacsorb.CORBAEngineTest::i, and gui.Appli::t.

Referenced by partition().

◆ getLocker()

std::mutex& YACS::ENGINE::PlayGround::getLocker ( ) const

inline

Definition at line 101 of file PlayGround.hxx.

101 { return _locker; }

YACS::ENGINE::PlayGround::_locker

std::mutex _locker

Definition: PlayGround.hxx:114

◆ getMaxNumberOfContainersCanBeHostedWithoutOverlap()

int PlayGround::getMaxNumberOfContainersCanBeHostedWithoutOverlap ( int nbCoresPerCont ) const

Definition at line 138 of file PlayGround.cxx.

 {
   if(nbCoresPerCont<1)
     throw Exception("PlayGround::getMaxNumberOfContainersCanBeHostedWithoutOverlap : invalid nbCoresPerCont. Must be >=1 !");
   int ret(0);
   for(auto it : _data)
     ret+=it.nbCores()/nbCoresPerCont;
   return ret;
 }

References _data.

Referenced by getNumberOfWorkers().

◆ getNumberOfCoresAvailable()

int PlayGround::getNumberOfCoresAvailable ( ) const

Definition at line 130 of file PlayGround.cxx.

 {
   int ret(0);
   for(auto it : _data)
     ret+=it.nbCores();
   return ret;
 }

References _data.

Referenced by YACS::ENGINE::PartDefinition::BuildFrom(), YACS::ENGINE::Bloc::fitToPlayGround(), highlightOnIds(), partition(), and splitIntoParts().

◆ getNumberOfFreePlace()

std::size_t PlayGround::getNumberOfFreePlace ( int nbCoresPerCont ) const

Definition at line 184 of file PlayGround.cxx.

 {
   std::size_t ret(0);
   for(auto res : _data)
     {
       ret += res.getNumberOfFreePlace(nbCoresPerCont);
     }
   return ret;
 }

References _data.

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

◆ getNumberOfWorkers()

int PlayGround::getNumberOfWorkers ( int nbCoresPerWorker ) const

you must garantee coherence between PlayGround::deduceMachineFrom, PlayGround::getNumberOfWorkers, PlayGround::getFetchedCores and PartDefinition::computeWorkerIdsCovered

Definition at line 579 of file PlayGround.cxx.

 {
   return getMaxNumberOfContainersCanBeHostedWithoutOverlap(nbCoresPerWorker);
 }

References getMaxNumberOfContainersCanBeHostedWithoutOverlap().

Referenced by YACS::ENGINE::Bloc::fitToPlayGround(), and YACS::ENGINE::SalomeContainerToolsDecorator::getParameters().

◆ getWorkerIdsFullyFetchedBy()

std::vector< std::size_t > PlayGround::getWorkerIdsFullyFetchedBy	(	int	nbCoresPerComp,
		const std::vector< bool > &	coreFlags
	)		const

you must garantee coherence between PlayGround::deduceMachineFrom, PlayGround::getNumberOfWorkers, and PartDefinition::computeWorkerIdsCovered

follow getMaxNumberOfContainersCanBeHostedWithoutOverlap method

Definition at line 280 of file PlayGround.cxx.

 {
   std::size_t posBg(0),posWorker(0);
   std::vector<std::size_t> ret;
   for(auto it : _data)
     {
       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.nbCores();
     }
   return ret;
 }

References _data.

◆ highlightOnIds()

void PlayGround::highlightOnIds	(	const std::vector< int > &	coreIds,
		std::vector< bool > &	v
	)		const

Definition at line 248 of file PlayGround.cxx.

 {
   if(v.size()!=getNumberOfCoresAvailable())
     throw Exception("PlayGround::highlightOnIds : oops ! invalid size !");
   for(std::vector<int>::const_iterator it=coreIds.begin();it!=coreIds.end();it++)
     v[*it]=true;
 }

References getNumberOfCoresAvailable().

Referenced by splitIntoParts().

◆ loadFromKernelCatalog()

void PlayGround::loadFromKernelCatalog ( )

Definition at line 115 of file PlayGround.cxx.

 {
   Runtime *r(getRuntime());
   if(!r)
     throw Exception("PlayGround::loadFromKernelCatalog : no runtime  !");
   std::vector< std::pair<std::string,int> > data(r->getCatalogOfComputeNodes());
   setData(data);
 }

References YACS::ENGINE::getRuntime(), testCppPluginInvokation::r, and setData().

◆ partition()

std::vector< YACS::BASES::AutoRefCnt< PartDefinition > > PlayGround::partition	(	const std::vector< std::pair< const PartDefinition , const ComplexWeight > > &	parts,
		const std::vector< int > &	nbCoresPerShot
	)		const

Definition at line 298 of file PlayGround.cxx.

 {
   std::size_t sz(parts.size()),szs(getNumberOfCoresAvailable());
   if (sz!=nbCoresPerShot.size())
     throw Exception("PlayGround::partition : incoherent vector size !");
   if(sz==0)
     return std::vector< YACS::BASES::AutoRefCnt<PartDefinition> >();
   if(sz==1)
     {
       const PartDefinition *pd(parts[0].first);
       if(!pd)
         throw Exception("Presence of null pointer as part def  0 !");
       YACS::BASES::AutoRefCnt<PartDefinition> ret(pd->copy());
       std::vector< YACS::BASES::AutoRefCnt<PartDefinition> > ret2(1,ret);
       return ret2;
     }
   if(sz>31)
     throw Exception("PlayGround::partition : not implemented yet for more than 31 ! You need to pay for it :)");
   std::vector<bool> zeArr(szs*sz,false);
   std::size_t i(0);
   for(std::vector< std::pair<const PartDefinition *, const ComplexWeight *> >::const_iterator it=parts.begin();it!=parts.end();it++,i++)
     {
       const PartDefinition *pd((*it).first);
       if(!pd)
         throw Exception("Presence of null pointer as part def !");
       if(pd->getPlayGround()!=this)
         throw Exception("Presence of non homogeneous playground !");
       std::vector<bool> bs(pd->getCoresOn()); // tab of length nbCores, with True or False for each Core
       for(std::size_t j=0;j<szs;j++)
         zeArr[j*sz+i]=bs[j]; // remplis une table avec les valeurs de bs. La table est [nb part] * [nb cores]
     }
   std::vector< std::vector<int> > retIds(sz);
   for(std::size_t i=0;i<szs;i++)
     {
       std::vector<bool> code(zeArr.begin()+i*sz,zeArr.begin()+(i+1)*sz);// vecteur contenant le true/false d'un coeur pour ttes les partitions
       std::vector<int> locIds(GetIdsMatching(zeArr,code)); // liste des coeurs qui peuvent correspondre au pattern code
       std::vector<int> partsIds(BuildVectOfIdsFromVecBool(code));// pour chaque partition retourne l'id de la premiere partition à true
       if(partsIds.empty())
         continue;
       std::vector<std::pair <const ComplexWeight *, int> > wg;
       for(std::vector<int>::const_iterator it=partsIds.begin();it!=partsIds.end();it++)
         {
           wg.push_back(std::pair <const ComplexWeight *, int> (parts[*it].second, nbCoresPerShot[*it]));
         }
       std::vector< std::vector<int> > ress(splitIntoParts(locIds,wg));
       std::size_t k(0);
       for(std::vector<int>::const_iterator it=partsIds.begin();it!=partsIds.end();it++,k++)
         {
           retIds[*it].insert(retIds[*it].end(),ress[k].begin(),ress[k].end());
         }
     }
   //
   std::vector< YACS::BASES::AutoRefCnt<PartDefinition> > ret(sz);
   for(std::size_t i=0;i<sz;i++)
     {
       std::set<int> s(retIds[i].begin(),retIds[i].end());
       std::vector<int> v(s.begin(),s.end());
       ret[i]=PartDefinition::BuildFrom(this,v);
     }
   return ret;
 }

References YACS::ENGINE::PartDefinition::BuildFrom(), BuildVectOfIdsFromVecBool(), YACS::ENGINE::PartDefinition::copy(), YACS::ENGINE::PartDefinition::getCoresOn(), GetIdsMatching(), getNumberOfCoresAvailable(), YACS::ENGINE::PartDefinition::getPlayGround(), yacsorb.CORBAEngineTest::i, and splitIntoParts().

Referenced by YACS::ENGINE::ForkBlocPoint::partitionRegardingDPL().

◆ printMe()

void PlayGround::printMe ( ) const

Definition at line 225 of file PlayGround.cxx.

 {
   for(auto it : _data)
   {
     it.printSelf(std::cout);
     std::cout << std::endl;
   }
 }

References _data.

◆ printSelf()

std::string PlayGround::printSelf ( ) const

Definition at line 102 of file PlayGround.cxx.

 {
   std::ostringstream oss;
   std::size_t sz(0);
   for(auto it : _data)
     sz=std::max(sz,it.name().length());
   for(auto it : _data)
     {
       oss << " - " << std::setw(10) << it.name() << " : " << it.nbCores() << std::endl;
     }
   return oss.str();
 }

References _data.

◆ release()

void PlayGround::release	(	std::size_t	workerId,
		int	nbCoresPerCont
	)		const

Definition at line 210 of file PlayGround.cxx.

 {
   std::size_t offset(0);
   for(const auto& res : _data)
     {
       std::size_t nbOfWorker(static_cast<std::size_t>(res.nbCores()/nbCoresPerCont));
       std::size_t minId(offset),maxId(offset+nbOfWorker);
       if(workerId>=minId && workerId<maxId)
         {
           res.release(workerId-minId,nbCoresPerCont);
           break;
         }
     }
 }

References _data.

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

◆ setData()

void PlayGround::setData ( const std::vector< std::pair< std::string, int > > & defOfRes )

Definition at line 124 of file PlayGround.cxx.

 {
   _data=std::vector<Resource>(defOfRes.begin(),defOfRes.end());
   checkCoherentInfo();
 }

References _data, and checkCoherentInfo().

Referenced by loadFromKernelCatalog().

◆ splitIntoParts()

std::vector< std::vector< int > > PlayGround::splitIntoParts	(	const std::vector< int > &	coreIds,
		const std::vector< std::pair< const ComplexWeight *, int > > &	weights
	)		const

private

Definition at line 360 of file PlayGround.cxx.

 {
   std::size_t sz(weights.size());
   if(sz==0)
     return std::vector< std::vector<int> >();
   std::vector< std::vector<int> > ret;
   std::vector< std::vector<int> > disorderRet(sz);
   std::vector<bool> zeArr(getNumberOfCoresAvailable(),false);
   highlightOnIds(coreIds,zeArr);
   int nbOfCoresToSplit(coreIds.size());
   int totalSpace(coreIds.size());
   int remainingSpace(totalSpace);
   std::vector<int> nbOfCoresAllocated(sz);
   std::vector<int> nbCoresPerShot(sz,-1);  
   // first every other branchs take its minimal part of the cake
   // and remove branch without valid weight
   int i(0);
   std::map<int,int> saveOrder;
   const std::vector< std::pair <const ComplexWeight *, int> > sortedWeights(bigToTiny(weights, saveOrder));
   for(std::vector<std::pair <const ComplexWeight *, int> >::const_iterator it=sortedWeights.begin();it!=sortedWeights.end();it++,i++)
     {
       nbCoresPerShot[i]=(*it).second;
       if ((*it).first->isUnsetLoopWeight())
         {
           nbOfCoresAllocated[i]=nbCoresPerShot[i]; // branch with only elementary nodes
         }
       else if (!(*it).first->hasValidLoopWeight())
         {
           nbOfCoresAllocated[i]=std::max((int)((double)totalSpace/(double)(sz)), nbCoresPerShot[i]); // branch with undefined weight, takes his part proportionnally to the number of branchs
         }
       else
         {
           nbOfCoresAllocated[i]=nbCoresPerShot[i];
         }
     }
   remainingSpace-=std::accumulate(nbOfCoresAllocated.begin(), nbOfCoresAllocated.end(), 0);
   //get critical path (between path with loopWeight)
   int criticalPathRank=getCriticalPath(sortedWeights, nbOfCoresAllocated);
   if (criticalPathRank!=-1)
     {
       // add cores to critical path while enough cores are availables
           while (remainingSpace >= nbCoresPerShot[criticalPathRank])
             {
               nbOfCoresAllocated[criticalPathRank]+=nbCoresPerShot[criticalPathRank];
               remainingSpace-=nbCoresPerShot[criticalPathRank];
               criticalPathRank=getCriticalPath(sortedWeights, nbOfCoresAllocated);
             }
           //fill other paths with remaining cores (if possible) (reuse fromBigToTiny here?)
           // and takePlace
           int coresToAdd;
           int j(0);
           for(std::vector<int>::iterator it=nbOfCoresAllocated.begin();it!=nbOfCoresAllocated.end();it++,j++)
             {
               coresToAdd=((int)(remainingSpace/nbCoresPerShot[j]))*nbCoresPerShot[j];
               *it+=coresToAdd;
               remainingSpace-=coresToAdd;
             }
     }
   int k(0);
   for(std::vector<int>::iterator it=nbOfCoresAllocated.begin();it!=nbOfCoresAllocated.end();it++,k++)
     {
       disorderRet[k]=takePlace(*it,nbCoresPerShot[k],zeArr,k==(sz-1));
     }   
   ret=backToOriginalOrder(disorderRet, saveOrder);
   return ret;
 }

References backToOriginalOrder(), bigToTiny(), getCriticalPath(), getNumberOfCoresAvailable(), highlightOnIds(), yacsorb.CORBAEngineTest::i, and takePlace().

Referenced by partition().

◆ takePlace()

std::vector< int > PlayGround::takePlace	(	int	maxNbOfCoresToAlloc,
		int	nbCoresPerShot,
		std::vector< bool > &	distributionOfCores,
		bool	lastOne = `false`
	)		const

private

Definition at line 487 of file PlayGround.cxx.

 {
   if(maxNbOfCoresToAlloc<1)
     throw Exception("PlayGround::takePlace : internal error ! no space to alloc !");
   int tmpMaxNbOfCoresToAlloc(maxNbOfCoresToAlloc);
   if(lastOne)
     tmpMaxNbOfCoresToAlloc=std::max(tmpMaxNbOfCoresToAlloc,(int)std::count(distributionOfCores.begin(),distributionOfCores.end(),true));
   std::vector<int> ret;
   std::vector<int> offsets(computeOffsets());
   int nbFullItem(0);
   std::size_t sz(offsets.size()-1);
   for(std::size_t i=0;i<sz && tmpMaxNbOfCoresToAlloc>=nbCoresPerShot;i++)
     {
       int d(offsets[i+1]-offsets[i]);
       if(nbCoresPerShot>d)
         continue;
       std::vector<bool> target(nbCoresPerShot,true);
       for(int j=0;j<=d-nbCoresPerShot && tmpMaxNbOfCoresToAlloc>=nbCoresPerShot;)
         {
           std::vector<bool> t(distributionOfCores.begin()+offsets[i]+j,distributionOfCores.begin()+offsets[i]+j+nbCoresPerShot);
           if(t==target)
             {
               nbFullItem++;
               tmpMaxNbOfCoresToAlloc-=nbCoresPerShot;
               std::fill(distributionOfCores.begin()+offsets[i]+j,distributionOfCores.begin()+offsets[i]+j+nbCoresPerShot,false);
               for(int k=offsets[i]+j;k<offsets[i]+j+nbCoresPerShot;k++)
                 ret.push_back(k);
               j+=nbCoresPerShot;
             }
           else
             j++;
         }
     }
   if(nbFullItem>0)
     return ret;
   if(nbCoresPerShot<=1)
     throw Exception("PlayGround::takePlace : internal error !");
   // not enough contiguous place. Find the first wider contiguous place
   for(int kk=std::min(nbCoresPerShot-1,tmpMaxNbOfCoresToAlloc);kk>=1;kk--)
     {
       for(std::size_t i=0;i<sz && tmpMaxNbOfCoresToAlloc>=kk;i++)
         {
           int d(offsets[i+1]-offsets[i]);
           if(kk>d)
             continue;
           std::vector<bool> target(kk,true);
           for(int j=0;j<=d-kk && tmpMaxNbOfCoresToAlloc>=kk;)
             {
               std::vector<bool> t(distributionOfCores.begin()+offsets[i]+j,distributionOfCores.begin()+offsets[i]+j+kk);
               if(t==target)
                 {
                   nbFullItem++;
                   tmpMaxNbOfCoresToAlloc-=kk;
                   std::fill(distributionOfCores.begin()+offsets[i]+j,distributionOfCores.begin()+offsets[i]+j+kk,false);
                   for(int k=offsets[i]+j;k<offsets[i]+j+kk;k++)
                     ret.push_back(k);
                   return ret;
                 }
               else
                 j++;
             }
         }
     }
   throw Exception("PlayGround::takePlace : internal error ! All cores are occupied !");
 }

References computeOffsets(), yacsorb.CORBAEngineTest::i, and gui.Appli::t.

Referenced by splitIntoParts().

Member Data Documentation

◆ _data

std::vector< Resource > YACS::ENGINE::PlayGround::_data

private

Definition at line 115 of file PlayGround.hxx.

Referenced by allocateFor(), checkCoherentInfo(), computeOffsets(), deduceMachineFrom(), fromWorkerIdToResId(), getMaxNumberOfContainersCanBeHostedWithoutOverlap(), getNumberOfCoresAvailable(), getNumberOfFreePlace(), getWorkerIdsFullyFetchedBy(), printMe(), printSelf(), release(), and setData().

◆ _locker

std::mutex YACS::ENGINE::PlayGround::_locker

mutableprivate

Definition at line 114 of file PlayGround.hxx.

The documentation for this class was generated from the following files:

src/engine/PlayGround.hxx
src/engine/PlayGround.cxx

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PlayGround() [1/2]

◆ PlayGround() [2/2]

◆ ~PlayGround()

Member Function Documentation

◆ allocateFor()

◆ backToOriginalOrder()

◆ bigToTiny()

◆ BuildVectOfIdsFromVecBool()

◆ checkCoherentInfo()

◆ computeOffsets()

◆ deduceMachineFrom()

◆ fromWorkerIdToResId()

◆ getCriticalPath()

◆ getData()

◆ getFetchedCores()

◆ GetIdsMatching()

◆ getLocker()

◆ getMaxNumberOfContainersCanBeHostedWithoutOverlap()

◆ getNumberOfCoresAvailable()

◆ getNumberOfFreePlace()

◆ getNumberOfWorkers()

◆ getWorkerIdsFullyFetchedBy()

◆ highlightOnIds()

◆ loadFromKernelCatalog()

◆ partition()

◆ printMe()

◆ printSelf()

◆ release()

◆ setData()

◆ splitIntoParts()

◆ takePlace()

Member Data Documentation

◆ _data

◆ _locker