]> SALOME platform Git repositories - modules/yacs.git/blob - src/evalyfx/YACSEvalResource.cxx
Salome HOME
Deleted deprecated code
[modules/yacs.git] / src / evalyfx / YACSEvalResource.cxx
1 // Copyright (C) 2012-2016  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 // Author : Anthony Geay (EDF R&D)
20
21 #include "YACSEvalResource.hxx"
22
23 #include "DeploymentTree.hxx"
24 #include "Container.hxx"
25 #include "Exception.hxx"
26
27 #include "SalomeContainer.hxx"
28 #include "SalomeHPContainer.hxx"
29 #include "ComponentInstance.hxx"
30
31 #include "ResourcesManager.hxx"
32
33 #include <set>
34 #include <queue>
35 #include <sstream>
36 #include <iterator>
37 #include <algorithm>
38
39 const char YACSEvalVirtualYACSContainer::CONTAINER_NAME_KEY[]="container_name";
40
41 const char YACSEvalVirtualYACSContainer::CPU_CLOCK_KEY[]="cpu_clock";
42
43 const char YACSEvalVirtualYACSContainer::HOSTNAME_KEY[]="hostname";
44
45 const char YACSEvalVirtualYACSContainer::MEM_KEY[]="mem_mb";
46
47 const char YACSEvalVirtualYACSContainer::NB_NODE_KEY[]="nb_node";
48
49 const char YACSEvalVirtualYACSContainer::NB_PROC_PER_NODE_KEY[]="nb_proc_per_node";
50
51 const char YACSEvalVirtualYACSContainer::NB_RESOURCE_PROCS_KEY[]="nb_resource_procs";
52
53 const char YACSEvalVirtualYACSContainer::POLICY_KEY[]="policy";
54
55 const char YACSEvalVirtualYACSContainer::OS_KEY[]="OS";
56
57 /*!
58  * This class is here only to avoid "friend class YACSEvalListOfResources".
59  */
60 class YACSEvalResourceEff : public YACSEvalResource
61 {
62 public:
63   YACSEvalResourceEff(YACSEvalListOfResources *gf, const std::vector< YACS::ENGINE::Container * >& conts);
64 };
65
66 YACSEvalResourceEff::YACSEvalResourceEff(YACSEvalListOfResources *gf, const std::vector< YACS::ENGINE::Container * >& conts):YACSEvalResource(gf,conts)
67 {
68 }
69
70 void YACSEvalNonConstLocker::checkNonLocked() const
71 {
72   if(_isLocked)
73     throw YACS::Exception("YACSEvalNonConstLocker::checkNonLocked : this is locked and trying to invoke non-const method !");
74 }
75
76 void YACSEvalNonConstLocker::checkLocked() const
77 {
78   if(!_isLocked)
79     throw YACS::Exception("YACSEvalNonConstLocker::checkLocked : this is NOT locked whereas it should be !");
80 }
81
82 YACSEvalVirtualYACSContainer::YACSEvalVirtualYACSContainer():_gf(0),_cont(0)
83 {
84 }
85
86 void YACSEvalVirtualYACSContainer::set(YACSEvalResource *gf, YACS::ENGINE::Container *cont)
87 {
88   checkNonLocked();
89   _gf=gf;
90   if(_cont==cont)
91     return ;
92   if(_cont)
93     _cont->decrRef();
94   _cont=cont;
95   if(_cont)
96     _cont->incrRef();
97   _propertyMap=listOfPropertiesInYACSContainer();
98 }
99
100 YACSEvalVirtualYACSContainer::YACSEvalVirtualYACSContainer(YACSEvalResource *gf, YACS::ENGINE::Container *cont):_gf(gf),_cont(cont)
101 {
102   if(_cont)
103     _cont->incrRef();
104   _propertyMap=listOfPropertiesInYACSContainer();
105 }
106
107 YACSEvalVirtualYACSContainer::~YACSEvalVirtualYACSContainer()
108 {
109   if(_cont)
110     _cont->decrRef();
111 }
112
113 /*!
114  * \param [in,out] entry - Resource type instance to be updated with \a this.
115  */
116 void YACSEvalVirtualYACSContainer::aggregate(ParserResourcesType& entry) const
117 {
118   if(entry.HostName.empty())
119     entry.HostName=getHostName();
120   entry.DataForSort._memInMB=std::max(entry.DataForSort._memInMB,getMem());
121   entry.DataForSort._nbOfProcPerNode=std::max(entry.DataForSort._nbOfProcPerNode,getNbProcPerNode());
122   entry.DataForSort._nbOfNodes=std::max(entry.DataForSort._nbOfNodes,getNbNodes());
123   entry.DataForSort._CPUFreqMHz=std::max(entry.DataForSort._CPUFreqMHz,getCPUFreq());
124   std::vector<YACS::ENGINE::ComponentInstance *> comps(_gf->getGodFather()->getDeploymentTree()->getComponentsLinkedToContainer(_cont));
125   std::set<std::string> compNames;
126   for(std::vector<YACS::ENGINE::ComponentInstance *>::const_iterator it=comps.begin();it!=comps.end();it++)
127     {
128       YACS::ENGINE::ComponentInstance *elt(*it);
129       if(elt)
130         compNames.insert(elt->getCompoName());
131     }
132   compNames.insert(entry.ComponentsList.begin(),entry.ComponentsList.end());
133   compNames.erase(std::string());
134   std::vector<std::string> compNames2(compNames.begin(),compNames.end());
135   entry.ComponentsList=compNames2;
136 }
137
138 std::string YACSEvalVirtualYACSContainer::findDefault(bool isInteractive) const
139 {
140   std::vector<std::string> possibleHosts(_gf->getAllFittingMachines());
141   for(std::vector<std::string>::const_iterator it=possibleHosts.begin();it!=possibleHosts.end();it++)
142     {
143       if(_gf->getGodFather()->hasRightInteractiveStatus(*it,isInteractive))
144         return *it;
145     }
146   throw YACS::Exception("YACSEvalVirtualYACSContainer::findDefault : impossible to find a right machine with requested interactive status !");
147 }
148
149 void YACSEvalVirtualYACSContainer::setWantedMachine(const std::string& machine)
150 {
151   checkNonLocked();
152   std::vector<std::string> possibleHosts(_gf->getAllFittingMachines());
153   if(std::find(possibleHosts.begin(),possibleHosts.end(),machine)==possibleHosts.end())
154     throw YACS::Exception("YACSEvalVirtualYACSContainer::setWantedMachine : the specified machine is not in the list of available !");
155   std::string oldMachine(getChosenMachine());
156   setMachineNoCheck(machine);
157   try
158   {
159       _gf->notifyWantedMachine(this,oldMachine,machine);
160   }
161   catch(YACS::Exception& e)
162   {
163       setMachineNoCheck(oldMachine);
164       throw e;
165   }
166 }
167
168 std::vector<std::string> YACSEvalVirtualYACSContainer::listOfPropertyKeys() const
169 {
170   std::set<std::string> s;
171   std::map<std::string,std::string>::const_iterator it;
172   for(it=_overloadedPropertyMap.begin();it!=_overloadedPropertyMap.end();it++)
173     s.insert((*it).first);
174   for(it=_propertyMap.begin();it!=_propertyMap.end();it++)
175     s.insert((*it).first);
176   std::vector<std::string> ret(s.begin(),s.end());
177   return ret;
178 }
179
180 std::string YACSEvalVirtualYACSContainer::getValueOfKey(const char *key) const
181 {
182   std::string skey(key);
183   if(skey==HOSTNAME_KEY)
184     return _chosenHost;
185   std::map<std::string,std::string>::const_iterator it;
186   it=_overloadedPropertyMap.find(skey);
187   if(it!=_overloadedPropertyMap.end())
188     return (*it).second;
189   it=_propertyMap.find(skey);
190   if(it!=_propertyMap.end())
191     return (*it).second;
192   return std::string();
193 }
194
195 void YACSEvalVirtualYACSContainer::setProperty(const std::string& key, const std::string &value)
196 {
197   checkNonLocked();
198   if(key==HOSTNAME_KEY)
199     setWantedMachine(value);
200   else
201     _overloadedPropertyMap[key]=value;
202 }
203
204 void YACSEvalVirtualYACSContainer::apply(bool interactiveStatus)
205 {
206   YACS::ENGINE::SalomeContainer *cont0(dynamic_cast<YACS::ENGINE::SalomeContainer *>(_cont));
207   YACS::ENGINE::SalomeHPContainer *cont1(dynamic_cast<YACS::ENGINE::SalomeHPContainer *>(_cont));
208   if(!cont0 && !cont1)
209     throw YACS::Exception("YACSEvalVirtualYACSContainer::apply : unrecognized container !");
210   if(interactiveStatus)
211     _cont->setProperty(HOSTNAME_KEY,getValueOfKey(HOSTNAME_KEY));
212   else
213     {// in cluster mode no hostname and policy set to cycl by default
214       _cont->setProperty(HOSTNAME_KEY,std::string());
215       _cont->setProperty("policy","cycl");
216     }
217 }
218
219 std::string YACSEvalVirtualYACSContainer::getName() const
220 {
221   checkNotNullYACSContainer();
222   return _cont->getName();
223 }
224
225 unsigned int YACSEvalVirtualYACSContainer::getValueOfKeyUInt(const char *key) const
226 {
227   std::string v(getValueOfKey(key));
228   unsigned int ret(0);
229   if(v.empty())
230     return ret;
231   std::istringstream iss(v);
232   iss >> ret;
233   return ret;
234 }
235
236 std::map<std::string,std::string> YACSEvalVirtualYACSContainer::listOfPropertiesInYACSContainer() const
237 {
238   YACS::ENGINE::SalomeContainer *cont0(dynamic_cast<YACS::ENGINE::SalomeContainer *>(_cont));
239   YACS::ENGINE::SalomeHPContainer *cont1(dynamic_cast<YACS::ENGINE::SalomeHPContainer *>(_cont));
240   std::map<std::string,std::string> props;
241   if(cont0)
242     props=cont0->getProperties();
243   else if(cont1)
244     props=cont1->getProperties();
245   return props;
246 }
247
248 void YACSEvalVirtualYACSContainer::checkNotNullYACSContainer() const
249 {
250   if(!_cont)
251     throw YACS::Exception("YACSEvalVirtualYACSContainer::checkNotNullYACSContainer : internal YACS container is NULL !");
252 }
253
254 YACSEvalResource::~YACSEvalResource()
255 {
256 }
257
258 std::vector<std::string> YACSEvalResource::getAllChosenMachines() const
259 {
260   std::set<std::string> s;
261   for(std::vector< YACSEvalVirtualYACSContainer >::const_iterator it=_containers.begin();it!=_containers.end();it++)
262     s.insert((*it).getChosenMachine());
263   std::vector<std::string> ret(s.begin(),s.end());
264   return ret;
265 }
266
267 std::vector<std::string> YACSEvalResource::getAllFittingMachines() const
268 {
269   ParserResourcesType ref;
270   aggregate(ref);
271   return _gf->getFittingResources(&ref);
272 }
273
274 void YACSEvalResource::setWantedMachine(const std::string& machine)
275 {
276   checkNonLocked();
277   std::vector<std::string> possibleHosts(getAllFittingMachines());
278   if(std::find(possibleHosts.begin(),possibleHosts.end(),machine)==possibleHosts.end())
279     throw YACS::Exception("YACSEvalResource::setWantedMachine : the specified machine is not in the list of available !");
280   for(std::vector< YACSEvalVirtualYACSContainer >::iterator it=_containers.begin();it!=_containers.end();it++)
281     (*it).setMachineNoCheck(machine);
282 }
283
284 YACSEvalVirtualYACSContainer *YACSEvalResource::at(std::size_t i) const
285 {
286   if(i>=_containers.size())
287     throw YACS::Exception("YACSEvalResource::at : invalid input ! must be < size !");
288   return const_cast<YACSEvalVirtualYACSContainer *>(&_containers[i]);
289 }
290
291 void YACSEvalResource::apply(bool interactiveStatus)
292 {
293   for(std::vector< YACSEvalVirtualYACSContainer >::iterator it=_containers.begin();it!=_containers.end();it++)
294     (*it).apply(interactiveStatus);
295 }
296
297 void YACSEvalResource::fitWithCurrentCatalogAbs()
298 {
299   std::vector<std::string> ress(getAllFittingMachines());
300   if(ress.empty())
301     throw YACS::Exception("YACSEvalResource::fitWithCurrentCatalogAbs : no suitable host in your catalog of resource !");
302   setMachineNoCheck(ress.front());
303 }
304
305 void YACSEvalResource::aggregate(ParserResourcesType& entry) const
306 {
307   for(std::vector< YACSEvalVirtualYACSContainer >::const_iterator it=_containers.begin();it!=_containers.end();it++)
308     (*it).aggregate(entry);
309 }
310
311 void YACSEvalResource::notifyWantedMachine(YACSEvalVirtualYACSContainer *sender, const std::string& oldMachine, const std::string& newMachine)
312 {
313   _gf->notifyWantedMachine(sender,oldMachine,newMachine);
314 }
315
316 void YACSEvalResource::setMachineNoCheck(const std::string& machine)
317 {
318   for(std::vector< YACSEvalVirtualYACSContainer >::iterator it=_containers.begin();it!=_containers.end();it++)
319     (*it).setMachineNoCheck(machine);
320 }
321
322 YACSEvalResource::YACSEvalResource(YACSEvalListOfResources *gf, const std::vector< YACS::ENGINE::Container * >& conts):_gf(gf)
323 {
324   std::size_t sz(conts.size());
325   _containers.resize(sz);
326   for(std::size_t i=0;i<sz;i++)
327     _containers[i].set(this,conts[i]);
328 }
329
330 void YACSEvalParamsForCluster::setExclusiveness(bool newStatus)
331 {
332   if(newStatus)
333     throw YACS::Exception("YACSEvalParamsForCluster::setExclusiveness : exclusive mode set to true is not implemented yet !");
334 }
335
336 void YACSEvalParamsForCluster::checkConsistency() const
337 {
338   if(_remoteWorkingDir.empty())
339     throw YACS::Exception("YACSEvalParamsForCluster::checkConsistency : remote work dir is not set !");
340   if(_localWorkingDir.empty())
341     throw YACS::Exception("YACSEvalParamsForCluster::checkConsistency : local work dir is not set !");
342   if(_wcKey.empty())
343     throw YACS::Exception("YACSEvalParamsForCluster::checkConsistency : WC key is not set !");
344   if(_nbOfProcs==0)
345     throw YACS::Exception("YACSEvalParamsForCluster::checkConsistency : nb procs must be != 0 !");
346 }
347
348 YACSEvalListOfResources::YACSEvalListOfResources(int maxLevOfPara, ResourcesManager_cpp *rm, const YACS::ENGINE::DeploymentTree& dt):_maxLevOfPara(maxLevOfPara),_rm(rm),_dt(new YACS::ENGINE::DeploymentTree(dt))
349 {
350   std::vector<YACS::ENGINE::Container *> conts(_dt->getAllContainers());
351   std::map<std::string, std::vector<YACS::ENGINE::Container *> > listOfHosts;
352   for(std::vector<YACS::ENGINE::Container *>::const_iterator it=conts.begin();it!=conts.end();it++)
353     {
354       std::vector<YACS::ENGINE::ComponentInstance *> cis(dt.getComponentsLinkedToContainer(*it));
355       YACS::ENGINE::SalomeContainer *c1(dynamic_cast<YACS::ENGINE::SalomeContainer *>(*it));
356       YACS::ENGINE::SalomeHPContainer *c2(dynamic_cast<YACS::ENGINE::SalomeHPContainer *>(*it));
357       std::string zeHost;
358       if(c1)
359         zeHost=c1->getProperty(YACSEvalVirtualYACSContainer::HOSTNAME_KEY);
360       if(c2)
361         zeHost=c2->getProperty(YACSEvalVirtualYACSContainer::HOSTNAME_KEY);
362       listOfHosts[zeHost].push_back(*it);
363     }
364   for(std::map<std::string, std::vector<YACS::ENGINE::Container *> >::const_iterator it=listOfHosts.begin();it!=listOfHosts.end();it++)
365     _resources.push_back(new YACSEvalResourceEff(this,(*it).second));
366   fitWithCurrentCatalog();
367 }
368
369 std::vector<std::string> YACSEvalListOfResources::getAllChosenMachines() const
370 {
371   std::set<std::string> s;
372   for(std::vector<YACSEvalResource *>::const_iterator it=_resources.begin();it!=_resources.end();it++)
373     {
374       std::vector<std::string> tmp((*it)->getAllChosenMachines());
375       s.insert(tmp.begin(),tmp.end());
376     }
377   std::vector<std::string> ret(s.begin(),s.end());
378   return ret;
379 }
380
381 std::vector<std::string> YACSEvalListOfResources::getAllFittingMachines() const
382 {
383   ParserResourcesType ref;
384   for(std::vector<YACSEvalResource *>::const_iterator it=_resources.begin();it!=_resources.end();it++)
385     (*it)->aggregate(ref);
386   return getFittingResources(&ref);
387 }
388
389 void YACSEvalListOfResources::setWantedMachine(const std::string& machine)
390 {
391   checkNonLocked();
392   std::vector<std::string> possibleHosts(getAllFittingMachines());
393   if(std::find(possibleHosts.begin(),possibleHosts.end(),machine)==possibleHosts.end())
394     throw YACS::Exception("YACSEvalResource::setWantedMachine : the specified machine is not in the list of available !");
395   for(std::vector<YACSEvalResource *>::iterator it=_resources.begin();it!=_resources.end();it++)
396     (*it)->setMachineNoCheck(machine);
397 }
398
399 YACSEvalResource *YACSEvalListOfResources::at(std::size_t i) const
400 {
401   if(i>=size())
402     throw YACS::Exception("YACSEvalListOfResources::at : invalid id !");
403   return _resources[i];
404 }
405
406 bool YACSEvalListOfResources::isInteractive() const
407 {
408   std::vector<std::string> allMachines(getAllChosenMachines());
409   if(allMachines.empty())
410     return true;
411   std::size_t ii(0),sz(allMachines.size());
412   std::vector<bool> status(sz);
413   for(std::vector<std::string>::const_iterator it=allMachines.begin();it!=allMachines.end();it++,ii++)
414     {
415       status[ii]=isMachineInteractive(*it);
416     }
417   std::size_t trueRet(std::count(status.begin(),status.end(),true)),falseRet(std::count(status.begin(),status.end(),false));
418   if(trueRet==sz && falseRet==0)
419     return true;
420   else if(trueRet==0 && falseRet==sz)
421     return false;
422   throw YACS::Exception("YACSEvalListOfResources::isInteractive : mix of interactive and non interactive ! internal error !");
423 }
424
425 unsigned int YACSEvalListOfResources::getNumberOfProcsDeclared() const
426 {
427   if(isInteractive())
428     {
429       std::vector<std::string> chosen(getAllChosenMachines());
430       unsigned int ret(0);
431       for(std::vector<std::string>::const_iterator it=chosen.begin();it!=chosen.end();it++)
432         ret+=getNumberOfProcOfResource(*it);
433       return ret;
434     }
435   else
436     return _paramsInCaseOfCluster.getNbProcs();
437 }
438
439 void YACSEvalListOfResources::checkOKForRun() const
440 {
441   if(!isInteractive())
442     _paramsInCaseOfCluster.checkConsistency();
443 }
444
445 void YACSEvalListOfResources::apply()
446 {
447   bool interactiveSt(isInteractive());
448   for(std::vector<YACSEvalResource *>::iterator it=_resources.begin();it!=_resources.end();it++)
449     (*it)->apply(interactiveSt);
450 }
451
452 YACSEvalListOfResources::~YACSEvalListOfResources()
453 {
454   delete _dt;
455   for(std::vector<YACSEvalResource *>::iterator it=_resources.begin();it!=_resources.end();it++)
456     delete *it;
457 }
458
459 bool YACSEvalListOfResources::isMachineInteractive(const std::string& machine) const
460 {
461   const MapOfParserResourcesType& zeList(_rm->GetList());
462   std::map<std::string, ParserResourcesType>::const_iterator it2(zeList.find(machine));
463   if(it2==zeList.end())
464     {
465       std::ostringstream oss; oss << "YACSEvalListOfResources::isMachineInteractive : no such machine with name \"" << machine << "\" !";
466       throw YACS::Exception(oss.str());
467     }
468   const ParserResourcesType& elt((*it2).second);
469   return (elt.Batch==none);
470 }
471
472 class EffectiveComparator
473 {
474 public:
475   virtual ~EffectiveComparator() { }
476   virtual EffectiveComparator *copy() const = 0;
477   virtual bool compare(const ResourceDataToSort& elt1, const ResourceDataToSort& elt2) const = 0;
478 };
479
480 // comparator for a null request in scheme
481 class BasicComparator : public EffectiveComparator
482 {
483 public:
484   EffectiveComparator *copy() const { return new BasicComparator; }
485   bool compare(const ResourceDataToSort& elt1, const ResourceDataToSort& elt2) const;
486 };
487
488 class MemAwareComparator : public EffectiveComparator
489 {
490 public:
491   EffectiveComparator *copy() const { return new MemAwareComparator; }
492   bool compare(const ResourceDataToSort& elt1, const ResourceDataToSort& elt2) const;
493 };
494
495 class CompromiseComparator : public EffectiveComparator
496 {
497 public:
498   CompromiseComparator(int memMB, int nbProcs):_memMB(memMB),_nbProcs(nbProcs) { }
499   EffectiveComparator *copy() const { return new CompromiseComparator(_memMB,_nbProcs); }
500   bool compare(const ResourceDataToSort& elt1, const ResourceDataToSort& elt2) const;
501 private:
502   int _memMB;
503   int _nbProcs;
504 };
505
506 class CompareRes
507 {
508 public:
509   CompareRes(const ParserResourcesType *request, const MapOfParserResourcesType& zeCatalog);
510   CompareRes(const CompareRes& other);
511   bool operator()(const std::string& res1, const std::string& res2);
512   ~CompareRes() { delete _comp; }
513 private:
514   EffectiveComparator *_comp;
515   const ParserResourcesType *_request;
516   const MapOfParserResourcesType& _zeCatalog;
517 };
518
519 bool BasicComparator::compare(const ResourceDataToSort& elt1, const ResourceDataToSort& elt2) const
520 {
521   int nbOfProcs1(elt1._nbOfNodes*elt1._nbOfProcPerNode),nbOfProcs2(elt2._nbOfNodes*elt2._nbOfProcPerNode);
522   return nbOfProcs1<nbOfProcs2;
523 }
524
525 bool MemAwareComparator::compare(const ResourceDataToSort& elt1, const ResourceDataToSort& elt2) const
526 {
527   return elt1._memInMB<elt2._memInMB;
528 }
529
530 bool CompromiseComparator::compare(const ResourceDataToSort& elt1, const ResourceDataToSort& elt2) const
531 {
532   double v1a(elt1._memInMB/_memMB),v1b(elt1._nbOfNodes*elt1._nbOfProcPerNode/_nbProcs);
533   double v2a(elt2._memInMB/_memMB),v2b(elt2._nbOfNodes*elt2._nbOfProcPerNode/_nbProcs);
534   return std::min(v1a,v1b)<std::min(v2a,v2b);
535 }
536
537 CompareRes::CompareRes(const ParserResourcesType *request, const MapOfParserResourcesType& zeCatalog):_comp(0),_request(request),_zeCatalog(zeCatalog)
538 {
539   const ResourceDataToSort& tmp(_request->DataForSort);
540   // all request items are set to default -> Basic comparison on procs
541   if(request->DataForSort._nbOfNodes==1 && request->DataForSort._nbOfProcPerNode==1 && request->DataForSort._memInMB==0)
542     _comp=new BasicComparator;
543   // all items are set to default except memory -> Memory aware only
544   else if(request->DataForSort._memInMB!=0 && request->DataForSort._nbOfNodes==1 && request->DataForSort._nbOfProcPerNode==1)
545     _comp=new MemAwareComparator;
546   // memory and procs are set by the user -> do the best possible.
547   else if(request->DataForSort._memInMB!=0 && ( request->DataForSort._nbOfNodes!=1 || request->DataForSort._nbOfProcPerNode!=1 ) )
548     _comp=new CompromiseComparator(request->DataForSort._memInMB,request->DataForSort._nbOfNodes*request->DataForSort._nbOfProcPerNode);
549   else
550     _comp=new BasicComparator;
551 }
552
553 CompareRes::CompareRes(const CompareRes& other):_comp(other._comp->copy()),_request(other._request),_zeCatalog(other._zeCatalog)
554 {
555 }
556
557 bool CompareRes::operator()(const std::string& res1, const std::string& res2)
558 {
559   std::map<std::string, ParserResourcesType>::const_iterator it1(_zeCatalog.find(res1)),it2(_zeCatalog.find(res2));
560   if(it1==_zeCatalog.end() || it2==_zeCatalog.end())
561     throw YACS::Exception("Internal error during comparison !");
562   const ParserResourcesType& elt1((*it1).second);
563   const ParserResourcesType& elt2((*it2).second);
564   return _comp->compare(elt1.DataForSort,elt2.DataForSort);
565 }
566
567 /*!
568  * Implements an another alg than those proposed by default in ResourcesManager_cpp in "ResourcesManager.hxx".
569  */
570 std::vector<std::string> YACSEvalListOfResources::getFittingResources(ParserResourcesType *request) const
571 {
572   int mlop(getMaxLevelOfParallelism());
573   request->DataForSort._memInMB*=mlop;
574   request->DataForSort._nbOfNodes*=mlop;
575   //
576   const MapOfParserResourcesType& zeListInCatalog(_rm->GetList());
577   std::vector<std::string> list0;
578   // first keep those having relevant components
579   const std::vector<std::string>& listExpected(request->ComponentsList);
580   std::set<std::string> listExpected2(listExpected.begin(),listExpected.end());
581   for(std::map<std::string, ParserResourcesType>::const_iterator it=zeListInCatalog.begin();it!=zeListInCatalog.end();it++)
582     {
583       const std::vector<std::string>& compoList((*it).second.ComponentsList);
584       std::set<std::string> s1(compoList.begin(),compoList.end());
585       std::vector<std::string> diff;
586       std::set_difference(listExpected2.begin(),listExpected2.end(),s1.begin(),s1.end(),std::inserter(diff,diff.begin()));
587       if(diff.empty())
588         list0.push_back((*it).first);
589     }
590   // sort list0 regarding request
591   std::sort(list0.begin(),list0.end(),CompareRes(request,zeListInCatalog));
592   // if HostName in request is defined and in list0 put it first.
593   std::string tmp(request->HostName);
594   if(!tmp.empty())
595     {
596       std::vector<std::string>::iterator it1(std::find(list0.begin(),list0.end(),tmp));
597       if(it1!=list0.end())
598         {// HostName in list0 so put it in first place.
599           list0.erase(it1);
600           list0.insert(list0.begin(),tmp);
601         }
602     }
603   return list0;
604 }
605
606 void YACSEvalListOfResources::notifyWantedMachine(YACSEvalVirtualYACSContainer *sender, const std::string& oldMachine, const std::string& newMachine)
607 {
608   const MapOfParserResourcesType& zeList(_rm->GetList());
609   std::map<std::string, ParserResourcesType>::const_iterator itOld(zeList.find(oldMachine)),itNew(zeList.find(newMachine));
610   if(itOld==zeList.end() || itNew==zeList.end())
611     throw YACS::Exception("YACSEvalListOfResources::notifyWantedMachine : internal error !");
612   const ParserResourcesType& oldPRT((*itOld).second);
613   const ParserResourcesType& newPRT((*itNew).second);
614   bool oldISt(oldPRT.Batch==none),newISt(newPRT.Batch==none);//interactive status
615   if(oldISt==newISt)
616     return ;
617   // the batch/interactive mode has changed -> try to change for all.
618   std::queue<std::string> sts;
619   try
620   {
621     if(newISt)
622       {// switching from interactive to batch -> In batch every YACSEvalVirtualYACSContainer instances in this must lie on newMachine.
623         for(std::vector<YACSEvalResource *>::const_iterator it=_resources.begin();it!=_resources.end();it++)
624           {
625             std::vector<std::string> fms((*it)->getAllFittingMachines());
626             std::vector<std::string>::iterator it0(std::find(fms.begin(),fms.end(),newMachine));
627             if(it0==fms.end())
628               {
629                 std::ostringstream oss; oss << "In the context of switch to batch the requested cluster machine \"" << newMachine << "\" is not compatible for following list of containers : " << std::endl;
630                 std::size_t sz((*it)->size());
631                 for(std::size_t i=0;i<sz;i++)
632                   {
633                     YACSEvalVirtualYACSContainer *cont((*it)->at(i));
634                     if(cont)
635                       oss << " \"" << cont->getName() << "\", ";
636                   }
637                 throw YACS::Exception(oss.str());
638               }
639             std::size_t sz((*it)->size());
640             for(std::size_t i=0;i<sz;i++)
641               {
642                 std::size_t sz((*it)->size());
643                 for(std::size_t i=0;i<sz;i++)
644                   {
645                     YACSEvalVirtualYACSContainer *cont((*it)->at(i));
646                     if(cont==sender)
647                       continue;
648                     sts.push(newMachine);
649                   }
650               }
651           }
652       }
653     else
654       {
655         for(std::vector<YACSEvalResource *>::const_iterator it=_resources.begin();it!=_resources.end();it++)
656           {
657             std::size_t sz((*it)->size());
658             for(std::size_t i=0;i<sz;i++)
659               {
660                 YACSEvalVirtualYACSContainer *cont((*it)->at(i));
661                 if(cont==sender)
662                   continue;
663                 sts.push(cont->findDefault(false));
664               }
665           }
666       }
667   }
668   catch(YACS::Exception& e)
669   {
670       std::ostringstream oss; oss << "YACSEvalListOfResources::notifyWantedMachine : switching from interactive/batch must be global ! " << e.what();
671       throw YACS::Exception(oss.str());
672   }
673   for(std::vector<YACSEvalResource *>::const_iterator it=_resources.begin();it!=_resources.end();it++)
674     {
675       std::size_t sz((*it)->size());
676       for(std::size_t i=0;i<sz;i++)
677         {
678           YACSEvalVirtualYACSContainer *cont((*it)->at(i));
679           if(cont==sender)
680             continue;
681           cont->setMachineNoCheck(sts.front());
682           sts.pop();
683         }
684     }
685 }
686
687 bool YACSEvalListOfResources::hasRightInteractiveStatus(const std::string& machineToTest, bool isInteractive) const
688 {
689   const MapOfParserResourcesType& zeList(_rm->GetList());
690   std::map<std::string, ParserResourcesType>::const_iterator it(zeList.find(machineToTest));
691   if(it==zeList.end())
692     throw YACS::Exception("YACSEvalListOfResources::hasRightInteractiveStatus : internal error !");
693   const ParserResourcesType& elt((*it).second);
694   bool myStatus(elt.Batch==none);
695   return myStatus==isInteractive;
696 }
697
698 void YACSEvalListOfResources::fitWithCurrentCatalog()
699 {
700   std::vector<std::string> ress(getAllFittingMachines());
701   if(ress.empty())
702     throw YACS::Exception("YACSEvalListOfResources::fitWithCurrentCatalog : no available resource in your catalog !");
703   for(std::vector<YACSEvalResource *>::iterator it=_resources.begin();it!=_resources.end();it++)
704     (*it)->setMachineNoCheck(ress.front());
705 }
706
707 unsigned int YACSEvalListOfResources::getNumberOfProcOfResource(const std::string& machine) const
708 {
709   const MapOfParserResourcesType& zeList(_rm->GetList());
710   std::map<std::string, ParserResourcesType>::const_iterator it(zeList.find(machine));
711   if(it==zeList.end())
712     throw YACS::Exception("YACSEvalListOfResources::getNumberOfProcOfResource : internal error !");
713   const ParserResourcesType& PRT((*it).second);
714   const ResourceDataToSort& RDT(PRT.DataForSort);
715   unsigned int ret(RDT._nbOfNodes*RDT._nbOfProcPerNode);
716   return ret;
717 }