Changeset 254


Ignore:
Timestamp:
07/08/11 11:21:13 (10 years ago)
Author:
hozdoba
Message:

Gestion du dispatch client

Location:
XMLIO_V2/dev/dev_rv
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • XMLIO_V2/dev/dev_rv/Makefile.wk

    r253 r254  
    1515VTK       = yes 
    1616GUI       = no 
    17 NPROC     = 5 
     17NPROC     = 12 
    1818#VERSION   = 4 
    1919CSUITE    = gnu 
     
    255255 
    256256LIBS_PATH  += -L $(NETCDF_LIB) -L $(HDF5_LIB) 
    257 LIBS       += -lnetcdf -lhdf5_hl -lhdf5 -lz 
     257LIBS       +=  -lnetcdf -lhdf5_hl -lhdf5 -lz 
    258258INCLUDE    += -I $(NETCDF_INCL) 
    259259 
  • XMLIO_V2/dev/dev_rv/src/xmlio/fortran/impi_interface.f90

    r204 r254  
    176176   END SUBROUTINE xios_mpi_barrier 
    177177 
     178   ! Collecte de données et rediffusion 
     179   SUBROUTINE xios_mpi_allgather(sendbuf, sendcount, recvbuf, recvcount, comm, ierror) BIND (C, NAME ="mpi_allgather") 
     180      INTEGER (kind = C_INT), DIMENSION(*) :: sendbuf, recvbuf 
     181      INTEGER (kind = C_INT)               :: sendcount, recvcount, comm, ierror 
     182       CALL MPI_ALLGATHER(sendbuf, sendcount, MPI_INTEGER, recvbuf, recvcount, MPI_INTEGER, comm, ierror) 
     183   END SUBROUTINE xios_mpi_allgather 
     184 
    178185END MODULE IMPI_INTERFACE 
  • XMLIO_V2/dev/dev_rv/src/xmlio/fortran/impi_interface.hpp

    r204 r254  
    8080void mpi_barrier(int * comm, int * err); 
    8181 
     82/// Collecte de données et rediffusion /// 
     83void mpi_allgather(int sendbuf[], int * sendcount, int recvbuf[], int * recvcount, int * comm, int * ierror); 
     84 
    8285#ifdef __cplusplus 
    8386} 
  • XMLIO_V2/dev/dev_rv/src/xmlio/main_server.cpp

    r200 r254  
    1616   try 
    1717   { 
     18      MPIComm comm_client, comm_client_server, comm_server; 
    1819      //comm::CMPIManager::Initialise(&argc, &argv); // < seulement en mode connecté 
    1920      //comm::CMPIManager::Finalize();               // < seulement en mode connecté 
    2021 
    2122      CXIOSManager::Initialise (CXIOSManager::CLIENT_SERVER, &argc, &argv); 
    22       CXIOSManager::AddClient ("nemo"    , 4, 2, &nemo_fake_entry); 
     23      //CXIOSManager::AddClient ("nemo"    , 4, 2, &nemo_fake_entry); 
    2324      //CXIOSManager::AddClient("orchidee", 1, 1, &orchidee_fake_entry); 
    2425      //CXIOSManager::AddClient("lmdz"    , 4, 2, &lmdz_fake_entry); 
    25       CXIOSManager::RunClientServer (comm::CMPIManager::GetCommWorld ()); 
     26      CMPIManager::DispatchClient(true, comm_client, comm_client_server,  comm_server); 
     27      CMPIManager::RunServer("Nemo", comm_client_server, comm_server); 
     28      //CXIOSManager::RunClientServer (comm::CMPIManager::GetCommWorld ()); 
    2629      CXIOSManager::Finalize (); 
    2730   } 
  • XMLIO_V2/dev/dev_rv/src/xmlio/manager/mpi_manager.cpp

    r196 r254  
    8888      } 
    8989 
     90      bool CMPIManager::DispatchClient(bool      is_server, 
     91                                       MPIComm & comm_client, 
     92                                       MPIComm & comm_client_server, 
     93                                       MPIComm & comm_server, 
     94                                       MPIComm   comm_parent) 
     95      { 
     96         int value = (is_server) ? 1 : 2; 
     97         StdSize nbClient = 0, nbServer = 0, nbClientByServer = 0; 
     98         std::vector<int> info, rank_client, rank_server; 
     99         CMPIManager::AllGather(value, info, comm_parent); 
     100 
     101         for (StdSize s = 0;  s < info.size(); s++) 
     102         { 
     103            if (info[s] == 1) rank_server.push_back(s); 
     104            else rank_client.push_back(s); 
     105         } 
     106         nbClient = rank_client.size(); 
     107         nbServer = rank_server.size(); 
     108          
     109 
     110         comm_client = CMPIManager::CreateComm(CMPIManager::CreateSubGroup( 
     111                       CMPIManager::GetGroupWorld(), rank_client), comm_parent); 
     112 
     113         if (nbServer != 0) 
     114         { 
     115            StdSize currentServer = 0; 
     116            nbClientByServer = nbClient/nbServer; 
     117            comm_server = CMPIManager::CreateComm(CMPIManager::CreateSubGroup( 
     118                          CMPIManager::GetGroupWorld(), rank_server), comm_parent); 
     119 
     120            //std::cout << nbClient << "," << nbServer  << "," << nbClientByServer << std::endl; 
     121 
     122            for (StdSize mm = 0; mm < nbClient; mm += nbClientByServer) 
     123            { 
     124               std::vector<int> group_rank; 
     125               group_rank.push_back(rank_server[currentServer++]); 
     126               for (StdSize nn = 0; nn < nbClientByServer; nn++) 
     127                  group_rank.push_back(rank_client[nn+mm]); 
     128               MPIComm comm_client_server_ = CMPIManager::CreateComm(CMPIManager::CreateSubGroup( 
     129                                             CMPIManager::GetGroupWorld(), group_rank), comm_parent); 
     130 
     131               if (std::find(group_rank.begin(), group_rank.end(), CMPIManager::GetCommRank()) != group_rank.end()) 
     132               { 
     133                  comm_client_server = comm_client_server_; 
     134               } 
     135                
     136               group_rank.clear(); 
     137            } 
     138            return (true); 
     139         } 
     140         else 
     141         { 
     142            comm_server = comm_client; 
     143            return (false); 
     144         } 
     145      } 
     146 
    90147      //--------------------------------------------------------------- 
    91148 
     
    211268      } 
    212269 
     270      void CMPIManager::AllGather(int indata, std::vector<int> & outdata, MPIComm comm) 
     271      { 
     272         std::vector<int> data; data.push_back(indata); 
     273         CMPIManager::AllGather(data, outdata, comm); 
     274      } 
     275 
     276      void  CMPIManager::AllGather(std::vector<int> & indata, 
     277                                   std::vector<int> & outdata, MPIComm comm) 
     278      { 
     279         int error = 0; 
     280         int sendcount = indata.size(), recvcount = indata.size() * CMPIManager::GetCommSize(comm); 
     281         outdata.resize(recvcount); 
     282         mpi_allgather(&(indata[0]), &sendcount, &(outdata[0]), &sendcount, &comm, &error); 
     283         if (error != mpi_success) 
     284            ERROR("CMPIManager::AllGather (indata, outdata, comm)", << " MPI Error !"); 
     285      } 
     286 
    213287      //-------------------------------------------------------------- 
    214288 
  • XMLIO_V2/dev/dev_rv/src/xmlio/manager/mpi_manager.hpp

    r152 r254  
    4040            static void Barrier(MPIComm comm = CMPIManager::GetCommWorld()); 
    4141 
     42            static bool DispatchClient(bool      is_server, 
     43                                       MPIComm & comm_client, 
     44                                       MPIComm & comm_client_server, 
     45                                       MPIComm & comm_server, 
     46                                       MPIComm   comm_parent = CMPIManager::GetCommWorld()); 
     47 
    4248            /// Groupes /// 
    4349            static MPIGroup GetGroupWorld(void); 
     
    5359            static void Wait (MPIRequest & request); 
    5460            static bool Test (MPIRequest & request); 
     61 
     62            static void AllGather(int indata, std::vector<int> & outdata, 
     63                                  MPIComm comm = CMPIManager::GetCommWorld()); 
     64 
     65            static void AllGather(std::vector<int> & indata, 
     66                                  std::vector<int> & outdata, 
     67                                  MPIComm comm = CMPIManager::GetCommWorld()); 
    5568 
    5669            static bool HasReceivedData(MPIComm comm, int src_rank); 
  • XMLIO_V2/dev/dev_rv/src/xmlio/output/onetcdf4.cpp

    r202 r254  
    4949            { 
    5050               CheckError(nc_create_par 
    51                   (filename.c_str(), NC_NETCDF4|NC_MPIPOSIX, *comm, MPI_INFO_NULL, &this->ncidp)); 
     51                  (filename.c_str(), NC_NETCDF4|NC_MPIIO, *comm, MPI_INFO_NULL, &this->ncidp)); 
    5252            } 
    5353            else CheckError(nc_create(filename.c_str(), NC_NETCDF4, &this->ncidp)); 
  • XMLIO_V2/dev/dev_rv/src/xmlio/output/onetcdf4.hpp

    r202 r254  
    1212#define MPI_INCLUDED 
    1313#include <netcdf.h> 
     14extern "C" { 
     15#include <netcdf_par.h> 
     16} 
     17 
    1418 
    1519#ifndef UNLIMITED_DIM 
  • XMLIO_V2/dev/dev_rv/src4/xmlio/fortran/idomain.f90

    r249 r254  
    4444      INTEGER                        , OPTIONAL, INTENT(IN) :: jend_ 
    4545      INTEGER                        , OPTIONAL, INTENT(IN) :: nj_ 
    46       LOGICAL                        , dimension(*), OPTIONAL, INTENT(IN) :: mask_(:,:) 
     46      LOGICAL          , dimension(*), OPTIONAL, INTENT(IN) :: mask_(:,:) 
    4747      INTEGER                        , OPTIONAL, INTENT(IN) :: data_dim_ 
    4848      INTEGER                        , OPTIONAL, INTENT(IN) :: data_ni_ 
     
    9393      INTEGER                          , OPTIONAL, INTENT(IN) :: nj_ 
    9494      LOGICAL          , dimension(*)  , OPTIONAL, INTENT(IN) :: mask_(:,:) 
    95       LOGICAL(kind = 1), dimension(:,:), ALLOCATABLE          :: mask__ 
     95      LOGICAL(kind = 1), dimension(:,:), ALLOCATABLE          :: mask__! (size(mask_,1),size(mask,2)) 
    9696      INTEGER                          , OPTIONAL, INTENT(IN) :: data_dim_ 
    9797      INTEGER                          , OPTIONAL, INTENT(IN) :: data_ni_ 
Note: See TracChangeset for help on using the changeset viewer.