]> SALOME platform Git repositories - modules/kernel.git/blob - src/ResourcesManager/SALOME_ResourcesManager.cxx
Salome HOME
Update copyrights
[modules/kernel.git] / src / ResourcesManager / SALOME_ResourcesManager.cxx
1 // Copyright (C) 2007-2019  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 #include "SALOME_ResourcesManager.hxx" 
24 #include "Utils_ExceptHandlers.hxx"
25 #include "Utils_CorbaException.hxx"
26 #include "OpUtil.hxx"
27
28 #include <stdlib.h>
29 #include <stdio.h>
30 #ifndef WIN32
31 #include <unistd.h>
32 #else
33 #include <io.h>
34 #include <process.h>
35 #endif
36 #include <fstream>
37 #include <iostream>
38 #include <sstream>
39 #include <string.h>
40 #include <map>
41 #include <list>
42
43 #include <sys/types.h>
44 #include <sys/stat.h>
45 #include "utilities.h"
46
47 #define MAX_SIZE_FOR_HOSTNAME 256;
48
49 using namespace std;
50
51 const char *SALOME_ResourcesManager::_ResourcesManagerNameInNS = "/ResourcesManager";
52
53 //=============================================================================
54 /*!
55  * just for test
56  */ 
57 //=============================================================================
58
59 SALOME_ResourcesManager::SALOME_ResourcesManager(CORBA::ORB_ptr orb, PortableServer::POA_var poa, SALOME_NamingService *ns, const char *xmlFilePath) : _rm(xmlFilePath)
60 {
61   MESSAGE("SALOME_ResourcesManager constructor");
62   _NS = ns;
63   _orb = CORBA::ORB::_duplicate(orb) ;
64   //
65   PortableServer::POAManager_var pman = poa->the_POAManager();
66   CORBA::PolicyList policies;
67   policies.length(1);
68   PortableServer::ThreadPolicy_var threadPol(poa->create_thread_policy(PortableServer::SINGLE_THREAD_MODEL));
69   policies[0] = PortableServer::ThreadPolicy::_duplicate(threadPol);
70   _poa = poa->create_POA("SingleThreadPOA",pman,policies);
71   threadPol->destroy();
72   //
73   PortableServer::ObjectId_var id = _poa->activate_object(this);
74   CORBA::Object_var obj = _poa->id_to_reference(id);
75   Engines::ResourcesManager_var refContMan = Engines::ResourcesManager::_narrow(obj);
76   _NS->Register(refContMan,_ResourcesManagerNameInNS);
77   MESSAGE("SALOME_ResourcesManager constructor end");
78 }
79
80 //=============================================================================
81 /*!
82  *  Standard constructor, parse resource file.
83  *  - if ${APPLI} exists in environment,
84  *    look for ${HOME}/${APPLI}/CatalogResources.xml
85  *  - else look for default:
86  *    ${KERNEL_ROOT_DIR}/share/salome/resources/kernel/CatalogResources.xml
87  *  - parse XML resource file.
88  */ 
89 //=============================================================================
90
91 SALOME_ResourcesManager::SALOME_ResourcesManager(CORBA::ORB_ptr orb, 
92                                                  PortableServer::POA_var poa, 
93                                                  SALOME_NamingService *ns) : _rm()
94 {
95   MESSAGE("SALOME_ResourcesManager constructor");
96   _NS = ns;
97   _orb = CORBA::ORB::_duplicate(orb) ;
98   //
99   PortableServer::POAManager_var pman = poa->the_POAManager();
100   CORBA::PolicyList policies;
101   policies.length(1);
102   PortableServer::ThreadPolicy_var threadPol(poa->create_thread_policy(PortableServer::SINGLE_THREAD_MODEL));
103   policies[0] = PortableServer::ThreadPolicy::_duplicate(threadPol);
104   _poa = poa->create_POA("SingleThreadPOA",pman,policies);
105   threadPol->destroy();
106   //
107   PortableServer::ObjectId_var id = _poa->activate_object(this);
108   CORBA::Object_var obj = _poa->id_to_reference(id);
109   Engines::ResourcesManager_var refContMan = Engines::ResourcesManager::_narrow(obj);
110   _NS->Register(refContMan,_ResourcesManagerNameInNS);
111
112   MESSAGE("SALOME_ResourcesManager constructor end");
113 }
114
115 //=============================================================================
116 /*!
117  *  Standard Destructor
118  */ 
119 //=============================================================================
120
121 SALOME_ResourcesManager::~SALOME_ResourcesManager()
122 {
123   MESSAGE("SALOME_ResourcesManager destructor");
124 }
125
126
127 //=============================================================================
128 /*! CORBA method:
129  *  shutdown all the containers, then the ContainerManager servant
130  */
131 //=============================================================================
132
133 void SALOME_ResourcesManager::Shutdown()
134 {
135   MESSAGE("Shutdown");
136   _NS->Destroy_Name(_ResourcesManagerNameInNS);
137   PortableServer::ObjectId_var oid = _poa->servant_to_id(this);
138   _poa->deactivate_object(oid);
139 }
140
141 /*!
142  * Return list of resources available (regarding content of CatalogResources.xml). And for each resource the number of proc available of it.
143  */
144 void SALOME_ResourcesManager::ListAllAvailableResources(Engines::ResourceList_out machines, Engines::IntegerList_out nbProcsOfMachines)
145 {
146   const MapOfParserResourcesType& zeList(_rm.GetList());
147   std::size_t sz(zeList.size());
148   std::vector<std::string> ret0(sz);
149   std::vector<int> ret1(sz);
150   {
151     std::size_t i(0);
152     for(MapOfParserResourcesType::const_iterator it=zeList.begin();it!=zeList.end();it++,i++)
153       {
154         const ParserResourcesType& elt((*it).second);
155         ret0[i]=elt.HostName;
156         //ret1[i]=elt.nbOfProc;
157         ret1[i]=elt.DataForSort._nbOfNodes*elt.DataForSort._nbOfProcPerNode;
158       }
159   }
160   machines=new Engines::ResourceList;
161   nbProcsOfMachines=new Engines::IntegerList;
162   machines->length(sz); nbProcsOfMachines->length(sz);
163   for(std::size_t j=0;j<sz;j++)
164     {
165       (*machines)[j]=CORBA::string_dup(ret0[j].c_str());
166       (*nbProcsOfMachines)[j]=ret1[j];
167     }
168 }
169
170 //=============================================================================
171 //! get the name of resources fitting the specified constraints (params)
172 /*!
173  *  If hostname specified, check it is local or known in resources catalog.
174  *
175  *  Else
176  *  - select first machines with corresponding OS (all machines if
177  *    parameter OS empty),
178  *  - then select the sublist of machines on which the component is known
179  *    (if the result is empty, that probably means that the inventory of
180  *    components is probably not done, so give complete list from previous step)
181  */ 
182 //=============================================================================
183
184 Engines::ResourceList *
185 SALOME_ResourcesManager::GetFittingResources(const Engines::ResourceParameters& params)
186 {
187   //MESSAGE("ResourcesManager::GetFittingResources");
188   Engines::ResourceList_var ret;
189
190   // CORBA -> C++
191   resourceParams p = resourceParameters_CORBAtoCPP(params);
192
193   try
194   {
195     // Call C++ ResourceManager
196     std::vector <std::string> vec = _rm.GetFittingResources(p);
197
198     // C++ -> CORBA
199     ret = resourceList_CPPtoCORBA(vec);
200   }
201   catch(const ResourcesException &ex)
202   {
203     INFOS("Caught exception in GetFittingResources C++:  " << ex.msg);
204     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
205   }  
206
207   return ret._retn();
208 }
209
210 //=============================================================================
211 /*!
212  *  dynamically obtains the first machines
213  */ 
214 //=============================================================================
215
216 char *
217 SALOME_ResourcesManager::FindFirst(const Engines::ResourceList& listOfResources)
218 {
219   // CORBA -> C++
220   std::vector<std::string> rl = resourceList_CORBAtoCPP(listOfResources);
221
222   return CORBA::string_dup(_rm.Find("first", rl).c_str());
223 }
224
225 char *
226 SALOME_ResourcesManager::Find(const char* policy, const Engines::ResourceList& listOfResources)
227 {
228   // CORBA -> C++
229   std::vector<std::string> rl = resourceList_CORBAtoCPP(listOfResources);
230
231   return CORBA::string_dup(_rm.Find(policy, rl).c_str());
232 }
233
234 Engines::ResourceDefinition*
235 SALOME_ResourcesManager::GetResourceDefinition(const char * name)
236 {
237   Engines::ResourceDefinition_var resDef;
238   try {
239     ParserResourcesType resource = _rm.GetResourcesDescr(name);
240     resDef = resourceDefinition_CPPtoCORBA(resource);
241   } catch (const exception & ex) {
242     INFOS("Caught exception in GetResourceDefinition: " << ex.what());
243     THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::BAD_PARAM);
244   }
245
246   return resDef._retn();
247 }
248
249 void 
250 SALOME_ResourcesManager::AddResource(const Engines::ResourceDefinition& new_resource,
251                                      CORBA::Boolean write,
252                                      const char * xml_file)
253 {
254   try
255   {
256     ParserResourcesType resource = resourceDefinition_CORBAtoCPP(new_resource);
257     _rm.AddResourceInCatalog(resource);
258
259     if (write)
260     {
261       _rm.WriteInXmlFile(std::string(xml_file));
262       _rm.ParseXmlFiles();
263     }
264   }
265   catch (const SALOME_Exception & e)
266   {
267     INFOS("Error in AddResourceInCatalog: " << e);
268     THROW_SALOME_CORBA_EXCEPTION(e.what(), SALOME::BAD_PARAM);
269   }
270   catch (const ResourcesException & e)
271   {
272     INFOS("Error in AddResourceInCatalog: " << e.msg);
273     THROW_SALOME_CORBA_EXCEPTION(e.msg.c_str(), SALOME::BAD_PARAM);
274   }
275 }
276
277 void
278 SALOME_ResourcesManager::RemoveResource(const char * resource_name,
279                                         CORBA::Boolean write,
280                                         const char * xml_file)
281 {
282   try
283   {
284     _rm.DeleteResourceInCatalog(resource_name);
285   }
286   catch (const SALOME_Exception & e)
287   {
288     INFOS("Error in DeleteResourceInCatalog: " << e);
289     THROW_SALOME_CORBA_EXCEPTION(e.what(), SALOME::BAD_PARAM);
290   }
291
292   if (write)
293   {
294     _rm.WriteInXmlFile(std::string(xml_file));
295     _rm.ParseXmlFiles();
296   }
297 }
298
299 char *
300 SALOME_ResourcesManager::getMachineFile(const char * resource_name,
301                                         CORBA::Long nb_procs, 
302                                         const char * parallelLib)
303 {
304   std::string machine_file_name("");
305
306   if (std::string(parallelLib) == "Dummy")
307   {
308     MESSAGE("[getMachineFile] parallelLib is Dummy");
309     MapOfParserResourcesType resourcesList = _rm.GetList();
310     if (resourcesList.find(std::string(resource_name)) != resourcesList.end())
311     {
312       ParserResourcesType resource = resourcesList[std::string(resource_name)];
313
314       // Check if resource is cluster or not
315       if (resource.ClusterMembersList.empty())
316       {
317         //It is not a cluster so we create a cluster with one machine
318         ParserResourcesType fake_node;
319         fake_node.HostName = resource.HostName;
320         fake_node.Protocol = resource.Protocol;
321         fake_node.ClusterInternalProtocol = resource.ClusterInternalProtocol;
322         fake_node.UserName = resource.UserName;
323         fake_node.AppliPath = resource.AppliPath;
324         fake_node.DataForSort = resource.DataForSort;
325
326         resource.ClusterMembersList.push_front(fake_node);
327       }
328
329       // Creating list of machines for creating the machine file
330       std::list<std::string> list_of_machines;
331       std::list<ParserResourcesType>::iterator cluster_it =
332         resource.ClusterMembersList.begin();
333       while (cluster_it != resource.ClusterMembersList.end())
334       {
335         // For each member of the cluster we add a nbOfNodes * nbOfProcPerNode in the list
336         unsigned int number_of_proc = (*cluster_it).DataForSort._nbOfNodes * 
337                                       (*cluster_it).DataForSort._nbOfProcPerNode;
338         for (unsigned int i = 0; i < number_of_proc; i++)
339           list_of_machines.push_back((*cluster_it).HostName);
340         cluster_it++;
341       }
342
343       // Creating machine file
344       machine_file_name = tmpnam(NULL);
345       std::ofstream machine_file(machine_file_name.c_str(), std::ios_base::out);
346
347       CORBA::Long machine_number = 0;
348       std::list<std::string>::iterator it = list_of_machines.begin();
349       while (machine_number != nb_procs)
350       {
351         // Adding a new node to the machine file
352         machine_file << *it << std::endl;
353
354         // counting...
355         it++;
356         if (it == list_of_machines.end())
357           it = list_of_machines.begin();
358         machine_number++;
359       }
360     }
361     else
362       INFOS("[getMachineFile] Error resource_name not found in resourcesList -> " << resource_name);
363   }
364   else if (std::string(parallelLib) == "Mpi")
365   {
366     MESSAGE("[getMachineFile] parallelLib is Mpi");
367
368     MapOfParserResourcesType resourcesList = _rm.GetList();
369     if (resourcesList.find(std::string(resource_name)) != resourcesList.end())
370     {
371       ParserResourcesType resource = resourcesList[std::string(resource_name)];
372       // Check if resource is cluster or not
373       if (resource.ClusterMembersList.empty())
374       {
375         //It is not a cluster so we create a cluster with one machine
376         ParserResourcesType fake_node;
377         fake_node.HostName = resource.HostName;
378         fake_node.Protocol = resource.Protocol;
379         fake_node.ClusterInternalProtocol = resource.ClusterInternalProtocol;
380         fake_node.UserName = resource.UserName;
381         fake_node.AppliPath = resource.AppliPath;
382         fake_node.DataForSort = resource.DataForSort;
383
384         resource.ClusterMembersList.push_front(fake_node);
385       }
386
387       // Choose mpi implementation -> each MPI implementation has is own machinefile...
388       if (resource.mpi == lam)
389       {
390         // Creating machine file
391         machine_file_name = tmpnam(NULL);
392         std::ofstream machine_file(machine_file_name.c_str(), std::ios_base::out);
393
394         // We add all cluster machines to the file
395         std::list<ParserResourcesType>::iterator cluster_it =
396           resource.ClusterMembersList.begin();
397         while (cluster_it != resource.ClusterMembersList.end())
398         {
399           unsigned int number_of_proc = (*cluster_it).DataForSort._nbOfNodes * 
400             (*cluster_it).DataForSort._nbOfProcPerNode;
401           machine_file << (*cluster_it).HostName << " cpu=" << number_of_proc << std::endl;
402           cluster_it++;
403         }
404       }
405       else if ((resource.mpi == openmpi) || (resource.mpi == ompi))
406       {
407         // Creating machine file
408         machine_file_name = tmpnam(NULL);
409         std::ofstream machine_file(machine_file_name.c_str(), std::ios_base::out);
410
411         // We add all cluster machines to the file
412         std::list<ParserResourcesType>::iterator cluster_it =
413           resource.ClusterMembersList.begin();
414         while (cluster_it != resource.ClusterMembersList.end())
415         {
416           unsigned int number_of_proc = (*cluster_it).DataForSort._nbOfNodes *
417             (*cluster_it).DataForSort._nbOfProcPerNode;
418           machine_file << (*cluster_it).HostName << " slots=" << number_of_proc << std::endl;
419           cluster_it++;
420         }
421       }
422       else if (resource.mpi == nompi)
423       {
424         INFOS("[getMachineFile] Error resource_name MPI implementation was defined for " << resource_name);
425       }
426       else
427         INFOS("[getMachineFile] Error resource_name MPI implementation not currently handled for " << resource_name);
428     }
429     else
430       INFOS("[getMachineFile] Error resource_name not found in resourcesList -> " << resource_name);
431   }
432   else
433     INFOS("[getMachineFile] Error parallelLib is not handled -> " << parallelLib);
434
435   return CORBA::string_dup(machine_file_name.c_str());
436 }