source: XMLIO_V2/dev/common/src/manager/xios_manager.cpp @ 300

Last change on this file since 300 was 300, checked in by ymipsl, 12 years ago

nouvelle version de developpement de xios

  • nouvelle interface fortran
  • recodage complet de la couche de communication
  • et bien d'autres choses...

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