source: XMLIO_V2/dev/dev_rv/src/xmlio/manager/xios_manager.cpp @ 180

Last change on this file since 180 was 180, checked in by hozdoba, 12 years ago
File size: 14.0 KB
Line 
1#include "xios_manager.hpp"
2
3#include "tree_manager.hpp"
4#include "data_treatment.hpp"
5
6namespace xmlioserver
7{
8      /// ////////////////////// Définitions ////////////////////// ///
9     
10      void CXIOSManager::Initialise(XIOSType type, int * argc, char *** argv)
11      {
12         CXIOSManager::Type = type;
13         if (type != CLIENT)
14         {
15            // Initialisation de la biliothÚque MPI si nécessaire
16            comm::CMPIManager::Initialise(argc, argv);
17            ExeName = StdString((*argv)[0]);
18            for (int i = 1; i < *argc; i++)
19               ExeOptions.push_back(StdString((*argv)[i]));
20         }
21      }
22
23      void CXIOSManager::Finalize(void)
24      {
25         if (CXIOSManager::Type != CLIENT)
26         {
27            // Finalisation de la biliothÚque MPI si nécessaire
28            comm::CMPIManager::Finalize();
29         }
30      }
31
32      ///-------------------------------------------------------------
33
34      StdString CXIOSManager::ExeName("unknown");
35      std::vector<StdString> CXIOSManager::ExeOptions;
36
37      CXIOSManager::XIOSType   CXIOSManager::Type    = CLIENT;
38      CXIOSManager::XIOSStatus CXIOSManager::Status  = LOC_UNUSED;
39
40      StdString     CXIOSManager::ClientName("unknown name");
41      comm::MPIComm CXIOSManager::Comm_Client_Server = -1;
42      comm::MPIComm CXIOSManager::Comm_Server = -1;
43
44      xios_map<StdString, CXIOSManager::XIOSClient> CXIOSManager::Clients;
45
46      ///--------------------------------------------------------------
47     
48      void CXIOSManager::RunServer
49         (StdString clientName, comm::MPIComm comm_client_server, comm::MPIComm comm_server)
50      {
51         using namespace comm;
52         
53         // Reconstruction de l'arborescence d'objet à l'aide des données envoyées par chacun des
54         // clients associés à ce serveur.
55         std::vector<boost::shared_ptr<CLinearBuffer> > clientBuffer;
56         for (int i = 1; i < CMPIManager::GetCommSize(comm_client_server); i++)
57         {
58            while (!CMPIManager::HasReceivedData(comm_client_server, i)){}
59            clientBuffer.push_back(CMPIManager::ReceiveLinearBuffer(comm_client_server, i));
60         }
61         
62         // La quasi-totalité de l'arborescence est obtenue depuis les informations
63         // fournies par le client 1 du sous-groupe.
64         StdString main_data_tree = clientBuffer[0]->getString(0);       
65         tree::CTreeManager::FromBinary(main_data_tree);
66         
67         // Obtention des sous-domaines clients.
68         for (int j = 1; j < clientBuffer.size(); j++)
69         {
70            main_data_tree = clientBuffer[j]->getString(0);
71            tree::CTreeManager::DomainsFromBinary(main_data_tree);
72         }
73         
74         StdOStringStream oss;
75         oss << StdString("data/def/def_server_end.")
76             << CMPIManager::GetCommRank(CMPIManager::GetCommWorld());
77         CTreeManager::PrintTreeToFile(oss.str());
78         
79         //data::CDataTreatment dt;     
80      }
81     
82      //--------------------------------------------------------------
83     
84      void CXIOSManager::ShowInformation_CS(comm::MPIComm comm_client_server)
85      {
86         using namespace comm;
87         typedef std::pair<StdString, XIOSClient> StdPairStrClient;
88         if (CMPIManager::IsMaster(comm_client_server))
89         {
90            std::cout << " *************************************** " << std::endl
91                      << " *     XmlIOServer (Client/Server)     * " << std::endl
92                      << " *************************************** " << std::endl;
93            std::cout << " > Nombre de processus : "
94                      << CMPIManager::GetCommSize(comm_client_server) << std::endl;
95            std::cout << " > Nombre de processus utilisés : "
96                      << (CXIOSManager::GetNbClient() + CXIOSManager::GetNbServer()) << std::endl;
97            std::cout << " > Nombre de clients : "
98                      << CXIOSManager::GetNbClient() << std::endl;
99            std::cout << " > Nombre de serveurs : "
100                      << CXIOSManager::GetNbServer() << std::endl;
101
102            xios_map<StdString, XIOSClient>::iterator
103               iit  = CXIOSManager::Clients.begin(),
104               eend = CXIOSManager::Clients.end();
105
106            for (;iit != eend; iit++)
107            {
108               const StdPairStrClient & elem = *iit;
109               std::cout << " - " << elem.first
110                         << " > nombre de clients : "             
111                         << elem.second.nbClient
112                         << " , nombre de clients par serveur : " 
113                         << elem.second.nbClientPServer
114                         << " , nombre de serveurs : "           
115                         << elem.second.nbClient/elem.second.nbClientPServer
116                         << std::endl;
117            }
118
119            std::cout << " *************************************** " << std::endl;
120         }
121
122         comm::CMPIManager::Barrier();
123         
124      }
125     
126      //--------------------------------------------------------------
127     
128      void CXIOSManager::RunClientServer(comm::MPIComm comm_client_server)
129      {
130         using namespace comm;
131         typedef std::pair<StdString, XIOSClient> StdPairStrClient;
132         
133         CXIOSManager::ShowInformation_CS(comm_client_server);
134         
135         xios_map<StdString, XIOSClient>::iterator
136               iit  = CXIOSManager::Clients.begin(),
137               eend = CXIOSManager::Clients.end();
138         
139         StdSize start = 0, end   = 0;
140         
141         bool isClient = true, isIncl = false, isIncl_ = false;
142         MPIComm comm_client = 0, comm_client_grp = 0; comm_client_server = 0;
143
144         for (;iit != eend; iit++)
145         {
146            const StdPairStrClient & elem = *iit;
147
148            std::vector<int> clieindex, servindex ;
149            StdSize   currentRank      = CMPIManager::GetCommRank();
150            StdString clientName       = elem.first;
151            StdSize   nbClient         = elem.second.nbClient;
152            StdSize   nbClientPServer  = elem.second.nbClientPServer;
153            StdSize   nbServer         = (elem.second.nbClient)/(elem.second.nbClientPServer);
154
155            for (StdSize i = 0; i<nbServer; i++)
156            {
157               end = start + nbClientPServer;
158               MPIComm comm_  =  CMPIManager::CreateComm
159                  (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), start, end));
160               MPIComm comm__ =  CMPIManager::CreateComm
161                  (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), start+1, end));
162                 
163               servindex.push_back(start);
164               for (StdSize j = start+1; j <= end; j++)
165                  clieindex.push_back(j);
166                               
167               if ((currentRank >= start) && (currentRank <= end))
168               {
169                  comm_client_server = comm_;
170                  comm_client_grp    = comm__;
171                  isIncl = true;
172                  CXIOSManager::ClientName = clientName;
173                  CXIOSManager::Status = LOC_CLIENT;
174               }
175               if (currentRank == start)
176               {
177                  isClient = false; isIncl_  = true;
178                  CXIOSManager::Comm_Client_Server = comm_;
179                  CXIOSManager::Status = LOC_SERVER;
180               }               
181               if (clieindex.size() == nbClient)
182               {
183                  MPIComm comm___ = CMPIManager::CreateComm
184                  (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), clieindex));
185                  if (isIncl) comm_client = comm___;
186                  clieindex.clear();
187                  isIncl = false;
188               }
189               
190               start = start + nbClientPServer + 1;
191            }
192            MPIComm comm____ = CMPIManager::CreateComm
193               (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), servindex));
194            if (isIncl_) CXIOSManager::Comm_Server = comm____;               
195            servindex.clear();
196            isIncl_ = false;           
197         }
198         
199         if (isClient && (CXIOSManager::Clients.find(CXIOSManager::ClientName) !=
200                          CXIOSManager::Clients.end()))
201         {
202            CXIOSManager::Clients[CXIOSManager::ClientName].entry
203               (comm_client, comm_client_grp, comm_client_server);
204         }
205         else if(CXIOSManager::Clients.find(CXIOSManager::ClientName) !=
206                 CXIOSManager::Clients.end())
207         {
208            CXIOSManager::RunServer(CXIOSManager::ClientName, 
209                                    CXIOSManager::Comm_Client_Server,
210                                    CXIOSManager::Comm_Server);
211         }
212      }
213     
214      //---------------------------------------------------------------
215     
216      void CXIOSManager::RunClient(comm::MPIComm comm_client)
217      {
218         CXIOSManager::Status  = LOC_CLIENT_SERVER;
219         (CXIOSManager::Clients.begin()->second.entry)(comm_client, comm_client, comm_client);
220      }
221
222      //---------------------------------------------------------------
223
224      void CXIOSManager::AddClient(StdString clientName, StdSize nbClient, StdSize nbClientPServer,
225                                   void (*entry_point)(comm::MPIComm, comm::MPIComm, comm::MPIComm))
226      {
227         StdSize nbprocess  = comm::CMPIManager::GetCommSize(comm::CMPIManager::GetCommWorld());
228         StdSize nbprocess_used = CXIOSManager::GetNbClient() + CXIOSManager::GetNbServer();
229
230         if (nbClient < nbClientPServer)
231            ERROR("CXIOSManager::AddClient(...)", 
232                  << "nbClient < nbClientPServer");
233                 
234         if ((nbClient % nbClientPServer) != 0)
235            ERROR("CXIOSManager::AddClient(...)",
236                  << " (nbClient % nbClientPServer) != 0 !");
237                 
238         if ((nbprocess-nbprocess_used) < (nbClient + nbClient/nbClientPServer))
239            ERROR("CXIOSManager::AddClient(...)",
240                  << " Pas assez de processus disponibles !");
241                 
242         if (CXIOSManager::Clients.find(clientName) != CXIOSManager::Clients.end())
243            ERROR("CXIOSManager::AddClient(...)",
244                  << " Un client portant le même nom existe déjà !");
245
246         XIOSClient client = {nbClient, nbClientPServer, entry_point };
247         CXIOSManager::Clients[clientName] = client;
248      }
249
250      //---------------------------------------------------------------
251
252      StdSize CXIOSManager::GetNbClient(void)
253      {
254         switch (CXIOSManager::Type)
255         {
256            case (CLIENT_SERVER):
257            {
258               StdSize retvalue = 0;
259               typedef std::pair<StdString, XIOSClient> StdPairStrClient;
260               xios_map<StdString, XIOSClient>::iterator
261                  iit  = CXIOSManager::Clients.begin(),
262                  eend = CXIOSManager::Clients.end();
263
264               for (;iit != eend; iit++)
265               {
266                  const StdPairStrClient & elem = *iit;
267                  retvalue += CXIOSManager::GetNbLocClient(elem.first);
268               }
269               
270               return (retvalue);
271            }
272            case (CLIENT):
273               return (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server));
274            case (SERVER):
275               return (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Client_Server) - 1);
276            default:
277               return (0);
278         }
279      }
280     
281      //---------------------------------------------------------------
282
283      StdSize CXIOSManager::GetNbLocClient(const StdString & clientName)
284      {
285         switch (CXIOSManager::Type)
286         {
287            case (CLIENT_SERVER):
288               return (CXIOSManager::Clients[clientName].nbClient);
289            case (CLIENT):
290            case (SERVER):
291               return (CXIOSManager::GetNbClient());
292            default:
293               return (0);
294         }
295      }
296
297      //---------------------------------------------------------------
298
299      StdSize CXIOSManager::GetNbServer(void)
300      {
301         switch (CXIOSManager::Type)
302         {
303            case (CLIENT_SERVER):
304            {
305               StdSize retvalue = 0;
306               typedef std::pair<StdString, XIOSClient> StdPairStrClient;             
307
308               xios_map<StdString, XIOSClient>::iterator
309                  iit  = CXIOSManager::Clients.begin(),
310                  eend = CXIOSManager::Clients.end();
311
312               for (;iit != eend; iit++)
313               {
314                  const StdPairStrClient & elem = *iit;
315                  retvalue += CXIOSManager::GetNbLocServer(elem.first);
316               }                 
317                 
318               return (retvalue);
319            }
320            case (CLIENT):
321               return (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server));
322            case (SERVER):
323               return (1);
324            default:
325               return (0);
326         }
327      }
328
329      //---------------------------------------------------------------
330
331      StdSize CXIOSManager::GetNbLocServer(const StdString & clientName)
332      {
333         switch (CXIOSManager::Type)
334         {
335            case (CLIENT_SERVER):
336               return (CXIOSManager::Clients[clientName].nbClient /
337                       CXIOSManager::Clients[clientName].nbClientPServer);
338            case (CLIENT):
339            case (SERVER):
340               return (CXIOSManager::GetNbServer());
341            default:
342               return (0);
343         }
344      }
345     
346      //---------------------------------------------------------------
347     
348      CXIOSManager::XIOSType   CXIOSManager::GetType(void)
349      {
350         return (CXIOSManager::Type);
351      }
352     
353      //---------------------------------------------------------------
354     
355      CXIOSManager::XIOSStatus CXIOSManager::GetStatus(void)
356      {
357         return (CXIOSManager::Status);
358      }
359     
360      //---------------------------------------------------------------
361     
362      StdString  CXIOSManager::GetClientName(void)
363      {
364         return (CXIOSManager::ClientName);
365      }
366
367      ///--------------------------------------------------------------
368
369} // namespace xmlioserver
Note: See TracBrowser for help on using the repository browser.