#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