Changeset 256 for XMLIO_V2/dev/dev_rv/src4

Timestamp:

07/12/11 16:32:19 (13 years ago)

Author:

hozdoba

Message:

Ajout de classes pour la version 4

Location:

XMLIO_V2/dev/dev_rv/src4/xmlio

Files:

• array_util.hpp (added)
• array_util_impl.hpp (added)
• exception.hpp (modified) (2 diffs)
• main_server.cpp (modified) (1 diff)
• mpi/mpi_interface.cpp (modified) (3 diffs)
• mpi/mpi_interface.hpp (modified) (3 diffs)
• netcdf/onetcdf4.hpp (modified) (1 diff)

XMLIO_V2/dev/dev_rv/src4/xmlio/exception.hpp

@@ -4 +4 @@
 
 #ifndef __EXCEPTION_HPP__
-#define __EXCEPTION_HPP__
+#define __EXCEPTION_HPP__
 
 #ifndef __XIOS_NO_EXTERN
@@ -15 +15 @@
 // XMLIOServer headers
 #include "object.hpp"
-
 
 /**

XMLIO_V2/dev/dev_rv/src4/xmlio/main_server.cpp

@@ -17 +17 @@
 
 #include "mpi_interface.hpp"
-#include "onetcdf4.hpp"
-#include "onetcdf4_impl.hpp"
+//~ #include "onetcdf4.hpp"
+//~ #include "onetcdf4_impl.hpp"
+#include "array_util.hpp"
+#include "array_util_impl.hpp"
 
 namespace xios = xmlioserver;
 //~ using namespace xios::data;
-using namespace xios::io;
+//~ using namespace xios::io;
 //~ using namespace xios::tree;
 //~ using namespace xios::xml;

XMLIO_V2/dev/dev_rv/src4/xmlio/mpi/mpi_interface.cpp

@@ -4 +4 @@
  
  /**
- * \file    mpi_interface.hpp
+ * \file    mpi_interface.cpp
  * \brief   Gestion des communications MPI via une surcouche interne (implémentation).
  * \author  Hervé Ozdoba
@@ -78 +78 @@
          XIOS_ERROR("CMPIManager::Barrier(comm)", << " MPI Error !");
    }
+   
+   bool CMPIManager::DispatchClient(bool       _is_server,
+                                    MPI_Comm & _comm_client,
+                                    MPI_Comm & _comm_client_server,
+                                    MPI_Comm & _comm_server,
+                                    MPI_Comm   _comm_parent)
+   {
+      int value = (_is_server) ? 1 : 2;
+      std::size_t nbClient = 0, nbServer = 0, nbClientByServer = 0;
+      std::vector<int> info, rank_client, rank_server;
+      CMPIManager::AllGather(value, info, _comm_parent);
+
+      for (std::size_t s = 0;  s < info.size(); s++)
+      {
+         if (info[s] == 1) rank_server.push_back(s);
+         else rank_client.push_back(s);
+      }
+      nbClient = rank_client.size();
+      nbServer = rank_server.size();
+         
+
+      _comm_client = CMPIManager::CreateComm(CMPIManager::CreateSubGroup(
+                     CMPIManager::GetGroupWorld(), rank_client), _comm_parent);
+
+      if (nbServer != 0)
+      {
+         std::size_t currentServer = 0;
+         nbClientByServer = nbClient/nbServer;
+         _comm_server = CMPIManager::CreateComm(CMPIManager::CreateSubGroup(
+                        CMPIManager::GetGroupWorld(), rank_server), _comm_parent);
+
+         //std::cout << nbClient << "," << nbServer  << "," << nbClientByServer << std::endl;
+
+         for (std::size_t mm = 0; mm < nbClient; mm += nbClientByServer)
+         {
+            std::vector<int> group_rank;
+            group_rank.push_back(rank_server[currentServer++]);
+            for (std::size_t nn = 0; nn < nbClientByServer; nn++)
+               group_rank.push_back(rank_client[nn+mm]);
+            MPI_Comm comm_client_server_ = CMPIManager::CreateComm(CMPIManager::CreateSubGroup(
+                                           CMPIManager::GetGroupWorld(), group_rank), _comm_parent);
+
+            if (std::find(group_rank.begin(), group_rank.end(),
+                         CMPIManager::GetCommRank(_comm_parent)) != group_rank.end())
+            {
+               _comm_client_server = comm_client_server_;
+            }
+               
+            group_rank.clear();
+         }
+         return (true);
+      }
+      else
+      {
+         _comm_server = _comm_client;
+         return (false);
+      }
+   }
+   
 
    // --------------------------------- Groupes --------------------------------
@@ -174 +233 @@
       CMPIManager::Wait (request); // Temporaire
    }
+   
+   void CMPIManager::AllGather(int _indata, std::vector<int> & _outdata, MPI_Comm _comm)
+   {
+      std::vector<int> data; data.push_back(_indata);
+      CMPIManager::AllGather(data, _outdata, _comm);
+   }
+
+   void  CMPIManager::AllGather(const std::vector<int> & _indata,
+                                      std::vector<int> & _outdata, MPI_Comm _comm)
+   {
+      int sendcount = _indata.size(),
+          recvcount = _indata.size() * CMPIManager::GetCommSize(_comm);
+      _outdata.resize(recvcount);     
+      if (MPI_Allgather ( const_cast<int*>(&(_indata[0])), sendcount, MPI_INTEGER,
+                                          &(_outdata[0]) , recvcount, MPI_INTEGER, _comm) != MPI_SUCCESS)
+         XIOS_ERROR("CMPIManager::AllGather (indata, outdata, comm)", << " MPI Error !");
+   }
          
    // ------------------------- Communication 'complexe' -----------------------

XMLIO_V2/dev/dev_rv/src4/xmlio/mpi/mpi_interface.hpp

@@ -40 +40 @@
       typedef MPI_Fint MPI_F_DataType; /*!< \brief Identifiant de type de données MPI (Fortran). */
       
+      /**
+       * \class CMPIManager
+       * \brief Surcouche interne de la biblià othÚque M(essage) P(assing) I(nterface).
+       */
       class CMPIManager
       {
@@ -49 +53 @@
          public : // Communicateurs
          
-            static int GetCommRank(MPI_Comm comm = CMPIManager::GetCommWorld());
-            static int GetCommSize(MPI_Comm comm = CMPIManager::GetCommWorld());
-            static MPI_Comm CreateComm(MPI_Group group, MPI_Comm pcomm = CMPIManager::GetCommWorld());
+            static int GetCommRank(MPI_Comm _comm = CMPIManager::GetCommWorld());
+            static int GetCommSize(MPI_Comm _comm = CMPIManager::GetCommWorld());
+            static MPI_Comm CreateComm(MPI_Group _group, MPI_Comm _pcomm = CMPIManager::GetCommWorld());
             static MPI_Comm GetCommWorld(void);
 
          public : // Autre
          
-            static void Barrier(MPI_Comm comm = CMPIManager::GetCommWorld());
+            static void Barrier(MPI_Comm _comm = CMPIManager::GetCommWorld());
+            
+            static bool DispatchClient(bool       _is_server,
+                                       MPI_Comm & _comm_client,
+                                       MPI_Comm & _comm_client_server,
+                                       MPI_Comm & _comm_server,
+                                       MPI_Comm   _comm_parent = CMPIManager::GetCommWorld());
 
          public : // Groupes
          
             static MPI_Group GetGroupWorld(void);
-            static MPI_Group CreateSubGroup(MPI_Group pgroup, const std::vector<int> & ranks);
-            static MPI_Group CreateSubGroup(MPI_Group pgroup, int min_rank, int max_rank, int intval = 1);
+            static MPI_Group CreateSubGroup(MPI_Group _pgroup, const std::vector<int> & _ranks);
+            static MPI_Group CreateSubGroup(MPI_Group _pgroup, int _min_rank, int _max_rank, int _intval = 1);
 
          public : // Tests 
          
-            static bool IsMaster(MPI_Comm comm = CMPIManager::GetCommWorld());
-            static bool IsRank(int rank, MPI_Comm comm = CMPIManager::GetCommWorld());
+            static bool IsMaster(MPI_Comm _comm = CMPIManager::GetCommWorld());
+            static bool IsRank(int _rank, MPI_Comm _comm = CMPIManager::GetCommWorld());
 
          public : // Communication simple
          
-            static void Send (MPI_Comm comm, int dest_rank, char * data,
-                              std::size_t size, MPI_Request & request);
-            static void Wait (MPI_Request & request);
-            static bool Test (MPI_Request & request);
+            static void Send (MPI_Comm _comm, int _dest_rank, char * _data,
+                              std::size_t _size, MPI_Request & _request);
+            static void Wait (MPI_Request & _request);
+            static bool Test (MPI_Request & _request);
 
-            static bool HasReceivedData(MPI_Comm comm, int src_rank);
-            static std::size_t GetReceivedDataSize(MPI_Comm comm, int src_rank);
-            static void Receive(MPI_Comm comm, int src_rank, char * data);
+            static bool HasReceivedData(MPI_Comm _comm, int _src_rank);
+            static std::size_t GetReceivedDataSize(MPI_Comm _comm, int _src_rank);
+            static void Receive(MPI_Comm _comm, int _src_rank, char * _data);
+            
+            static void AllGather(int _indata, std::vector<int> & _outdata,
+                                  MPI_Comm _comm = CMPIManager::GetCommWorld());
+
+            static void AllGather(const std::vector<int> & _indata,
+                                        std::vector<int> & _outdata,
+                                  MPI_Comm _comm = CMPIManager::GetCommWorld());
+
 
          public : // Communication 'complexe'
@@ -89 +107 @@
          public : // Mémoire (non fonctionnel ....)
          
-            static void AllocMemory(void * data, std::size_t size);
-            static void FreeMemory (void * data);
+            static void AllocMemory(void * _data, std::size_t _size);
+            static void FreeMemory (void * _data);
          
       }; // class CMPIManager

XMLIO_V2/dev/dev_rv/src4/xmlio/netcdf/onetcdf4.hpp

@@ -14 +14 @@
 #define MPI_INCLUDED
 #include <netcdf.h>
+extern "C" {
+#include <netcdf_par.h>
+}
 
 // C++ standard headers