Changeset 1638


Ignore:
Timestamp:
01/22/19 16:15:03 (3 months ago)
Author:
yushan
Message:

dev on ADA

Location:
XIOS
Files:
17 added
77 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/branch_openmp/arch/arch-X64_ADA.env

    r986 r1638  
    1 module unload compilerwrappers 
     1module load gcc/6.4.0 
     2module load  intel/2018.2 
    23module unload netcdf 
    34module unload hdf5 
    4  
    5 module load netcdf/mpi/4.1.3 
     5#module load netcdf/mpi/4.1.3 
    66#module load hdf5/mpi/1.8.9 
    7  
    8 export NETCDF_INC_DIR=/smplocal/pub/NetCDF/4.1.3/mpi/include 
    9 export NETCDF_LIB_DIR=/smplocal/pub/NetCDF/4.1.3/mpi/lib 
    10 export HDF5_INC_DIR=/smplocal/pub/HDF5/1.8.9/par/include 
    11 export HDF5_LIB_DIR=/smplocal/pub/HDF5/1.8.9/par/lib 
  • XIOS/dev/branch_openmp/arch/arch-X64_ADA.fcm

    r1545 r1638  
    33################################################################################ 
    44 
    5 %CCOMPILER      mpiicc -qopenmp -D_usingEP -D_intelmpi  
    6 %FCOMPILER      mpiifort -qopenmp -D_usingEP -D_intelmpi 
    7 %LINKER         mpiifort  -nofor-main -qopenmp -D_usingEP -D_intelmpi 
     5%CCOMPILER      mpiicc -std=c++11  
     6%FCOMPILER      mpiifort  
     7%LINKER         mpiifort  -nofor-main 
    88 
    9  
    10 %BASE_CFLAGS    -std=c++11 -diag-disable 1125 -diag-disable 279 
     9%BASE_CFLAGS    -diag-disable 1125 -diag-disable 279  
    1110%PROD_CFLAGS    -O3 -D BOOST_DISABLE_ASSERTS 
    1211%DEV_CFLAGS     -g -traceback 
    13 %DEBUG_CFLAGS   -DBZ_DEBUG -g  -fno-inline  
    14  
     12%DEBUG_CFLAGS   -DBZ_DEBUG -g -traceback -fno-inline 
    1513 
    1614%BASE_FFLAGS    -D__NONE__  
    1715%PROD_FFLAGS    -O3 
    1816%DEV_FFLAGS     -g -O2 -traceback 
    19 %DEBUG_FFLAGS   -g  
     17%DEBUG_FFLAGS   -g -traceback 
    2018 
    2119%BASE_INC       -D__NONE__ 
    22 %BASE_LD        -lstdc++  
     20%BASE_LD        -lstdc++ -Wl,-rpath=/smplocal/pub/NetCDF/4.1.3/mpi/lib:/smplocal/pub/HDF5/1.8.9/par/lib 
    2321 
    2422%CPP            mpiicc -EP 
  • XIOS/dev/branch_openmp/arch/arch-X64_ADA.path

    r986 r1638  
    1 NETCDF_INCDIR="-I $NETCDF_INC_DIR" 
    2 #NETCDF_LIBDIR="-L $NETCDF_LIB_DIR" 
    3 #NETCDF_LIB="-lnetcdff -lnetcdf" 
     1NETCDF_INCDIR="-I/smplocal/pub/NetCDF/4.1.3/mpi/include" 
     2NETCDF_LIBDIR="-L/smplocal/pub/NetCDF/4.1.3/mpi/lib" 
     3NETCDF_LIB="-lnetcdff -lnetcdf" 
    44 
    55MPI_INCDIR="" 
     
    77MPI_LIB="" 
    88 
    9 #HDF5_INCDIR="-I $HDF5_INC_DIR" 
    10 #HDF5_LIBDIR="-L $HDF5_LIB_DIR" 
    11 #HDF5_LIB="-lhdf5_hl -lhdf5 -lhdf5 -lz" 
     9HDF5_INCDIR="-I/smplocal/pub/HDF5/1.8.9/par/include" 
     10HDF5_LIBDIR="-L/smplocal/pub/HDF5/1.8.9/par/lib" 
     11HDF5_LIB="-lhdf5_hl -lhdf5 -lhdf5 -lz" 
    1212 
    1313OASIS_INCDIR="-I$PWD/../../oasis3-mct/BLD/build/lib/psmile.MPI1" 
  • XIOS/dev/branch_openmp/bld.cfg

    r1556 r1638  
    88# ------------------------------------------------------------------------------ 
    99 
    10 inc arch.fcm 
    11 inc config.fcm 
     10# Specifying the build directory and src::blitz if necessary. 
     11inc bld_dir.cfg 
    1212 
    1313%CFLAGS           %BASE_CFLAGS %COMPIL_CFLAGS 
     
    1515%LD_FLAGS         %ARCH_LD %BASE_LD 
    1616 
    17  
    18 dest::root   $PWD 
    19  
    2017bld::infile_ext::cpp   C::SOURCE 
    2118bld::infile_ext::conf  CPP::INCLUDE 
    2219bld::infile_ext::hpp   CPP::INCLUDE 
    2320 
     21# IMPORTANT: as the build directory may not necessarily coincide with the source directory,  
     22# each source subfolder should be declared individually 
     23search_src           false 
     24src::xios                               $PWD/src 
     25src::xios::config                       $PWD/src/config 
     26src::xios::date                         $PWD/src/date 
     27src::xios::filter                       $PWD/src/filter 
     28src::xios::functor                      $PWD/src/functor 
     29src::xios::interface::c                 $PWD/src/interface/c 
     30src::xios::interface::c_attr            $PWD/src/interface/c_attr 
     31src::xios::interface::fortran           $PWD/src/interface/fortran 
     32src::xios::interface::fortran_attr      $PWD/src/interface/fortran_attr 
     33src::xios::io                           $PWD/src/io 
     34src::xios::node                         $PWD/src/node 
     35src::xios::parse_expr                   $PWD/src/parse_expr 
     36src::xios::test                         $PWD/src/test 
     37src::xios::transformation               $PWD/src/transformation 
     38src::xios::transformation::Functions    $PWD/src/transformation/Functions 
     39src::xios::type                         $PWD/src/type 
    2440 
    25 search_src           true 
    26 src::zzz . 
    27 src::date $PWD/extern/boost/src/date_time 
    28 src::blitz $PWD/extern/blitz/src 
    2941src::netcdf $PWD/extern/netcdf4 
    3042src::remap $PWD/extern/remap/src 
    31 src::src_ep_dev $PWD/extern/src_ep_dev 
    32 #src::src_ep_dev $PWD/extern/ep_dev 
     43src::ep $PWD/extern/src_ep_dev 
     44#src::ep $PWD/extern/src_ep_dev2 
     45 
    3346bld::lib xios 
    34 bld::target libxios.a  
     47#bld::target libxios.a  
    3548#bld::target generate_fortran_interface.exe  
    36 bld::target xios_server.exe  
     49#bld::target test_remap.exe 
     50#bld::target xios_server.exe  
    3751#bld::target test_regular.exe 
    38 #bld::target test_expand_domain.exe 
    39 #bld::target test_new_features.exe  
    40 #bld::target test_unstruct_complete.exe  
    41 #bld::target test_omp.exe  
    42 #bld::target test_complete_omp.exe  
    43 #bld::target test_remap.exe  
    44 #bld::target test_remap_ref.exe  
    45 #bld::target test_remap_omp.exe  
    46 #bld::target test_unstruct_omp.exe 
    47 #bld::target test_netcdf_omp.exe 
    48 #bld::target test_client.exe  
     52#bld::target test_xios2_cmip6.exe 
     53#bld::target test_new_features.exe test_unstruct_complete.exe  
     54#bld::target test_remap.exe#bld::target test_complete.exe 
    4955#bld::target test_complete.exe 
    50 #bld::target test_remap.exe 
    51 #bld::target test_xios2_cmip6.exe 
    52 #bld::target test_connectivity_expand.exe 
    53 #bld::target toy_cmip6.exe 
    54 #bld::target toy_cmip6_omp.exe 
     56#bld::target test_client.exe 
     57bld::target test_omp.exe 
     58#bld::target test_unstruct_complete.exe 
     59#bld::target test_unstructured.exe 
    5560bld::exe_dep 
    5661 
     
    6368bld::tool::ld        %LINKER 
    6469bld::tool::ldflags   %LD_FLAGS  
    65 bld::tool::cflags    %CFLAGS %CBASE_INC -I${PWD}/extern/src_netcdf -I${PWD}/extern/boost/include -I${PWD}/extern/rapidxml/include -I${PWD}/extern/blitz/include  
     70bld::tool::cflags    %CFLAGS %CBASE_INC -I${PWD}/extern/src_netcdf -I${PWD}/extern/boost/include -I${PWD}/extern/rapidxml/include -I${PWD}/extern/blitz/include -I${PWD}/extern/src_ep_dev  
     71#bld::tool::cflags    %CFLAGS %CBASE_INC -I${PWD}/extern/src_netcdf -I${PWD}/extern/boost/include -I${PWD}/extern/rapidxml/include -I${PWD}/extern/blitz/include -I${PWD}/extern/src_ep_dev2  
    6672bld::tool::fflags    %FFLAGS %FBASE_INC  
    6773bld::tool::cppkeys   %CPP_KEY 
     
    7177# Pre-process code before analysing dependencies 
    7278bld::pp    false           
    73 bld::pp::interface/fortran              true 
    74 bld::pp::interface/fortran_attr         true 
     79bld::pp::xios::interface::fortran              true 
     80bld::pp::xios::interface::fortran_attr         true 
    7581bld::excl_dep        use::mod_prism_get_comm 
    7682bld::excl_dep        use::mod_prism_get_localcomm_proto 
  • XIOS/dev/branch_openmp/inputs/iodef.xml

    r1544 r1638  
    1111     <field id="field_Domain"  operation="average" freq_op="3600s" domain_ref="domain_A"/> 
    1212     <field id="field_A_zoom"  operation="average" freq_op="3600s" field_ref="field_A" grid_ref="grid_A_zoom"/> 
    13      <field id="field_Scalar"  operation="average" freq_op="3600s" grid_ref="grid_Scalar"/> 
     13     <field id="field_Scalar"  operation="instant" freq_op="3600s" grid_ref="grid_Scalar"/> 
    1414   </field_definition> 
    1515 
    1616 
    1717   <file_definition type="one_file" par_access="collective" output_freq="1h" output_level="10" enabled=".TRUE."> 
    18      <file id="output" name="output" enabled=".TRUE."> 
     18     <file id="output" name="output" > 
    1919        <field field_ref="field_A" name="field_A" /> 
    2020        <field field_ref="field_A_zoom" name="field_B" /> 
    2121     </file> 
    22      <file id="output1" name="output1" enabled=".TRUE."> 
     22     <file id="output1" name="output1"> 
    2323        <field field_ref="field_A" name="field_A" /> 
    2424     </file> 
    25      <file id="output2" name="output2" enabled=".TRUE."> 
     25     <file id="output2" name="output2" > 
    2626        <field field_ref="field_Scalar" name="field_A" /> 
    2727     </file> 
     
    7171        <variable_group id="parameters" > 
    7272          <variable id="using_server" type="bool">false</variable> 
    73           <variable id="info_level" type="int">50</variable> 
     73          <variable id="info_level" type="int">100</variable> 
    7474          <variable id="print_file" type="bool">true</variable> 
    7575        </variable_group> 
  • XIOS/dev/branch_openmp/make_xios

    r1157 r1638  
    55use_oasis="false" 
    66oasis="oasis3_mct" 
     7build_path="./" 
     8build_dir="./" 
     9build_suffixed="false" 
     10use_extern_boost="false" 
     11use_extern_blitz="false" 
    712use_memtrack="false" 
    813job="1" 
    914netcdf_lib="netcdf4_par" 
    1015compil_mode="prod" 
    11 arch_path="arch" 
    12 arch_default_path="arch" 
     16arch_path=$PWD/"arch" 
     17arch_default_path=$PWD/"arch" 
    1318arch_defined="FALSE" 
    1419arch_path_defined="FALSE" 
     
    2934            echo "       [--full] : to generate dependencies and recompile from scratch" 
    3035            echo "       [--use_oasis 'oasis3' 'oasis3_mct' : default oasis3_mct] : to use Oasis coupler" 
     36        echo "       [--build_path : absolute path to the build directory" 
     37        echo "       [--build_dir : name of the build directory" 
     38        echo "       [--build_suffixed : generate automatically suffixed name of the build directory (e.g. config_X64_CURIE_prod)" 
     39        echo "       [--use_extern_boost : to use external boost library" 
     40        echo "       [--use_extern_blitz : to use external blitz library" 
    3141            echo "       [--doc] : to generate Doxygen documentation (not available yet)" 
    3242            echo "       [--job ntasks] : to use parallel compilation with ntasks" 
     
    4454         "--full")  compil_full="true"  ; shift ;; 
    4555         "--use_oasis")  use_oasis="true" oasis=$2 ; shift ; shift  ;; 
     56         "--build_path")  build_path=$2     ; shift ; shift ;; 
     57         "--build_dir")  build_dir=$2     ; shift ; shift ;; 
     58         "--build_suffixed")  build_suffixed="true" ; shift  ;; 
     59         "--use_extern_boost")  use_extern_boost="true" ; shift  ;; 
     60         "--use_extern_blitz")  use_extern_blitz="true" ; shift  ;; 
    4661         "--doc")   doc="true"          ; shift ;; 
    4762         "--job")   job=$2              ; shift ; shift ;; 
    4863         "--netcdf_lib")   netcdf_lib=$2 ; shift ; shift ;; 
    4964         "--memtrack")  use_memtrack="true" memtrack=$2  ; shift ; shift ;; 
    50           *)         code="$1"           ; shift ;; 
    51        esac 
    52     done 
     65         *)         code="$1"           ; shift ;; 
     66      esac 
     67   done 
    5368 
    5469# Installation des sources 
     
    5873    echo -e "- uncompress archives ..."          
    5974    for tarname in `ls $install_dir/tools/archive/*.tar.gz` ; do 
     75        if  ( [[ ${tarname} == "${install_dir}/tools/archive/boost.tar.gz" ]] && [[ "$use_extern_boost" == "true" ]] ) || ( [[ ${tarname} == "${install_dir}/tools/archive/blitz.tar.gz" ]] && [[ "$use_extern_blitz" == "true" ]] ) 
     76        then 
     77                continue 
     78        fi 
    6079        gunzip -f "$tarname" 
    6180        tar -xf ${tarname%.gz} 
    6281    done 
    6382fi 
     83 
     84# Definition of the root directory of the build 
     85 
     86if [[ "$build_path" == "./" ]]; then 
     87  install_dir=$PWD 
     88else 
     89  install_dir=${build_path} 
     90fi 
     91 
     92if [[ "$build_suffixed" == "true" ]]; then 
     93    install_dir="${install_dir}/config_${arch}_${compil_mode}" 
     94else 
     95    install_dir="${install_dir}/${build_dir}" 
     96fi 
     97 
     98mkdir -p $install_dir 
     99 
     100rm -f ${PWD}/bld_dir.cfg 
     101echo "inc    ${install_dir}/arch.fcm" >> ${PWD}/bld_dir.cfg  
     102echo "inc    ${install_dir}/config.fcm" >> ${PWD}/bld_dir.cfg 
     103echo "dir::root  ${install_dir}"   >> ${PWD}/bld_dir.cfg 
    64104 
    65105# Vérification de la présence d'un identifiant d'architecture. 
     
    77117if [[ "$arch_defined" == "TRUE" ]] 
    78118then 
    79   rm -f arch.path 
    80   rm -f arch.fcm 
    81   rm -f arch.env 
     119  rm -f ${install_dir}/arch.path 
     120  rm -f ${install_dir}/arch.fcm 
     121  rm -f ${install_dir}/arch.env 
    82122 
    83123  if test -f $arch_path/arch-${arch}.path 
    84124  then 
    85     ln -s $arch_path/arch-${arch}.path arch.path 
     125    ln -s $arch_path/arch-${arch}.path ${install_dir}/arch.path 
    86126  elif test -f $arch_default_path/arch-${arch}.path 
    87127  then 
    88     ln -s $arch_default_path/arch-${arch}.path arch.path 
     128    ln -s $arch_default_path/arch-${arch}.path ${install_dir}/arch.path 
    89129  fi 
    90130         
    91131  if test -f $arch_path/arch-${arch}.fcm 
    92132  then 
    93     ln -s $arch_path/arch-${arch}.fcm arch.fcm 
     133    ln -s $arch_path/arch-${arch}.fcm ${install_dir}/arch.fcm 
    94134  elif test -f $arch_default_path/arch-${arch}.fcm 
    95135  then 
    96     ln -s $arch_default_path/arch-${arch}.fcm arch.fcm 
     136    ln -s $arch_default_path/arch-${arch}.fcm ${install_dir}/arch.fcm 
    97137  fi 
    98138 
    99139  if test -f $arch_path/arch-${arch}.env 
    100140  then 
    101     ln -s $arch_path/arch-${arch}.env arch.env 
     141    ln -s $arch_path/arch-${arch}.env ${install_dir}/arch.env 
    102142  elif test -f $arch_default_path/arch-${arch}.env 
    103143  then 
    104     ln -s $arch_default_path/arch-${arch}.env arch.env 
     144    ln -s $arch_default_path/arch-${arch}.env ${install_dir}/arch.env 
    105145  else 
    106     ln -s .void_file arch.env 
     146    ln -s .void_file ${install_dir}/arch.env 
    107147  fi 
    108   source arch.env 
    109   source arch.path 
     148  source ${install_dir}/arch.env 
     149  source ${install_dir}/arch.path 
    110150else 
    111151      echo "Please choose a target achitecture --> list all available architecture using make_xios --avail!" 
     
    170210fi  
    171211 
     212# Setting path for boost 
     213if [[ "$use_extern_boost" == "true" ]] 
     214then 
     215   rm -r $PWD/extern/boost 
     216   ln -s $PWD/.void_dir $PWD/extern/boost 
     217else 
     218   export BOOST_INCDIR="-I${PWD}/extern/boost" 
     219   export BOOST_LIBDIR="" 
     220   export BOOST_LIB="" 
     221fi 
     222 
     223# Setting path for blitz 
     224if [[ "$use_extern_blitz" == "true" ]] 
     225then 
     226   rm -r $PWD/extern/blitz 
     227   ln -s $PWD/.void_dir $PWD/extern/blitz 
     228else 
     229   echo "src::blitz $PWD/extern/blitz/src" >> ${PWD}/bld_dir.cfg 
     230   export BLITZ_INCDIR="-I${PWD}/extern/blitz" 
     231   export BLITZ_LIBDIR="" 
     232   export BLITZ_LIB="" 
     233fi 
     234 
     235 
    172236if [[ "$use_memtrack" == "true" ]] 
    173237   then 
    174238   XIOS_CPPKEY="$XIOS_CPPKEY XIOS_MEMTRACK" 
    175    if [[ "$memtrack" == "light" ]] 
    176     then 
    177         XIOS_CPPKEY="$XIOS_CPPKEY XIOS_MEMTRACK_LIGHT" 
     239 
     240    if [[ "$memtrack" == "light" ]] 
     241    then 
     242        XIOS_CPPKEY="$XIOS_CPPKEY XIOS_MEMTRACK_LIGHT" 
    178243    elif [[ "$memtrack" == "FULL"  ]] 
    179244    then 
     
    186251fi  
    187252 
    188 XIOS_CINCDIR="$NETCDF_INCDIR $HDF5_INCDIR $MPI_INCDIR" 
    189 XIOS_FINCDIR="$NETCDF_INCDIR $XIOS_FINCDIR $MPI_INCDIR" 
     253XIOS_CINCDIR="$NETCDF_INCDIR $HDF5_INCDIR $MPI_INCDIR $BOOST_INCDIR $BLITZ_INCDIR" 
     254XIOS_FINCDIR="$NETCDF_INCDIR $XIOS_FINCDIR $MPI_INCDIR $BOOST_INCDIR $BLITZ_INCDIR" 
    190255 
    191256XIOS_LIB="$XIOS_LIB $NETCDF_LIBDIR $HDF5_LIBDIR $MPI_LIBDIR $NETCDF_LIB $HDF5_LIB $MPI_LIB" 
    192257 
    193 rm -f config.fcm 
    194 echo "%COMPIL_CFLAGS $COMPIL_CFLAGS" >> config.fcm 
    195 echo "%COMPIL_FFLAGS $COMPIL_FFLAGS" >> config.fcm 
    196 echo "%CPP_KEY       $XIOS_CPPKEY"   >> config.fcm 
    197  
    198 echo "%CBASE_INC     $XIOS_CINCDIR" >> config.fcm      
    199 echo "%FBASE_INC     $XIOS_FINCDIR" >> config.fcm 
    200 echo "%ARCH_LD       $XIOS_LIB"     >> config.fcm  
     258rm -f ${install_dir}/config.fcm 
     259echo "%COMPIL_CFLAGS $COMPIL_CFLAGS" >> ${install_dir}/config.fcm 
     260echo "%COMPIL_FFLAGS $COMPIL_FFLAGS" >> ${install_dir}/config.fcm 
     261echo "%CPP_KEY       $XIOS_CPPKEY"   >> ${install_dir}/config.fcm 
     262 
     263echo "%CBASE_INC     $XIOS_CINCDIR" >> ${install_dir}/config.fcm      
     264echo "%FBASE_INC     $XIOS_FINCDIR" >> ${install_dir}/config.fcm 
     265echo "%ARCH_LD       $XIOS_LIB"     >> ${install_dir}/config.fcm  
    201266 
    202267echo "=> Using "$compil_mode" mode for compiling under architecture \""$arch"\" !" 
  • XIOS/trunk/extern/remap/src/libmapper.cpp

    r1614 r1638  
    4343  double* src_area=NULL ; 
    4444  double* dst_area=NULL ; 
    45   mapper = new Mapper(MPI_COMM_WORLD); 
     45  mapper = new Mapper(EP_COMM_WORLD); 
    4646  mapper->setVerbosity(PROGRESS) ; 
    4747  mapper->setSourceMesh(src_bounds_lon, src_bounds_lat, src_area, n_vert_per_cell_src, n_cell_src, src_pole ) ; 
  • XIOS/trunk/extern/remap/src/mapper.cpp

    r1614 r1638  
    3232 
    3333  int mpiRank, mpiSize; 
    34   MPI_Comm_rank(communicator, &mpiRank); 
    35   MPI_Comm_size(communicator, &mpiSize); 
     34  ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
     35  ep_lib::MPI_Comm_size(communicator, &mpiSize); 
    3636 
    3737  sourceElements.reserve(nbCells); 
     
    4343    long int offset ; 
    4444    long int nb=nbCells ; 
    45     MPI_Scan(&nb,&offset,1,MPI_LONG,MPI_SUM,communicator) ; 
     45    ep_lib::MPI_Scan(&nb,&offset,1,EP_LONG,EP_SUM,communicator) ; 
    4646    offset=offset-nb ; 
    4747    for(int i=0;i<nbCells;i++) sourceGlobalId[i]=offset+i ; 
     
    7070 
    7171  int mpiRank, mpiSize; 
    72   MPI_Comm_rank(communicator, &mpiRank); 
    73   MPI_Comm_size(communicator, &mpiSize); 
     72  ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
     73  ep_lib::MPI_Comm_size(communicator, &mpiSize); 
    7474 
    7575  targetElements.reserve(nbCells); 
     
    8181    long int offset ; 
    8282    long int nb=nbCells ; 
    83     MPI_Scan(&nb,&offset,1,MPI_LONG,MPI_SUM,communicator) ; 
     83    ep_lib::MPI_Scan(&nb,&offset,1,EP_LONG,EP_SUM,communicator) ; 
    8484    offset=offset-nb ; 
    8585    for(int i=0;i<nbCells;i++) targetGlobalId[i]=offset+i ; 
     
    117117  vector<double> timings; 
    118118  int mpiSize, mpiRank; 
    119   MPI_Comm_size(communicator, &mpiSize); 
    120   MPI_Comm_rank(communicator, &mpiRank); 
     119  ep_lib::MPI_Comm_size(communicator, &mpiSize); 
     120  ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
    121121 
    122122  this->buildSSTree(sourceMesh, targetMesh); 
     
    173173{ 
    174174  int mpiSize, mpiRank; 
    175   MPI_Comm_size(communicator, &mpiSize); 
    176   MPI_Comm_rank(communicator, &mpiRank); 
     175  ep_lib::MPI_Comm_size(communicator, &mpiSize); 
     176  ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
    177177 
    178178  /* create list of intersections (super mesh elements) for each rank */ 
     
    235235  /* communicate sizes of source elements to be sent (index lists and later values and gradients) */ 
    236236  int *nbRecvElement = new int[mpiSize]; 
    237   MPI_Alltoall(nbSendElement, 1, MPI_INT, nbRecvElement, 1, MPI_INT, communicator); 
     237  ep_lib::MPI_Alltoall(nbSendElement, 1, EP_INT, nbRecvElement, 1, EP_INT, communicator); 
    238238 
    239239  /* communicate indices of source elements on other ranks whoes value and gradient we need (since intersection) */ 
     
    246246  Coord **sendGrad = new Coord*[mpiSize]; 
    247247  GloId **sendNeighIds = new GloId*[mpiSize]; 
    248   MPI_Request *sendRequest = new MPI_Request[5*mpiSize]; 
    249   MPI_Request *recvRequest = new MPI_Request[5*mpiSize]; 
     248  ep_lib::MPI_Request *sendRequest = new ep_lib::MPI_Request[5*mpiSize]; 
     249  ep_lib::MPI_Request *recvRequest = new ep_lib::MPI_Request[5*mpiSize]; 
    250250  for (int rank = 0; rank < mpiSize; rank++) 
    251251  { 
    252252    if (nbSendElement[rank] > 0) 
    253253    { 
    254       MPI_Issend(sendElement[rank], nbSendElement[rank], MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     254      ep_lib::MPI_Issend(sendElement[rank], nbSendElement[rank], EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    255255      nbSendRequest++; 
    256256    } 
     
    271271        sendNeighIds[rank] = new GloId[nbRecvElement[rank]]; 
    272272      } 
    273       MPI_Irecv(recvElement[rank], nbRecvElement[rank], MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     273      ep_lib::MPI_Irecv(recvElement[rank], nbRecvElement[rank], EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    274274      nbRecvRequest++; 
    275275    } 
    276276  } 
    277   MPI_Status *status = new MPI_Status[5*mpiSize]; 
     277  ep_lib::MPI_Status *status = new ep_lib::MPI_Status[5*mpiSize]; 
    278278   
    279   MPI_Waitall(nbSendRequest, sendRequest, status); 
    280         MPI_Waitall(nbRecvRequest, recvRequest, status); 
     279  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
     280        ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
    281281 
    282282  /* for all indices that have been received from requesting ranks: pack values and gradients, then send */ 
     
    310310          sendNeighIds[rank][j] = sstree.localElements[recvElement[rank][j]].src_id; 
    311311      } 
    312       MPI_Issend(sendValue[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     312      ep_lib::MPI_Issend(sendValue[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    313313      nbSendRequest++; 
    314       MPI_Issend(sendArea[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     314      ep_lib::MPI_Issend(sendArea[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    315315      nbSendRequest++; 
    316       MPI_Issend(sendGivenArea[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     316      ep_lib::MPI_Issend(sendGivenArea[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    317317      nbSendRequest++; 
    318318      if (order == 2) 
    319319      { 
    320         MPI_Issend(sendGrad[rank], 3*nbRecvElement[rank]*(NMAX+1), MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     320        ep_lib::MPI_Issend(sendGrad[rank], 3*nbRecvElement[rank]*(NMAX+1), EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    321321        nbSendRequest++; 
    322         MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank]*(NMAX+1), MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     322        ep_lib::MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank]*(NMAX+1), EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    323323//ym  --> attention taille GloId 
    324324        nbSendRequest++; 
     
    326326      else 
    327327      { 
    328         MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank], MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     328        ep_lib::MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank], EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    329329//ym  --> attention taille GloId 
    330330        nbSendRequest++; 
     
    333333    if (nbSendElement[rank] > 0) 
    334334    { 
    335       MPI_Irecv(recvValue[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     335      ep_lib::MPI_Irecv(recvValue[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    336336      nbRecvRequest++; 
    337       MPI_Irecv(recvArea[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     337      ep_lib::MPI_Irecv(recvArea[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    338338      nbRecvRequest++; 
    339       MPI_Irecv(recvGivenArea[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     339      ep_lib::MPI_Irecv(recvGivenArea[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    340340      nbRecvRequest++; 
    341341      if (order == 2) 
    342342      { 
    343         MPI_Irecv(recvGrad[rank], 3*nbSendElement[rank]*(NMAX+1), 
    344             MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     343        ep_lib::MPI_Irecv(recvGrad[rank], 3*nbSendElement[rank]*(NMAX+1), 
     344            EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    345345        nbRecvRequest++; 
    346         MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank]*(NMAX+1), MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     346        ep_lib::MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank]*(NMAX+1), EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    347347//ym  --> attention taille GloId 
    348348        nbRecvRequest++; 
     
    350350      else 
    351351      { 
    352         MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank], MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     352        ep_lib::MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank], EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    353353//ym  --> attention taille GloId 
    354354        nbRecvRequest++; 
     
    357357  } 
    358358         
    359         MPI_Waitall(nbSendRequest, sendRequest, status); 
    360   MPI_Waitall(nbRecvRequest, recvRequest, status); 
     359        ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
     360  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
    361361   
    362362 
     
    487487{ 
    488488  int mpiSize, mpiRank; 
    489   MPI_Comm_size(communicator, &mpiSize); 
    490   MPI_Comm_rank(communicator, &mpiRank); 
     489  ep_lib::MPI_Comm_size(communicator, &mpiSize); 
     490  ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
    491491 
    492492  vector<Node> *routingList = new vector<Node>[mpiSize]; 
     
    522522  } 
    523523 
    524   MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator); 
    525   MPI_Alltoall(sendMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator); 
     524  ep_lib::MPI_Alltoall(nbSendNode, 1, EP_INT, nbRecvNode, 1, EP_INT, communicator); 
     525  ep_lib::MPI_Alltoall(sendMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator); 
    526526 
    527527  char **sendBuffer = new char*[mpiSize]; 
     
    549549  int nbSendRequest = 0; 
    550550  int nbRecvRequest = 0; 
    551   MPI_Request *sendRequest = new MPI_Request[mpiSize]; 
    552   MPI_Request *recvRequest = new MPI_Request[mpiSize]; 
    553   MPI_Status  *status      = new MPI_Status[mpiSize]; 
     551  ep_lib::MPI_Request *sendRequest = new ep_lib::MPI_Request[mpiSize]; 
     552  ep_lib::MPI_Request *recvRequest = new ep_lib::MPI_Request[mpiSize]; 
     553  ep_lib::MPI_Status  *status      = new ep_lib::MPI_Status[mpiSize]; 
    554554 
    555555  for (int rank = 0; rank < mpiSize; rank++) 
     
    557557    if (nbSendNode[rank] > 0) 
    558558    { 
    559       MPI_Issend(sendBuffer[rank], sendMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     559      ep_lib::MPI_Issend(sendBuffer[rank], sendMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    560560      nbSendRequest++; 
    561561    } 
    562562    if (nbRecvNode[rank] > 0) 
    563563    { 
    564       MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     564      ep_lib::MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    565565      nbRecvRequest++; 
    566566    } 
    567567  } 
    568568 
    569   MPI_Waitall(nbRecvRequest, recvRequest, status); 
    570   MPI_Waitall(nbSendRequest, sendRequest, status); 
     569  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
     570  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
    571571 
    572572  for (int rank = 0; rank < mpiSize; rank++) 
     
    615615 
    616616 
    617   MPI_Barrier(communicator); 
    618   MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator); 
    619   MPI_Alltoall(sendMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator); 
     617  ep_lib::MPI_Barrier(communicator); 
     618  ep_lib::MPI_Alltoall(nbSendNode, 1, EP_INT, nbRecvNode, 1, EP_INT, communicator); 
     619  ep_lib::MPI_Alltoall(sendMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator); 
    620620 
    621621  for (int rank = 0; rank < mpiSize; rank++) 
     
    629629    if (nbSendNode[rank] > 0) 
    630630    { 
    631       MPI_Issend(sendBuffer2[rank], sendMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     631      ep_lib::MPI_Issend(sendBuffer2[rank], sendMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    632632      nbSendRequest++; 
    633633    } 
    634634    if (nbRecvNode[rank] > 0) 
    635635    { 
    636       MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     636      ep_lib::MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    637637      nbRecvRequest++; 
    638638    } 
    639639  } 
    640640 
    641   MPI_Waitall(nbRecvRequest, recvRequest, status); 
    642   MPI_Waitall(nbSendRequest, sendRequest, status); 
     641  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
     642  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
    643643 
    644644  int nbNeighbourNodes = 0; 
     
    725725{ 
    726726  int mpiSize, mpiRank; 
    727   MPI_Comm_size(communicator, &mpiSize); 
    728   MPI_Comm_rank(communicator, &mpiRank); 
    729  
    730   MPI_Barrier(communicator); 
     727  ep_lib::MPI_Comm_size(communicator, &mpiSize); 
     728  ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
     729 
     730  ep_lib::MPI_Barrier(communicator); 
    731731 
    732732  vector<Node> *routingList = new vector<Node>[mpiSize]; 
     
    753753    cout << endl; 
    754754  } 
    755   MPI_Barrier(communicator); 
     755  ep_lib::MPI_Barrier(communicator); 
    756756 
    757757  int *nbSendNode = new int[mpiSize]; 
     
    771771  } 
    772772 
    773   MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator); 
    774   MPI_Alltoall(sentMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator); 
     773  ep_lib::MPI_Alltoall(nbSendNode, 1, EP_INT, nbRecvNode, 1, EP_INT, communicator); 
     774  ep_lib::MPI_Alltoall(sentMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator); 
    775775 
    776776  int total = 0; 
     
    805805  int nbSendRequest = 0; 
    806806  int nbRecvRequest = 0; 
    807   MPI_Request *sendRequest = new MPI_Request[mpiSize]; 
    808   MPI_Request *recvRequest = new MPI_Request[mpiSize]; 
    809   MPI_Status   *status = new MPI_Status[mpiSize]; 
     807  ep_lib::MPI_Request *sendRequest = new ep_lib::MPI_Request[mpiSize]; 
     808  ep_lib::MPI_Request *recvRequest = new ep_lib::MPI_Request[mpiSize]; 
     809  ep_lib::MPI_Status   *status = new ep_lib::MPI_Status[mpiSize]; 
    810810 
    811811  for (int rank = 0; rank < mpiSize; rank++) 
     
    813813    if (nbSendNode[rank] > 0) 
    814814    { 
    815       MPI_Issend(sendBuffer[rank], sentMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     815      ep_lib::MPI_Issend(sendBuffer[rank], sentMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    816816      nbSendRequest++; 
    817817    } 
    818818    if (nbRecvNode[rank] > 0) 
    819819    { 
    820       MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     820      ep_lib::MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    821821      nbRecvRequest++; 
    822822    } 
    823823  } 
    824824 
    825   MPI_Waitall(nbRecvRequest, recvRequest, status); 
    826   MPI_Waitall(nbSendRequest, sendRequest, status); 
     825  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
     826  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
    827827  char **sendBuffer2 = new char*[mpiSize]; 
    828828  char **recvBuffer2 = new char*[mpiSize]; 
     
    883883 
    884884  if (verbose >= 2) cout << "Rank " << mpiRank << "  Compute (internal) intersection " << cputime() - tic << " s" << endl; 
    885   MPI_Alltoall(sentMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator); 
     885  ep_lib::MPI_Alltoall(sentMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator); 
    886886 
    887887  for (int rank = 0; rank < mpiSize; rank++) 
     
    896896    if (sentMessageSize[rank] > 0) 
    897897    { 
    898       MPI_Issend(sendBuffer2[rank], sentMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     898      ep_lib::MPI_Issend(sendBuffer2[rank], sentMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    899899      nbSendRequest++; 
    900900    } 
    901901    if (recvMessageSize[rank] > 0) 
    902902    { 
    903       MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     903      ep_lib::MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    904904      nbRecvRequest++; 
    905905    } 
    906906  } 
    907907 
    908   MPI_Waitall(nbRecvRequest, recvRequest, status); 
    909   MPI_Waitall(nbSendRequest, sendRequest, status); 
     908  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
     909  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
    910910 
    911911  delete [] sendRequest; 
  • XIOS/trunk/extern/remap/src/mapper.hpp

    r1614 r1638  
    1818{ 
    1919public: 
    20        Mapper(MPI_Comm comm=MPI_COMM_WORLD) : communicator(comm), verbose(SILENT), neighbourElements(NULL), sstree(comm) {} 
     20       Mapper(ep_lib::MPI_Comm comm=EP_COMM_WORLD) : communicator(comm), verbose(SILENT), neighbourElements(NULL), sstree(comm) {} 
    2121       ~Mapper(); 
    2222       void setVerbosity(verbosity v) {verbose=v ;} 
     
    6767 
    6868       CParallelTree sstree; 
    69        MPI_Comm communicator ; 
     69       ep_lib::MPI_Comm communicator ; 
    7070       std::vector<Elt>  sourceElements ; 
    7171       std::vector<Node> sourceMesh ; 
  • XIOS/trunk/extern/remap/src/mpi_cascade.cpp

    r688 r1638  
    44namespace sphereRemap { 
    55 
    6 CMPICascade::CMPICascade(int nodes_per_level, MPI_Comm comm) 
     6CMPICascade::CMPICascade(int nodes_per_level, ep_lib::MPI_Comm comm) 
    77{ 
    88        int remaining_levels; 
    9         MPI_Comm intraComm; 
     9        ep_lib::MPI_Comm intraComm; 
    1010        int l = 0; // current level 
    1111        do { 
     
    1515                level[l].p_grp_size = level[l].size/level[l].group_size; 
    1616         
    17                 MPI_Comm_split(comm, level[l].colour(), level[l].key(), &intraComm); 
    18                 MPI_Comm_split(comm, level[l].p_colour(), level[l].p_key(), &(level[l].pg_comm)); 
     17                ep_lib::MPI_Comm_split(comm, level[l].colour(), level[l].key(), &intraComm); 
     18                ep_lib::MPI_Comm_split(comm, level[l].p_colour(), level[l].p_key(), &(level[l].pg_comm)); 
    1919                comm = intraComm; 
    2020                l++; 
  • XIOS/trunk/extern/remap/src/mpi_cascade.hpp

    r694 r1638  
    1212{ 
    1313public: 
    14         CCascadeLevel(MPI_Comm comm) : comm(comm) 
     14        CCascadeLevel(ep_lib::MPI_Comm comm) : comm(comm) 
    1515        { 
    16                 MPI_Comm_size(comm, &size); 
    17                 MPI_Comm_rank(comm, &rank); 
     16                ep_lib::MPI_Comm_size(comm, &size); 
     17                ep_lib::MPI_Comm_rank(comm, &rank); 
    1818        } 
    1919        int colour() const { return rank % group_size; }; 
     
    2424        int p_key() const { return colour() + rank/(p_grp_size*group_size)*group_size; } 
    2525 
    26         MPI_Comm comm, pg_comm; 
     26        ep_lib::MPI_Comm comm, pg_comm; 
    2727        int rank; 
    2828        int size; 
     
    3535public: 
    3636        //  
    37         CMPICascade(int nodes_per_level, MPI_Comm comm); 
     37        CMPICascade(int nodes_per_level, ep_lib::MPI_Comm comm); 
    3838 
    3939        int num_levels; 
  • XIOS/trunk/extern/remap/src/mpi_routing.cpp

    r694 r1638  
    1010const int verbose = 0; 
    1111 
    12 CMPIRouting::CMPIRouting(MPI_Comm comm) : communicator(comm) 
    13 { 
    14         MPI_Comm_rank(comm, &mpiRank); 
    15         MPI_Comm_size(comm, &mpiSize); 
     12CMPIRouting::CMPIRouting(ep_lib::MPI_Comm comm) : communicator(comm) 
     13{ 
     14        ep_lib::MPI_Comm_rank(comm, &mpiRank); 
     15        ep_lib::MPI_Comm_size(comm, &mpiSize); 
    1616} 
    1717 
     
    1919    but message lengths are *known* to receiver */ 
    2020template <typename T> 
    21 void alltoalls_known(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, MPI_Comm communicator) 
    22 { 
    23         vector<MPI_Request> request(ranks.size() * 2); 
    24         vector<MPI_Status>  status(ranks.size() * 2); 
     21void alltoalls_known(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, ep_lib::MPI_Comm communicator) 
     22{ 
     23        vector<ep_lib::MPI_Request> request(ranks.size() * 2); 
     24        vector<ep_lib::MPI_Status>  status(ranks.size() * 2); 
    2525 
    2626        // communicate data 
     
    2828        for (int i = 0; i < ranks.size(); i++) 
    2929                if (recv[i].size()) 
    30                         MPI_Irecv(&recv[i][0], recv[i].size()*sizeof(T), MPI_CHAR, ranks[i], 0, communicator, &request[nbRequest++]); 
     30                        ep_lib::MPI_Irecv(&recv[i][0], recv[i].size()*sizeof(T), EP_CHAR, ranks[i], 0, communicator, &request[nbRequest++]); 
    3131        for (int i = 0; i < ranks.size(); i++) 
    3232                if (send[i].size()) 
    33                         MPI_Isend((void *) &send[i][0], send[i].size()*sizeof(T), MPI_CHAR, ranks[i], 0, communicator, &request[nbRequest++]); 
    34         MPI_Waitall(nbRequest, &request[0], &status[0]); 
     33                        ep_lib::MPI_Isend((void *) &send[i][0], send[i].size()*sizeof(T), EP_CHAR, ranks[i], 0, communicator, &request[nbRequest++]); 
     34        ep_lib::MPI_Waitall(nbRequest, &request[0], &status[0]); 
    3535} 
    3636 
     
    3838    but message lengths are *unknown* to receiver */ 
    3939template <typename T> 
    40 void alltoalls_unknown(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, MPI_Comm communicator) 
    41 { 
    42         vector<MPI_Request> request(ranks.size() * 2); 
    43         vector<MPI_Status>  status(ranks.size() * 2); 
     40void alltoalls_unknown(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, ep_lib::MPI_Comm communicator) 
     41{ 
     42        vector<ep_lib::MPI_Request> request(ranks.size() * 2); 
     43        vector<ep_lib::MPI_Status>  status(ranks.size() * 2); 
    4444 
    4545        // communicate sizes 
     
    5050                sendSizes[i] = send[i].size(); 
    5151        for (int i = 0; i < ranks.size(); i++) 
    52                 MPI_Irecv(&recvSizes[i], 1, MPI_INT, ranks[i], 0, communicator, &request[nbRequest++]); 
     52                ep_lib::MPI_Irecv(&recvSizes[i], 1, EP_INT, ranks[i], 0, communicator, &request[nbRequest++]); 
    5353        for (int i = 0; i < ranks.size(); i++) 
    54                 MPI_Isend(&sendSizes[i], 1, MPI_INT, ranks[i], 0, communicator, &request[nbRequest++]); 
    55         MPI_Waitall(nbRequest, &request[0], &status[0]); 
     54                ep_lib::MPI_Isend(&sendSizes[i], 1, EP_INT, ranks[i], 0, communicator, &request[nbRequest++]); 
     55        ep_lib::MPI_Waitall(nbRequest, &request[0], &status[0]); 
    5656 
    5757        // allocate 
     
    118118        CTimer::get("CMPIRouting::init(reduce_scatter)").reset(); 
    119119        CTimer::get("CMPIRouting::init(reduce_scatter)").resume(); 
    120         MPI_Reduce_scatter(toSend, &nbSource, recvCount, MPI_INT, MPI_SUM, communicator); 
     120        ep_lib::MPI_Reduce_scatter(toSend, &nbSource, recvCount, EP_INT, EP_SUM, communicator); 
    121121        CTimer::get("CMPIRouting::init(reduce_scatter)").suspend(); 
    122122        CTimer::get("CMPIRouting::init(reduce_scatter)").print(); 
    123123 
    124         MPI_Alloc_mem(nbTarget *sizeof(int), MPI_INFO_NULL, &targetRank); 
    125         MPI_Alloc_mem(nbSource *sizeof(int), MPI_INFO_NULL, &sourceRank); 
     124        ep_lib::MPI_Alloc_mem(nbTarget *sizeof(int), EP_INFO_NULL, &targetRank); 
     125        ep_lib::MPI_Alloc_mem(nbSource *sizeof(int), EP_INFO_NULL, &sourceRank); 
    126126 
    127127        targetRankToIndex = new int[mpiSize]; 
     
    137137        } 
    138138 
    139         MPI_Barrier(communicator); 
     139        ep_lib::MPI_Barrier(communicator); 
    140140        CTimer::get("CMPIRouting::init(get_source)").reset(); 
    141141        CTimer::get("CMPIRouting::init(get_source)").resume(); 
    142142 
    143         MPI_Request *request = new MPI_Request[nbSource + nbTarget]; 
    144         MPI_Status  *status = new MPI_Status[nbSource + nbTarget]; 
     143        ep_lib::MPI_Request *request = new ep_lib::MPI_Request[nbSource + nbTarget]; 
     144        ep_lib::MPI_Status  *status = new ep_lib::MPI_Status[nbSource + nbTarget]; 
    145145 
    146146        int indexRequest = 0; 
     
    150150        for (int i = 0; i < nbSource; i++) 
    151151        { 
    152                 MPI_Irecv(&sourceRank[i], 1, MPI_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]); 
    153                 indexRequest++; 
     152                #ifdef _usingMPI 
     153                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]); 
     154                #elif _usingEP 
     155                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, -2, 0, communicator, &request[indexRequest]); 
     156                #endif 
     157                indexRequest++; 
    154158        } 
    155159        MPI_Barrier(communicator); 
    156160        for (int i = 0; i < nbTarget; i++) 
    157161        { 
    158                 MPI_Isend(&mpiRank, 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
     162                ep_lib::MPI_Isend(&mpiRank, 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
    159163                indexRequest++; 
    160164        } 
     
    170174        for (int i = 0; i < nbSource; i++) 
    171175        { 
    172                 MPI_Irecv(&sourceRank[i], 1, MPI_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]); 
    173                 indexRequest++; 
    174         } 
    175  
    176         for (int i = 0; i < nbTarget; i++) 
    177         { 
    178                 MPI_Isend(&mpiRank, 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
     176                #ifdef _usingMPI 
     177                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]); 
     178                #elif _usingEP 
     179                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, -2, 0, communicator, &request[indexRequest]); 
     180                #endif 
     181                indexRequest++; 
     182        } 
     183 
     184        for (int i = 0; i < nbTarget; i++) 
     185        { 
     186                ep_lib::MPI_Isend(&mpiRank, 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
    179187                indexRequest++; 
    180188        } 
     
    201209        for (int i = 0; i < nbSource; i++) 
    202210        { 
    203                 MPI_Irecv(&nbSourceElement[i], 1, MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
     211                ep_lib::MPI_Irecv(&nbSourceElement[i], 1, EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
    204212                indexRequest++; 
    205213        } 
     
    208216        { 
    209217                totalTargetElement += nbTargetElement[i]; 
    210                 MPI_Isend(&nbTargetElement[i], 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
     218                ep_lib::MPI_Isend(&nbTargetElement[i], 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
    211219                indexRequest++; 
    212220        } 
     
    276284 
    277285 
    278         MPI_Request* request=new MPI_Request[nbSource+nbTarget]; 
    279         MPI_Status*  status=new MPI_Status[nbSource+nbTarget]; 
     286        ep_lib::MPI_Request* request=new ep_lib::MPI_Request[nbSource+nbTarget]; 
     287        ep_lib::MPI_Status*  status=new ep_lib::MPI_Status[nbSource+nbTarget]; 
    280288        int indexRequest=0; 
    281289 
    282         MPI_Barrier(communicator); 
     290        ep_lib::MPI_Barrier(communicator); 
    283291        CTimer::get("CMPIRouting::transferToTarget").reset(); 
    284292        CTimer::get("CMPIRouting::transferToTarget").resume(); 
     
    286294        for(int i=0; i<nbSource; i++) 
    287295        { 
    288                 MPI_Irecv(sourceBuffer[i],nbSourceElement[i]*sizeof(T),MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
     296                ep_lib::MPI_Irecv(sourceBuffer[i],nbSourceElement[i]*sizeof(T),EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
    289297                indexRequest++; 
    290298        } 
     
    292300        for(int i=0;i<nbTarget; i++) 
    293301        { 
    294                 MPI_Isend(targetBuffer[i],nbTargetElement[i]*sizeof(T), MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
    295                 indexRequest++; 
    296         } 
    297  
    298         MPI_Waitall(indexRequest,request,status); 
     302                ep_lib::MPI_Isend(targetBuffer[i],nbTargetElement[i]*sizeof(T), EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
     303                indexRequest++; 
     304        } 
     305 
     306        ep_lib::MPI_Waitall(indexRequest,request,status); 
    299307 
    300308        CTimer::get("CMPIRouting::transferToTarget").suspend(); 
    301309        CTimer::get("CMPIRouting::transferToTarget").print(); 
    302         MPI_Barrier(communicator); 
     310        ep_lib::MPI_Barrier(communicator); 
    303311 
    304312        // unpack the data 
     
    340348        } 
    341349 
    342         MPI_Request *request = new MPI_Request[nbSource + nbTarget]; 
    343         MPI_Status  *status = new MPI_Status[nbSource + nbTarget]; 
     350        ep_lib::MPI_Request *request = new ep_lib::MPI_Request[nbSource + nbTarget]; 
     351        ep_lib::MPI_Status  *status = new ep_lib::MPI_Status[nbSource + nbTarget]; 
    344352        int indexRequest = 0; 
    345353 
    346         MPI_Barrier(communicator); 
     354        ep_lib::MPI_Barrier(communicator); 
    347355        CTimer::get("CMPIRouting::transferToTarget(messageSize)").reset(); 
    348356        CTimer::get("CMPIRouting::transferToTarget(messageSize)").resume(); 
     
    350358        for(int i=0; i<nbSource; i++) 
    351359        { 
    352                 MPI_Irecv(&sourceMessageSize[i],1,MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
     360                ep_lib::MPI_Irecv(&sourceMessageSize[i],1,EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
    353361                indexRequest++; 
    354362        } 
     
    356364        for(int i=0; i<nbTarget; i++) 
    357365        { 
    358                 MPI_Isend(&targetMessageSize[i],1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
    359                 indexRequest++; 
    360         } 
    361  
    362         MPI_Waitall(indexRequest,request,status); 
    363  
    364         MPI_Barrier(communicator); 
     366                ep_lib::MPI_Isend(&targetMessageSize[i],1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
     367                indexRequest++; 
     368        } 
     369 
     370        ep_lib::MPI_Waitall(indexRequest,request,status); 
     371 
     372        ep_lib::MPI_Barrier(communicator); 
    365373        CTimer::get("CMPIRouting::transferToTarget(messageSize)").suspend(); 
    366374        CTimer::get("CMPIRouting::transferToTarget(messageSize)").print(); 
     
    395403        for(int i=0; i<nbSource; i++) 
    396404        { 
    397                 MPI_Irecv(sourceBuffer[i],sourceMessageSize[i],MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
     405                ep_lib::MPI_Irecv(sourceBuffer[i],sourceMessageSize[i],EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
    398406                indexRequest++; 
    399407        } 
     
    401409        for(int i=0;i<nbTarget; i++) 
    402410        { 
    403                 MPI_Isend(targetBuffer[i],targetMessageSize[i], MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
     411                ep_lib::MPI_Isend(targetBuffer[i],targetMessageSize[i], EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
    404412                indexRequest++; 
    405413        } 
     
    460468        } 
    461469 
    462         MPI_Request* request=new MPI_Request[nbSource+nbTarget]; 
    463         MPI_Status*  status=new MPI_Status[nbSource+nbTarget]; 
     470        ep_lib::MPI_Request* request=new ep_lib::MPI_Request[nbSource+nbTarget]; 
     471        ep_lib::MPI_Status*  status=new ep_lib::MPI_Status[nbSource+nbTarget]; 
    464472        int indexRequest=0; 
    465473 
    466474        for(int i=0; i<nbSource; i++) 
    467475        { 
    468                 MPI_Isend(sourceBuffer[i],nbSourceElement[i]*sizeof(T),MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
     476                ep_lib::MPI_Isend(sourceBuffer[i],nbSourceElement[i]*sizeof(T),EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
    469477                indexRequest++; 
    470478        } 
     
    472480        for(int i=0;i<nbTarget; i++) 
    473481        { 
    474                 MPI_Irecv(targetBuffer[i],nbTargetElement[i]*sizeof(T), MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
    475                 indexRequest++; 
    476         } 
    477  
    478         MPI_Waitall(indexRequest,request,status); 
     482                ep_lib::MPI_Irecv(targetBuffer[i],nbTargetElement[i]*sizeof(T), EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
     483                indexRequest++; 
     484        } 
     485 
     486        ep_lib::MPI_Waitall(indexRequest,request,status); 
    479487 
    480488        // unpack the data 
     
    516524        } 
    517525 
    518         MPI_Request *request = new MPI_Request[nbSource + nbTarget]; 
    519         MPI_Status  *status = new MPI_Status[nbSource + nbTarget]; 
     526        ep_lib::MPI_Request *request = new ep_lib::MPI_Request[nbSource + nbTarget]; 
     527        ep_lib::MPI_Status  *status = new ep_lib::MPI_Status[nbSource + nbTarget]; 
    520528        int indexRequest = 0; 
    521529        for (int i = 0; i < nbSource; i++) 
    522530        { 
    523                 MPI_Isend(&sourceMessageSize[i], 1, MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
    524                 indexRequest++; 
    525         } 
    526         for (int i = 0; i < nbTarget; i++) 
    527         { 
    528                 MPI_Irecv(&targetMessageSize[i], 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
    529                 indexRequest++; 
    530         } 
    531         MPI_Waitall(indexRequest, request, status); 
     531                ep_lib::MPI_Isend(&sourceMessageSize[i], 1, EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
     532                indexRequest++; 
     533        } 
     534        for (int i = 0; i < nbTarget; i++) 
     535        { 
     536                ep_lib::MPI_Irecv(&targetMessageSize[i], 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
     537                indexRequest++; 
     538        } 
     539        ep_lib::MPI_Waitall(indexRequest, request, status); 
    532540 
    533541        for (int i = 0; i < nbTarget; i++) 
     
    557565        for (int i = 0; i < nbSource; i++) 
    558566        { 
    559                 MPI_Isend(sourceBuffer[i], sourceMessageSize[i], MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
    560                 indexRequest++; 
    561         } 
    562         for (int i = 0; i < nbTarget; i++) 
    563         { 
    564                 MPI_Irecv(targetBuffer[i], targetMessageSize[i], MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
    565                 indexRequest++; 
    566         } 
    567         MPI_Waitall(indexRequest, request, status); 
     567                ep_lib::MPI_Isend(sourceBuffer[i], sourceMessageSize[i], EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
     568                indexRequest++; 
     569        } 
     570        for (int i = 0; i < nbTarget; i++) 
     571        { 
     572                ep_lib::MPI_Irecv(targetBuffer[i], targetMessageSize[i], EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
     573                indexRequest++; 
     574        } 
     575        ep_lib::MPI_Waitall(indexRequest, request, status); 
    568576 
    569577        // unpack the data 
     
    605613 
    606614template void alltoalls_unknown(const std::vector<std::vector<NES> >& send, std::vector<std::vector<NES> >& recv, 
    607                                 const std::vector<int>& ranks, MPI_Comm communicator); 
     615                                const std::vector<int>& ranks, ep_lib::MPI_Comm communicator); 
    608616 
    609617template void alltoalls_known(const std::vector<std::vector<int> >& send, std::vector<std::vector<int> >& recv, 
    610                               const std::vector<int>& ranks, MPI_Comm communicator); 
    611  
    612 } 
     618                              const std::vector<int>& ranks, ep_lib::MPI_Comm communicator); 
     619 
     620} 
  • XIOS/trunk/extern/remap/src/mpi_routing.hpp

    r694 r1638  
    1111{ 
    1212 
    13         MPI_Comm communicator; 
     13        ep_lib::MPI_Comm communicator; 
    1414        int mpiRank; 
    1515        int mpiSize; 
     
    2929 
    3030public: 
    31         CMPIRouting(MPI_Comm comm); 
     31        CMPIRouting(ep_lib::MPI_Comm comm); 
    3232        ~CMPIRouting(); 
    3333        template<typename T> void init(const std::vector<T>& route, CMPICascade *cascade = NULL); 
     
    4444template <typename T> 
    4545void alltoalls_known(const std::vector<std::vector<T> >& send, std::vector<std::vector<T> >& recv, 
    46                      const std::vector<int>& ranks, MPI_Comm communicator); 
     46                     const std::vector<int>& ranks, ep_lib::MPI_Comm communicator); 
    4747 
    4848template <typename T> 
    4949void alltoalls_unknown(const std::vector<std::vector<T> >& send, std::vector<std::vector<T> >& recv, 
    50                        const std::vector<int>& ranks, MPI_Comm communicator); 
     50                       const std::vector<int>& ranks, ep_lib::MPI_Comm communicator); 
    5151} 
    5252#endif 
  • XIOS/trunk/extern/remap/src/parallel_tree.cpp

    r923 r1638  
    115115 
    116116//CParallelTree::CParallelTree(MPI_Comm comm) : communicator(comm), cascade(MIN_NODE_SZ*MIN_NODE_SZ, comm) 
    117 CParallelTree::CParallelTree(MPI_Comm comm) : communicator(comm), cascade(MAX_NODE_SZ*MAX_NODE_SZ*2, comm) 
     117CParallelTree::CParallelTree(ep_lib::MPI_Comm comm) : communicator(comm), cascade(MAX_NODE_SZ*MAX_NODE_SZ*2, comm) 
    118118{ 
    119119        treeCascade.reserve(cascade.num_levels); 
     
    151151 
    152152        int nrecv; // global number of samples  THIS WILL BE THE NUMBER OF LEAFS IN THE SAMPLE TREE 
    153         MPI_Allreduce(&n, &nrecv, 1, MPI_INT, MPI_SUM, comm.comm); // => size of sample tree does not depend on keepNodes! 
     153        ep_lib::MPI_Allreduce(&n, &nrecv, 1, EP_INT, EP_SUM, comm.comm); // => size of sample tree does not depend on keepNodes! 
    154154        double ratio = blocSize / (1.0 * nrecv); 
    155155        int nsend = ratio * n + 1; // nsend = n_local_samples / n_global_samples * blocksize + 1 = blocksize/comm.size 
     
    157157 
    158158        int *counts = new int[comm.size]; 
    159         MPI_Allgather(&nsend, 1, MPI_INT, counts, 1, MPI_INT, comm.comm); 
     159        ep_lib::MPI_Allgather(&nsend, 1, EP_INT, counts, 1, EP_INT, comm.comm); 
    160160 
    161161        nrecv = 0; 
     
    183183        /* each process needs the sample elements from all processes */ 
    184184        double *recvBuffer = new double[nrecv*4]; 
    185         MPI_Allgatherv(sendBuffer, 4 * nsend, MPI_DOUBLE, recvBuffer, counts, displs, MPI_DOUBLE, comm.comm); 
     185        ep_lib::MPI_Allgatherv(sendBuffer, 4 * nsend, EP_DOUBLE, recvBuffer, counts, displs, EP_DOUBLE, comm.comm); 
    186186        delete[] sendBuffer; 
    187187        delete[] counts; 
     
    241241         << "   node size : "<<node.size()<<"   bloc size : "<<blocSize<<"  total number of leaf : "<<tree.leafs.size()<<endl ; 
    242242/* 
    243         MPI_Allreduce(&ok, &allok, 1, MPI_INT, MPI_PROD, communicator); 
     243        MPI_Allreduce(&ok, &allok, 1, EP_INT, MPI_PROD, communicator); 
    244244        if (!allok) { 
    245245                MPI_Finalize(); 
     
    247247        } 
    248248*/ 
    249     MPI_Abort(MPI_COMM_WORLD,-1) ; 
     249    ep_lib::MPI_Abort(EP_COMM_WORLD,-1) ; 
    250250  } 
    251251/* 
     
    265265{ 
    266266        CMPIRouting MPIRoute(communicator); 
    267         MPI_Barrier(communicator); 
     267        ep_lib::MPI_Barrier(communicator); 
    268268        CTimer::get("buildLocalTree(initRoute)").resume(); 
    269269        MPIRoute.init(route); 
     
    290290 
    291291        int mpiRank; 
    292         MPI_Comm_rank(communicator, &mpiRank); 
     292        ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
    293293        localTree.leafs.reserve(nbLocalElements); 
    294294        for (int i = 0; i < nbLocalElements; i++) 
     
    316316  nb1=node.size() ; nb2=node2.size() ; 
    317317  nb=nb1+nb2 ; 
    318   MPI_Allreduce(&nb, &nbTot, 1, MPI_LONG, MPI_SUM, communicator) ; 
     318  ep_lib::MPI_Allreduce(&nb, &nbTot, 1, EP_LONG, EP_SUM, communicator) ; 
    319319  int commSize ; 
    320   MPI_Comm_size(communicator,&commSize) ; 
     320  ep_lib::MPI_Comm_size(communicator,&commSize) ; 
    321321   
    322322        // make multiple of two 
     
    501501        // gather circles on this level of the cascade 
    502502        int pg_size; 
    503         MPI_Comm_size(cascade.level[level].pg_comm, &pg_size); 
     503        ep_lib::MPI_Comm_size(cascade.level[level].pg_comm, &pg_size); 
    504504        vector<Coord> allRootCentres(pg_size); 
    505505        vector<double> allRootRadia(pg_size); 
    506         MPI_Allgather(&rootCentre, 3, MPI_DOUBLE, &allRootCentres[0], 3, MPI_DOUBLE, cascade.level[level].pg_comm); 
    507         MPI_Allgather(&rootRadius, 1, MPI_DOUBLE, &allRootRadia[0],   1, MPI_DOUBLE, cascade.level[level].pg_comm); 
     506        ep_lib::MPI_Allgather(&rootCentre, 3, EP_DOUBLE, &allRootCentres[0], 3, EP_DOUBLE, cascade.level[level].pg_comm); 
     507        ep_lib::MPI_Allgather(&rootRadius, 1, EP_DOUBLE, &allRootRadia[0],   1, EP_DOUBLE, cascade.level[level].pg_comm); 
    508508 
    509509        // now allRootsRadia and allRootCentres must be inserted into second levels of us and propagated to root 
  • XIOS/trunk/extern/remap/src/parallel_tree.hpp

    r694 r1638  
    1212{ 
    1313public: 
    14         CParallelTree(MPI_Comm comm); 
     14        CParallelTree(ep_lib::MPI_Comm comm); 
    1515        ~CParallelTree(); 
    1616 
     
    3434        vector<CSampleTree> treeCascade; // first for sample tree, then for routing tree 
    3535        CMPICascade cascade; 
    36   MPI_Comm communicator ; 
     36  ep_lib::MPI_Comm communicator ; 
    3737 
    3838}; 
  • XIOS/trunk/src/buffer_client.cpp

    r1227 r1638  
    1212  size_t CClientBuffer::maxRequestSize = 0; 
    1313 
    14   CClientBuffer::CClientBuffer(MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents) 
     14  CClientBuffer::CClientBuffer(ep_lib::MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents) 
    1515    : interComm(interComm) 
    1616    , serverRank(serverRank) 
     
    8383  bool CClientBuffer::checkBuffer(void) 
    8484  { 
    85     MPI_Status status; 
     85    ep_lib::MPI_Status status; 
    8686    int flag; 
    8787 
     
    8989    { 
    9090      traceOff(); 
    91       MPI_Test(&request, &flag, &status); 
     91      ep_lib::MPI_Test(&request, &flag, &status); 
    9292      traceOn(); 
    9393      if (flag == true) pending = false; 
     
    9898      if (count > 0) 
    9999      { 
    100         MPI_Issend(buffer[current], count, MPI_CHAR, serverRank, 20, interComm, &request); 
     100        ep_lib::MPI_Issend(buffer[current], count, EP_CHAR, serverRank, 20, interComm, &request); 
    101101        pending = true; 
    102102        if (current == 1) current = 0; 
  • XIOS/trunk/src/buffer_client.hpp

    r1227 r1638  
    1414      static size_t maxRequestSize; 
    1515 
    16       CClientBuffer(MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents); 
     16      CClientBuffer(ep_lib::MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents); 
    1717      ~CClientBuffer(); 
    1818 
     
    3939      bool pending; 
    4040 
    41       MPI_Request request; 
     41      ep_lib::MPI_Request request; 
    4242 
    4343      CBufferOut* retBuffer; 
    44       const MPI_Comm interComm; 
     44      const ep_lib::MPI_Comm interComm; 
    4545  }; 
    4646} 
  • XIOS/trunk/src/client.cpp

    r1587 r1638  
    99#include "oasis_cinterface.hpp" 
    1010#include "mpi.hpp" 
     11//#include "mpi_wrapper.hpp" 
    1112#include "timer.hpp" 
    1213#include "buffer_client.hpp" 
     
    1617{ 
    1718 
    18     MPI_Comm CClient::intraComm ; 
    19     MPI_Comm CClient::interComm ; 
    20     std::list<MPI_Comm> CClient::contextInterComms; 
     19    ep_lib::MPI_Comm CClient::intraComm ; 
     20    ep_lib::MPI_Comm CClient::interComm ; 
     21    std::list<ep_lib::MPI_Comm> CClient::contextInterComms; 
    2122    int CClient::serverLeader ; 
    2223    bool CClient::is_MPI_Initialized ; 
     
    2425    StdOFStream CClient::m_infoStream; 
    2526    StdOFStream CClient::m_errorStream; 
    26     MPI_Comm& CClient::getInterComm(void)   { return (interComm); } 
     27    ep_lib::MPI_Comm& CClient::getInterComm(void)   { return (interComm); } 
    2728      
    2829///--------------------------------------------------------------- 
     
    3536 */ 
    3637 
    37     void CClient::initialize(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm) 
     38    void CClient::initialize(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm) 
    3839    { 
    3940      int initialized ; 
    40       MPI_Initialized(&initialized) ; 
     41      ep_lib::MPI_Initialized(&initialized) ; 
    4142      if (initialized) is_MPI_Initialized=true ; 
    4243      else is_MPI_Initialized=false ; 
     
    4748      { 
    4849// localComm isn't given 
    49         if (localComm == MPI_COMM_NULL) 
     50        if (localComm == EP_COMM_NULL) 
    5051        { 
    5152          if (!is_MPI_Initialized) 
    5253          { 
    53             MPI_Init(NULL, NULL); 
     54            ep_lib::MPI_Init(NULL, NULL); 
    5455          } 
    5556          CTimer::get("XIOS").resume() ; 
     
    6364          int myColor ; 
    6465          int i,c ; 
    65           MPI_Comm newComm ; 
    66  
    67           MPI_Comm_size(CXios::globalComm,&size) ; 
    68           MPI_Comm_rank(CXios::globalComm,&rank_); 
     66          ep_lib::MPI_Comm newComm ; 
     67 
     68          ep_lib::MPI_Comm_size(CXios::globalComm,&size) ; 
     69 
     70          ep_lib::MPI_Comm_rank(CXios::globalComm,&rank_); 
    6971 
    7072          hashAll=new unsigned long[size] ; 
    7173 
    72           MPI_Allgather(&hashClient,1,MPI_LONG,hashAll,1,MPI_LONG,CXios::globalComm) ; 
     74          ep_lib::MPI_Allgather(&hashClient,1,EP_LONG,hashAll,1,EP_LONG,CXios::globalComm) ; 
    7375 
    7476          map<unsigned long, int> colors ; 
     
    9799 
    98100          myColor=colors[hashClient]; 
    99           MPI_Comm_split(CXios::globalComm,myColor,rank_,&intraComm) ; 
     101          ep_lib::MPI_Comm_split(CXios::globalComm,myColor,rank_,&intraComm) ; 
    100102 
    101103          if (CXios::usingServer) 
     
    104106            serverLeader=leaders[hashServer] ; 
    105107            int intraCommSize, intraCommRank ; 
    106             MPI_Comm_size(intraComm,&intraCommSize) ; 
    107             MPI_Comm_rank(intraComm,&intraCommRank) ; 
     108            ep_lib::MPI_Comm_size(intraComm,&intraCommSize) ; 
     109            ep_lib::MPI_Comm_rank(intraComm,&intraCommRank) ; 
    108110            info(50)<<"intercommCreate::client "<<rank_<<" intraCommSize : "<<intraCommSize 
    109111                   <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< serverLeader<<endl ; 
    110              MPI_Intercomm_create(intraComm, 0, CXios::globalComm, serverLeader, 0, &interComm) ; 
     112             ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, serverLeader, 0, &interComm) ; 
    111113             //rank_ = intraCommRank; 
    112114          } 
    113115          else 
    114116          { 
    115             MPI_Comm_dup(intraComm,&interComm) ; 
     117            ep_lib::MPI_Comm_dup(intraComm,&interComm) ; 
    116118          } 
    117119          delete [] hashAll ; 
     
    126128          else 
    127129          { 
    128             MPI_Comm_dup(localComm,&intraComm) ; 
    129             MPI_Comm_dup(intraComm,&interComm) ; 
     130            ep_lib::MPI_Comm_dup(localComm,&intraComm) ; 
     131            ep_lib::MPI_Comm_dup(intraComm,&interComm) ; 
    130132          } 
    131133        } 
     
    135137      { 
    136138        // localComm isn't given 
    137         if (localComm == MPI_COMM_NULL) 
     139        if (localComm == EP_COMM_NULL) 
    138140        { 
    139141          if (!is_MPI_Initialized) oasis_init(codeId) ; 
    140142          oasis_get_localcomm(localComm) ; 
    141143        } 
    142         MPI_Comm_dup(localComm,&intraComm) ; 
     144        ep_lib::MPI_Comm_dup(localComm,&intraComm) ; 
    143145 
    144146        CTimer::get("XIOS").resume() ; 
     
    147149        if (CXios::usingServer) 
    148150        { 
    149           MPI_Status status ; 
    150           MPI_Comm_rank(intraComm,&rank_) ; 
     151          ep_lib::MPI_Status status ; 
     152          ep_lib::MPI_Comm_rank(intraComm,&rank_) ; 
    151153 
    152154          oasis_get_intercomm(interComm,CXios::xiosCodeId) ; 
    153           if (rank_==0) MPI_Recv(&serverLeader,1, MPI_INT, 0, 0, interComm, &status) ; 
    154           MPI_Bcast(&serverLeader,1,MPI_INT,0,intraComm) ; 
    155         } 
    156         else MPI_Comm_dup(intraComm,&interComm) ; 
    157       } 
    158  
    159       MPI_Comm_dup(intraComm,&returnComm) ; 
     155          if (rank_==0) ep_lib::MPI_Recv(&serverLeader,1, EP_INT, 0, 0, interComm, &status) ; 
     156          ep_lib::MPI_Bcast(&serverLeader,1,EP_INT,0,intraComm) ; 
     157        } 
     158        else ep_lib::MPI_Comm_dup(intraComm,&interComm) ; 
     159      } 
     160 
     161      ep_lib::MPI_Comm_dup(intraComm,&returnComm) ; 
    160162    } 
    161163 
     
    168170 * Function is only called by client. 
    169171 */ 
    170     void CClient::registerContext(const string& id, MPI_Comm contextComm) 
     172    void CClient::registerContext(const string& id, ep_lib::MPI_Comm contextComm) 
    171173    { 
    172174      CContext::setCurrent(id) ; 
     
    178180      // Attached mode 
    179181      { 
    180         MPI_Comm contextInterComm ; 
    181         MPI_Comm_dup(contextComm,&contextInterComm) ; 
     182        ep_lib::MPI_Comm contextInterComm ; 
     183        ep_lib::MPI_Comm_dup(contextComm,&contextInterComm) ; 
    182184        CContext* contextServer = CContext::create(idServer); 
    183185 
     
    198200        size_t message_size ; 
    199201        int leaderRank ; 
    200         MPI_Comm contextInterComm ; 
    201  
    202         MPI_Comm_size(contextComm,&size) ; 
    203         MPI_Comm_rank(contextComm,&rank) ; 
    204         MPI_Comm_rank(CXios::globalComm,&globalRank) ; 
     202        ep_lib::MPI_Comm contextInterComm ; 
     203 
     204        ep_lib::MPI_Comm_size(contextComm,&size) ; 
     205        ep_lib::MPI_Comm_rank(contextComm,&rank) ; 
     206        ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank) ; 
    205207        if (rank!=0) globalRank=0 ; 
    206208 
     
    214216        buffer<<msg ; 
    215217 
    216         MPI_Send((void*)buff,buffer.count(),MPI_CHAR,serverLeader,1,CXios::globalComm) ; 
    217  
    218         MPI_Intercomm_create(contextComm,0,CXios::globalComm,serverLeader,10+globalRank,&contextInterComm) ; 
     218        ep_lib::MPI_Send((void*)buff,buffer.count(),EP_CHAR,serverLeader,1,CXios::globalComm) ; 
     219 
     220        ep_lib::MPI_Intercomm_create(contextComm,0,CXios::globalComm,serverLeader,10+globalRank,&contextInterComm) ; 
    219221        info(10)<<"Register new Context : "<<id<<endl ; 
    220         MPI_Comm inter ; 
    221         MPI_Intercomm_merge(contextInterComm,0,&inter) ; 
    222         MPI_Barrier(inter) ; 
     222        ep_lib::MPI_Comm inter ; 
     223        ep_lib::MPI_Intercomm_merge(contextInterComm,0,&inter) ; 
     224        ep_lib::MPI_Barrier(inter) ; 
    223225 
    224226        context->initClient(contextComm,contextInterComm) ; 
    225227 
    226228        contextInterComms.push_back(contextInterComm); 
    227         MPI_Comm_free(&inter); 
     229        ep_lib::MPI_Comm_free(&inter); 
    228230        delete [] buff ; 
    229231 
     
    251253        int msg=0 ; 
    252254 
    253         MPI_Comm_rank(intraComm,&rank) ; 
     255        ep_lib::MPI_Comm_rank(intraComm,&rank) ; 
    254256        if (rank==0)  
    255257        { 
    256           MPI_Send(&msg,1,MPI_INT,0,5,interComm) ; // tags oasis_endded = 5 
     258          ep_lib::MPI_Send(&msg,1,EP_INT,0,5,interComm) ; // tags oasis_endded = 5 
    257259        } 
    258260 
     
    266268      int msg=0 ; 
    267269 
    268       MPI_Comm_rank(intraComm,&rank) ; 
     270      ep_lib::MPI_Comm_rank(intraComm,&rank) ; 
    269271  
    270272      if (!CXios::isServer) 
    271273      { 
    272         MPI_Comm_rank(intraComm,&rank) ; 
     274        ep_lib::MPI_Comm_rank(intraComm,&rank) ; 
    273275        if (rank==0) 
    274276        { 
    275           MPI_Send(&msg,1,MPI_INT,0,0,interComm) ; 
    276         } 
    277       } 
    278  
    279       for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++) 
    280         MPI_Comm_free(&(*it)); 
    281       MPI_Comm_free(&interComm); 
    282       MPI_Comm_free(&intraComm); 
     277          ep_lib::MPI_Send(&msg,1,EP_INT,0,0,interComm) ; 
     278        } 
     279      } 
     280 
     281      for (std::list<ep_lib::MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++) 
     282        ep_lib::MPI_Comm_free(&(*it)); 
     283      ep_lib::MPI_Comm_free(&interComm); 
     284      ep_lib::MPI_Comm_free(&intraComm); 
    283285 
    284286      CTimer::get("XIOS init/finalize").suspend() ; 
     
    288290      { 
    289291        if (CXios::usingOasis) oasis_finalize(); 
    290         else MPI_Finalize() ; 
     292        else ep_lib::MPI_Finalize() ; 
    291293      } 
    292294       
     
    325327      int size = 0; 
    326328      int rank; 
    327       MPI_Comm_size(CXios::globalComm, &size); 
     329      ep_lib::MPI_Comm_size(CXios::globalComm, &size); 
    328330      while (size) 
    329331      { 
     
    334336      if (CXios::usingOasis) 
    335337      { 
    336         MPI_Comm_rank(CXios::globalComm,&rank); 
     338        ep_lib::MPI_Comm_rank(CXios::globalComm,&rank); 
    337339        fileNameClient << fileName << "_" << std::setfill('0') << std::setw(numDigit) << rank << ext; 
    338340      } 
  • XIOS/trunk/src/client.hpp

    r1587 r1638  
    1010    { 
    1111      public: 
    12         static void initialize(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm); 
     12        static void initialize(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm); 
    1313        static void finalize(void); 
    14         static void registerContext(const string& id, MPI_Comm contextComm); 
     14        static void registerContext(const string& id, ep_lib::MPI_Comm contextComm); 
    1515        static void callOasisEnddef(void) ; 
    1616 
    17         static MPI_Comm intraComm; 
    18         static MPI_Comm interComm; 
    19         static std::list<MPI_Comm> contextInterComms; 
     17        static ep_lib::MPI_Comm intraComm; 
     18        static ep_lib::MPI_Comm interComm; 
     19        static std::list<ep_lib::MPI_Comm> contextInterComms; 
    2020        static int serverLeader; 
    2121        static bool is_MPI_Initialized ; 
    2222 
    23         static MPI_Comm& getInterComm(); 
     23        static ep_lib::MPI_Comm& getInterComm(); 
    2424 
    2525        //! Get global rank without oasis and current rank in model intraComm in case of oasis 
  • XIOS/trunk/src/client_client_dht_template.hpp

    r1542 r1638  
    4040  public: 
    4141    CClientClientDHTTemplate(const Index2InfoTypeMap& indexInfoInitMap, 
    42                              const MPI_Comm& clientIntraComm); 
     42                             const ep_lib::MPI_Comm& clientIntraComm); 
    4343 
    4444    CClientClientDHTTemplate(const Index2VectorInfoTypeMap& indexInfoInitMap, 
    45                              const MPI_Comm& clientIntraComm); 
     45                             const ep_lib::MPI_Comm& clientIntraComm); 
    4646 
    4747    void computeIndexInfoMapping(const CArray<size_t,1>& indices); 
     
    5555 
    5656  protected: 
    57     CClientClientDHTTemplate(const MPI_Comm& clientIntraComm); 
     57    CClientClientDHTTemplate(const ep_lib::MPI_Comm& clientIntraComm); 
    5858 
    5959  protected: 
     
    6262    // Redistribute index and info among clients 
    6363    void computeDistributedIndex(const Index2InfoTypeMap& indexInfoInitMap, 
    64                                  const MPI_Comm& intraCommLevel, 
     64                                 const ep_lib::MPI_Comm& intraCommLevel, 
    6565                                 int level); 
    6666 
    6767    void computeDistributedIndex(const Index2VectorInfoTypeMap& indexInfoInitMap, 
    68                                  const MPI_Comm& intraCommLevel, 
     68                                 const ep_lib::MPI_Comm& intraCommLevel, 
    6969                                 int level); 
    7070 
     
    7373 
    7474    void computeIndexInfoMappingLevel(const CArray<size_t,1>& indices, 
    75                                       const MPI_Comm& intraCommLevel, 
     75                                      const ep_lib::MPI_Comm& intraCommLevel, 
    7676                                      int level); 
    7777 
     
    8585    // Send information to clients 
    8686    void sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize, 
    87                            const MPI_Comm& clientIntraComm, 
    88                            std::vector<MPI_Request>& requestSendInfo); 
     87                           const ep_lib::MPI_Comm& clientIntraComm, 
     88                           std::vector<ep_lib::MPI_Request>& requestSendInfo); 
     89    void sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize, 
     90                           const ep_lib::MPI_Comm& clientIntraComm, 
     91                           ep_lib::MPI_Request* requestSendInfo); 
    8992 
    9093    void recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize, 
    91                             const MPI_Comm& clientIntraComm, 
    92                             std::vector<MPI_Request>& requestRecvInfo); 
     94                            const ep_lib::MPI_Comm& clientIntraComm, 
     95                            std::vector<ep_lib::MPI_Request>& requestRecvInfo); 
     96    void recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize, 
     97                             const ep_lib::MPI_Comm& clientIntraComm, 
     98                             ep_lib::MPI_Request* requestRecvInfo); 
     99                                                         
    93100 
    94101    // Send global index to clients 
    95102    void sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize, 
    96                             const MPI_Comm& clientIntraComm, 
    97                             std::vector<MPI_Request>& requestSendIndexGlobal); 
     103                            const ep_lib::MPI_Comm& clientIntraComm, 
     104                            std::vector<ep_lib::MPI_Request>& requestSendIndexGlobal); 
     105    void sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize, 
     106                            const ep_lib::MPI_Comm& clientIntraComm, 
     107                            ep_lib::MPI_Request* requestSendIndexGlobal); 
    98108 
    99109    void recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize, 
    100                              const MPI_Comm& clientIntraComm, 
    101                              std::vector<MPI_Request>& requestRecvIndex); 
     110                             const ep_lib::MPI_Comm& clientIntraComm, 
     111                             std::vector<ep_lib::MPI_Request>& requestRecvIndex); 
     112    void recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize, 
     113                              const ep_lib::MPI_Comm& clientIntraComm, 
     114                              ep_lib::MPI_Request* requestRecvIndex); 
    102115 
    103116    void sendRecvOnReturn(const std::vector<int>& sendNbRank, std::vector<int>& sendNbElements, 
  • XIOS/trunk/src/client_client_dht_template_impl.hpp

    r1542 r1638  
    1414{ 
    1515template<typename T, typename H> 
    16 CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const MPI_Comm& clientIntraComm) 
     16CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const ep_lib::MPI_Comm& clientIntraComm) 
    1717  : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0) 
    1818{ 
    19   MPI_Comm_size(clientIntraComm, &nbClient_); 
     19  ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_); 
    2020  this->computeMPICommLevel(); 
    2121  int nbLvl = this->getNbLevel(); 
     
    3434template<typename T, typename H> 
    3535CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const Index2InfoTypeMap& indexInfoMap, 
    36                                                         const MPI_Comm& clientIntraComm) 
     36                                                        const ep_lib::MPI_Comm& clientIntraComm) 
    3737  : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0) 
    3838{ 
    39   MPI_Comm_size(clientIntraComm, &nbClient_); 
     39  ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_); 
    4040  this->computeMPICommLevel(); 
    4141  int nbLvl = this->getNbLevel(); 
     
    5959template<typename T, typename H> 
    6060CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const Index2VectorInfoTypeMap& indexInfoMap, 
    61                                                         const MPI_Comm& clientIntraComm) 
     61                                                        const ep_lib::MPI_Comm& clientIntraComm) 
    6262  : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0) 
    6363{ 
    64   MPI_Comm_size(clientIntraComm, &nbClient_); 
     64  ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_); 
    6565  this->computeMPICommLevel(); 
    6666  int nbLvl = this->getNbLevel(); 
     
    9595template<typename T, typename H> 
    9696void CClientClientDHTTemplate<T,H>::computeIndexInfoMappingLevel(const CArray<size_t,1>& indices, 
    97                                                                  const MPI_Comm& commLevel, 
     97                                                                 const ep_lib::MPI_Comm& commLevel, 
    9898                                                                 int level) 
    9999{ 
    100100  int clientRank; 
    101   MPI_Comm_rank(commLevel,&clientRank); 
     101  ep_lib::MPI_Comm_rank(commLevel,&clientRank); 
    102102  int groupRankBegin = this->getGroupBegin()[level]; 
    103103  int nbClient = this->getNbInGroup()[level]; 
     
    169169    recvIndexBuff = new unsigned long[recvNbIndexCount]; 
    170170 
    171   std::vector<MPI_Request> request; 
     171  int request_size = 0; 
     172  for (int idx = 0; idx < recvRankClient.size(); ++idx) 
     173  { 
     174    if (0 != recvNbIndexClientCount[idx]) 
     175      request_size ++; 
     176  } 
     177 
     178  request_size += client2ClientIndex.size(); 
     179 
     180  std::vector<ep_lib::MPI_Request> request(request_size); 
    172181  std::vector<int>::iterator itbRecvIndex = recvRankClient.begin(), itRecvIndex, 
    173182                             iteRecvIndex = recvRankClient.end(), 
     
    176185  int currentIndex = 0; 
    177186  int nbRecvClient = recvRankClient.size(); 
     187  int request_position = 0; 
    178188  for (int idx = 0; idx < nbRecvClient; ++idx) 
    179189  { 
    180190    if (0 != recvNbIndexClientCount[idx]) 
    181       recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request); 
     191      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, &request[request_position++]); 
    182192    currentIndex += recvNbIndexClientCount[idx]; 
    183193  } 
     
    186196                                                iteIndex = client2ClientIndex.end(); 
    187197  for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex) 
    188     sendIndexToClients(itIndex->first, (itIndex->second), sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request); 
    189  
    190   std::vector<MPI_Status> status(request.size()); 
    191   MPI_Waitall(request.size(), &request[0], &status[0]); 
     198    sendIndexToClients(itIndex->first, (itIndex->second), sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, &request[request_position++]); 
     199 
     200  std::vector<ep_lib::MPI_Status> status(request.size()); 
     201  ep_lib::MPI_Waitall(request.size(), &request[0], &status[0]); 
    192202 
    193203  CArray<size_t,1>* tmpGlobalIndex; 
     
    242252  } 
    243253 
    244   std::vector<MPI_Request> requestOnReturn; 
     254  int requestOnReturn_size=0; 
     255  for (int idx = 0; idx < recvRankOnReturn.size(); ++idx) 
     256  { 
     257    if (0 != recvNbIndexOnReturn[idx]) 
     258    { 
     259      requestOnReturn_size += 2; 
     260    } 
     261  } 
     262 
     263  for (int idx = 0; idx < nbRecvClient; ++idx) 
     264  { 
     265    if (0 != sendNbIndexOnReturn[idx]) 
     266    { 
     267      requestOnReturn_size += 2; 
     268    } 
     269  } 
     270 
     271  int requestOnReturn_position=0; 
     272 
     273  std::vector<ep_lib::MPI_Request> requestOnReturn(requestOnReturn_size); 
    245274  currentIndex = 0; 
    246275  for (int idx = 0; idx < recvRankOnReturn.size(); ++idx) 
     
    248277    if (0 != recvNbIndexOnReturn[idx]) 
    249278    { 
    250       recvIndexFromClients(recvRankOnReturn[idx], recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], commLevel, requestOnReturn); 
     279      recvIndexFromClients(recvRankOnReturn[idx], recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], commLevel, &requestOnReturn[requestOnReturn_position++]); 
    251280      recvInfoFromClients(recvRankOnReturn[idx], 
    252281                          recvInfoBuffOnReturn+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
    253282                          recvNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), 
    254                           commLevel, requestOnReturn); 
     283                          commLevel, &requestOnReturn[requestOnReturn_position++]); 
    255284    } 
    256285    currentIndex += recvNbIndexOnReturn[idx]; 
     
    286315 
    287316      sendIndexToClients(rank, client2ClientIndexOnReturn[rank], 
    288                          sendNbIndexOnReturn[idx], commLevel, requestOnReturn); 
     317                         sendNbIndexOnReturn[idx], commLevel, &requestOnReturn[requestOnReturn_position++]); 
    289318      sendInfoToClients(rank, client2ClientInfoOnReturn[rank], 
    290                         sendNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), commLevel, requestOnReturn); 
     319                        sendNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), commLevel, &requestOnReturn[requestOnReturn_position++]); 
    291320    } 
    292321    currentIndex += recvNbIndexClientCount[idx]; 
    293322  } 
    294323 
    295   std::vector<MPI_Status> statusOnReturn(requestOnReturn.size()); 
    296   MPI_Waitall(requestOnReturn.size(), &requestOnReturn[0], &statusOnReturn[0]); 
     324  std::vector<ep_lib::MPI_Status> statusOnReturn(requestOnReturn.size()); 
     325  ep_lib::MPI_Waitall(requestOnReturn.size(), &requestOnReturn[0], &statusOnReturn[0]); 
    297326 
    298327  Index2VectorInfoTypeMap indexToInfoMapping; 
     
    360389template<typename T, typename H> 
    361390void CClientClientDHTTemplate<T,H>::computeDistributedIndex(const Index2VectorInfoTypeMap& indexInfoMap, 
    362                                                             const MPI_Comm& commLevel, 
     391                                                            const ep_lib::MPI_Comm& commLevel, 
    363392                                                            int level) 
    364393{ 
    365394  int clientRank; 
    366   MPI_Comm_rank(commLevel,&clientRank); 
     395  ep_lib::MPI_Comm_rank(commLevel,&clientRank); 
    367396  computeSendRecvRank(level, clientRank); 
    368397 
     
    439468  // it will send a message to the correct clients. 
    440469  // Contents of the message are index and its corresponding informatioin 
    441   std::vector<MPI_Request> request; 
     470  int request_size = 0; 
     471   for (int idx = 0; idx < recvRankClient.size(); ++idx) 
     472   { 
     473     if (0 != recvNbIndexClientCount[idx]) 
     474     { 
     475       request_size += 2; 
     476     } 
     477   } 
     478  
     479   request_size += client2ClientIndex.size(); 
     480   request_size += client2ClientInfo.size(); 
     481  
     482   std::vector<ep_lib::MPI_Request> request(request_size); 
     483 
    442484  int currentIndex = 0; 
    443485  int nbRecvClient = recvRankClient.size(); 
     486  int request_position=0; 
    444487  for (int idx = 0; idx < nbRecvClient; ++idx) 
    445488  { 
    446489    if (0 != recvNbIndexClientCount[idx]) 
    447490    { 
    448       recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request); 
     491      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, &request[request_position++]); 
     492      //if(clientRank==0) printf("recv index request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request)); 
    449493      recvInfoFromClients(recvRankClient[idx], 
    450                           recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
    451                           recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(), 
    452                           commLevel, request); 
     494                            recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
     495                            recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(), 
     496                            commLevel, &request[request_position++]); 
     497      //if(clientRank==0) printf("recv info request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request)); 
    453498    } 
    454499    currentIndex += recvNbIndexClientCount[idx]; 
     
    458503                                                iteIndex = client2ClientIndex.end(); 
    459504  for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex) 
    460     sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request); 
     505  {  sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, &request[request_position++]); 
     506  }    //if(clientRank==0) printf("send index request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request));} 
    461507  std::unordered_map<int, unsigned char*>::iterator itbInfo = client2ClientInfo.begin(), itInfo, 
    462508                                                      iteInfo = client2ClientInfo.end(); 
    463509  for (itInfo = itbInfo; itInfo != iteInfo; ++itInfo) 
    464     sendInfoToClients(itInfo->first, itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], commLevel, request); 
    465  
    466   std::vector<MPI_Status> status(request.size()); 
    467   MPI_Waitall(request.size(), &request[0], &status[0]); 
     510   { sendInfoToClients(itInfo->first, itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], commLevel, &request[request_position++]); 
     511   }//   if(clientRank==0) printf("send info request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request));} 
     512 
     513  std::vector<ep_lib::MPI_Status> status(request.size()); 
     514   
     515  ep_lib::MPI_Waitall(request.size(), &request[0], &status[0]); 
    468516 
    469517  Index2VectorInfoTypeMap indexToInfoMapping; 
     
    518566template<typename T, typename H> 
    519567void CClientClientDHTTemplate<T,H>::sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize, 
    520                                                        const MPI_Comm& clientIntraComm, 
    521                                                        std::vector<MPI_Request>& requestSendIndex) 
    522 { 
    523   MPI_Request request; 
     568                                                       const ep_lib::MPI_Comm& clientIntraComm, 
     569                                                       std::vector<ep_lib::MPI_Request>& requestSendIndex) 
     570{ 
     571  ep_lib::MPI_Request request; 
    524572  requestSendIndex.push_back(request); 
    525   MPI_Isend(indices, indiceSize, MPI_UNSIGNED_LONG, 
     573  ep_lib::MPI_Isend(indices, indiceSize, EP_UNSIGNED_LONG, 
    526574            clientDestRank, MPI_DHT_INDEX, clientIntraComm, &(requestSendIndex.back())); 
     575} 
     576 
     577/*! 
     578  Send message containing index to clients 
     579  \param [in] clientDestRank rank of destination client 
     580  \param [in] indices index to send 
     581  \param [in] indiceSize size of index array to send 
     582  \param [in] clientIntraComm communication group of client 
     583  \param [in] requestSendIndex sending request 
     584*/ 
     585template<typename T, typename H> 
     586void CClientClientDHTTemplate<T,H>::sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize, 
     587                                                       const ep_lib::MPI_Comm& clientIntraComm, 
     588                                                       ep_lib::MPI_Request* requestSendIndex) 
     589{ 
     590  ep_lib::MPI_Isend(indices, indiceSize, EP_UNSIGNED_LONG, 
     591            clientDestRank, MPI_DHT_INDEX, clientIntraComm, requestSendIndex); 
    527592} 
    528593 
     
    536601template<typename T, typename H> 
    537602void CClientClientDHTTemplate<T,H>::recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize, 
    538                                                          const MPI_Comm& clientIntraComm, 
    539                                                          std::vector<MPI_Request>& requestRecvIndex) 
    540 { 
    541   MPI_Request request; 
     603                                                         const ep_lib::MPI_Comm& clientIntraComm, 
     604                                                         std::vector<ep_lib::MPI_Request>& requestRecvIndex) 
     605{ 
     606  ep_lib::MPI_Request request; 
    542607  requestRecvIndex.push_back(request); 
    543   MPI_Irecv(indices, indiceSize, MPI_UNSIGNED_LONG, 
     608  ep_lib::MPI_Irecv(indices, indiceSize, EP_UNSIGNED_LONG, 
    544609            clientSrcRank, MPI_DHT_INDEX, clientIntraComm, &(requestRecvIndex.back())); 
     610} 
     611 
     612/*! 
     613  Receive message containing index to clients 
     614  \param [in] clientDestRank rank of destination client 
     615  \param [in] indices index to send 
     616  \param [in] clientIntraComm communication group of client 
     617  \param [in] requestRecvIndex receiving request 
     618*/ 
     619template<typename T, typename H> 
     620void CClientClientDHTTemplate<T,H>::recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize, 
     621                                                         const ep_lib::MPI_Comm& clientIntraComm, 
     622                                                         ep_lib::MPI_Request *requestRecvIndex) 
     623{ 
     624  ep_lib::MPI_Irecv(indices, indiceSize, EP_UNSIGNED_LONG, 
     625            clientSrcRank, MPI_DHT_INDEX, clientIntraComm, requestRecvIndex); 
    545626} 
    546627 
     
    555636template<typename T, typename H> 
    556637void CClientClientDHTTemplate<T,H>::sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize, 
    557                                                       const MPI_Comm& clientIntraComm, 
    558                                                       std::vector<MPI_Request>& requestSendInfo) 
    559 { 
    560   MPI_Request request; 
     638                                                      const ep_lib::MPI_Comm& clientIntraComm, 
     639                                                      std::vector<ep_lib::MPI_Request>& requestSendInfo) 
     640{ 
     641  ep_lib::MPI_Request request; 
    561642  requestSendInfo.push_back(request); 
    562643 
    563   MPI_Isend(info, infoSize, MPI_CHAR, 
     644  ep_lib::MPI_Isend(info, infoSize, EP_CHAR, 
    564645            clientDestRank, MPI_DHT_INFO, clientIntraComm, &(requestSendInfo.back())); 
     646} 
     647 
     648/*! 
     649  Send message containing information to clients 
     650  \param [in] clientDestRank rank of destination client 
     651  \param [in] info info array to send 
     652  \param [in] infoSize info array size to send 
     653  \param [in] clientIntraComm communication group of client 
     654  \param [in] requestSendInfo sending request 
     655*/ 
     656template<typename T, typename H> 
     657void CClientClientDHTTemplate<T,H>::sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize, 
     658                                                      const ep_lib::MPI_Comm& clientIntraComm, 
     659                                                      ep_lib::MPI_Request *requestSendInfo) 
     660{ 
     661  ep_lib::MPI_Isend(info, infoSize, EP_CHAR, 
     662            clientDestRank, MPI_DHT_INFO, clientIntraComm, requestSendInfo); 
    565663} 
    566664 
     
    575673template<typename T, typename H> 
    576674void CClientClientDHTTemplate<T,H>::recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize, 
    577                                                         const MPI_Comm& clientIntraComm, 
    578                                                         std::vector<MPI_Request>& requestRecvInfo) 
    579 { 
    580   MPI_Request request; 
     675                                                        const ep_lib::MPI_Comm& clientIntraComm, 
     676                                                        std::vector<ep_lib::MPI_Request>& requestRecvInfo) 
     677{ 
     678  ep_lib::MPI_Request request; 
    581679  requestRecvInfo.push_back(request); 
    582680 
    583   MPI_Irecv(info, infoSize, MPI_CHAR, 
     681  ep_lib::MPI_Irecv(info, infoSize, EP_CHAR, 
    584682            clientSrcRank, MPI_DHT_INFO, clientIntraComm, &(requestRecvInfo.back())); 
     683} 
     684 
     685/*! 
     686  Receive message containing information from other clients 
     687  \param [in] clientDestRank rank of destination client 
     688  \param [in] info info array to receive 
     689  \param [in] infoSize info array size to receive 
     690  \param [in] clientIntraComm communication group of client 
     691  \param [in] requestRecvInfo list of receiving request 
     692*/ 
     693template<typename T, typename H> 
     694void CClientClientDHTTemplate<T,H>::recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize, 
     695                                                        const ep_lib::MPI_Comm& clientIntraComm, 
     696                                                        ep_lib::MPI_Request* requestRecvInfo) 
     697{ 
     698  ep_lib::MPI_Irecv(info, infoSize, EP_CHAR, 
     699            clientSrcRank, MPI_DHT_INFO, clientIntraComm, requestRecvInfo); 
    585700} 
    586701 
     
    651766{ 
    652767  recvNbElements.resize(recvNbRank.size()); 
    653   std::vector<MPI_Request> request(sendNbRank.size()+recvNbRank.size()); 
    654   std::vector<MPI_Status> requestStatus(sendNbRank.size()+recvNbRank.size()); 
     768  std::vector<ep_lib::MPI_Request> request(sendNbRank.size()+recvNbRank.size()); 
     769  std::vector<ep_lib::MPI_Status> requestStatus(sendNbRank.size()+recvNbRank.size()); 
    655770 
    656771  int nRequest = 0; 
    657772  for (int idx = 0; idx < recvNbRank.size(); ++idx) 
    658773  { 
    659     MPI_Irecv(&recvNbElements[0]+idx, 1, MPI_INT, 
     774    ep_lib::MPI_Irecv(&recvNbElements[0]+idx, 1, EP_INT, 
    660775              recvNbRank[idx], MPI_DHT_INDEX_1, this->internalComm_, &request[nRequest]); 
    661776    ++nRequest; 
     
    664779  for (int idx = 0; idx < sendNbRank.size(); ++idx) 
    665780  { 
    666     MPI_Isend(&sendNbElements[0]+idx, 1, MPI_INT, 
     781    ep_lib::MPI_Isend(&sendNbElements[0]+idx, 1, EP_INT, 
    667782              sendNbRank[idx], MPI_DHT_INDEX_1, this->internalComm_, &request[nRequest]); 
    668783    ++nRequest; 
    669784  } 
    670785 
    671   MPI_Waitall(sendNbRank.size()+recvNbRank.size(), &request[0], &requestStatus[0]); 
     786  ep_lib::MPI_Waitall(sendNbRank.size()+recvNbRank.size(), &request[0], &requestStatus[0]); 
    672787} 
    673788 
     
    696811  std::vector<int> recvBuff(recvBuffSize*2,0); 
    697812 
    698   std::vector<MPI_Request> request(sendBuffSize+recvBuffSize); 
    699   std::vector<MPI_Status> requestStatus(sendBuffSize+recvBuffSize); 
     813  std::vector<ep_lib::MPI_Request> request(sendBuffSize+recvBuffSize); 
     814  std::vector<ep_lib::MPI_Status> requestStatus(sendBuffSize+recvBuffSize); 
    700815 
    701816  int nRequest = 0; 
    702817  for (int idx = 0; idx < recvBuffSize; ++idx) 
    703818  { 
    704     MPI_Irecv(&recvBuff[0]+2*idx, 2, MPI_INT, 
     819    ep_lib::MPI_Irecv(&recvBuff[0]+2*idx, 2, EP_INT, 
    705820              recvRank[idx], MPI_DHT_INDEX_0, this->internalComm_, &request[nRequest]); 
    706821    ++nRequest; 
     
    716831  for (int idx = 0; idx < sendBuffSize; ++idx) 
    717832  { 
    718     MPI_Isend(&sendBuff[idx*2], 2, MPI_INT, 
     833    ep_lib::MPI_Isend(&sendBuff[idx*2], 2, EP_INT, 
    719834              sendRank[idx], MPI_DHT_INDEX_0, this->internalComm_, &request[nRequest]); 
    720835    ++nRequest; 
    721836  } 
    722837 
    723   MPI_Waitall(sendBuffSize+recvBuffSize, &request[0], &requestStatus[0]); 
     838  ep_lib::MPI_Waitall(sendBuffSize+recvBuffSize, &request[0], &requestStatus[0]); 
    724839  int nbRecvRank = 0, nbRecvElements = 0; 
    725840  recvNbRank.clear(); 
  • XIOS/trunk/src/client_server_mapping.cpp

    r1025 r1638  
    3030*/ 
    3131std::map<int,int> CClientServerMapping::computeConnectedClients(int nbServer, int nbClient, 
    32                                                                 MPI_Comm& clientIntraComm, 
     32                                                                ep_lib::MPI_Comm& clientIntraComm, 
    3333                                                                const std::vector<int>& connectedServerRank) 
    3434{ 
     
    6262 
    6363  // get connected server for everybody 
    64   MPI_Allgather(&nbConnectedServer,1,MPI_INT,recvCount,1,MPI_INT,clientIntraComm) ; 
     64  ep_lib::MPI_Allgather(&nbConnectedServer,1,EP_INT,recvCount,1,EP_INT,clientIntraComm) ; 
    6565 
    6666  displ[0]=0 ; 
     
    7070 
    7171 
    72   MPI_Allgatherv(sendBuff,nbConnectedServer,MPI_INT,recvBuff,recvCount,displ,MPI_INT,clientIntraComm) ; 
     72  ep_lib::MPI_Allgatherv(sendBuff,nbConnectedServer,EP_INT,recvBuff,recvCount,displ,EP_INT,clientIntraComm) ; 
    7373  for(int n=0;n<recvSize;n++) clientRes[recvBuff[n]]++ ; 
    7474 
  • XIOS/trunk/src/client_server_mapping.hpp

    r1542 r1638  
    3737 
    3838    static std::map<int,int> computeConnectedClients(int nbServer, int nbClient, 
    39                                                      MPI_Comm& clientIntraComm, 
     39                                                     ep_lib::MPI_Comm& clientIntraComm, 
    4040                                                     const std::vector<int>& connectedServerRank); 
    4141 
  • XIOS/trunk/src/client_server_mapping_distributed.cpp

    r1542 r1638  
    2020 
    2121CClientServerMappingDistributed::CClientServerMappingDistributed(const std::unordered_map<size_t,int>& globalIndexOfServer, 
    22                                                                  const MPI_Comm& clientIntraComm, bool isDataDistributed) 
     22                                                                 const ep_lib::MPI_Comm& clientIntraComm, bool isDataDistributed) 
    2323  : CClientServerMapping(), ccDHT_(0) 
    2424{ 
  • XIOS/trunk/src/client_server_mapping_distributed.hpp

    r1542 r1638  
    3535    /** Default constructor */ 
    3636    CClientServerMappingDistributed(const std::unordered_map<size_t,int>& globalIndexOfServer, 
    37                                     const MPI_Comm& clientIntraComm, 
     37                                    const ep_lib::MPI_Comm& clientIntraComm, 
    3838                                    bool isDataDistributed = true); 
    3939 
  • XIOS/trunk/src/context_client.cpp

    r1615 r1638  
    2121    \cxtSer [in] cxtSer Pointer to context of server side. (It is only used in case of attached mode). 
    2222    */ 
    23     CContextClient::CContextClient(CContext* parent, MPI_Comm intraComm_, MPI_Comm interComm_, CContext* cxtSer) 
     23    CContextClient::CContextClient(CContext* parent, ep_lib::MPI_Comm intraComm_, ep_lib::MPI_Comm interComm_, CContext* cxtSer) 
    2424     : mapBufferSize_(), parentServer(cxtSer), maxBufferedEvents(4) 
    2525    { 
     
    2727      intraComm = intraComm_; 
    2828      interComm = interComm_; 
    29       MPI_Comm_rank(intraComm, &clientRank); 
    30       MPI_Comm_size(intraComm, &clientSize); 
     29      ep_lib::MPI_Comm_rank(intraComm, &clientRank); 
     30      ep_lib::MPI_Comm_size(intraComm, &clientSize); 
    3131 
    3232      int flag; 
    33       MPI_Comm_test_inter(interComm, &flag); 
    34       if (flag) MPI_Comm_remote_size(interComm, &serverSize); 
    35       else  MPI_Comm_size(interComm, &serverSize); 
     33      ep_lib::MPI_Comm_test_inter(interComm, &flag); 
     34      if (flag) ep_lib::MPI_Comm_remote_size(interComm, &serverSize); 
     35      else  ep_lib::MPI_Comm_size(interComm, &serverSize); 
    3636 
    3737      computeLeader(clientRank, clientSize, serverSize, ranksServerLeader, ranksServerNotLeader); 
     
    102102        classId_in=event.getClassId() ; 
    103103//        MPI_Allreduce(&timeLine,&timeLine_out, 1, MPI_UINT64_T, MPI_SUM, intraComm) ; // MPI_UINT64_T standardized by MPI 3 
    104         MPI_Allreduce(&timeLine,&timeLine_out, 1, MPI_LONG_LONG_INT, MPI_SUM, intraComm) ;  
    105         MPI_Allreduce(&typeId_in,&typeId, 1, MPI_INT, MPI_SUM, intraComm) ; 
    106         MPI_Allreduce(&classId_in,&classId, 1, MPI_INT, MPI_SUM, intraComm) ; 
     104        ep_lib::MPI_Allreduce(&timeLine,&timeLine_out, 1, EP_LONG_LONG_INT, EP_SUM, intraComm) ;  
     105        ep_lib::MPI_Allreduce(&typeId_in,&typeId, 1, EP_INT, EP_SUM, intraComm) ; 
     106        ep_lib::MPI_Allreduce(&classId_in,&classId, 1, EP_INT, EP_SUM, intraComm) ; 
    107107        if (typeId/clientSize!=event.getTypeId() || classId/clientSize!=event.getClassId() || timeLine_out/clientSize!=timeLine) 
    108108        { 
     
    343343       if (ratio < minBufferSizeEventSizeRatio) minBufferSizeEventSizeRatio = ratio; 
    344344     } 
    345      MPI_Allreduce(MPI_IN_PLACE, &minBufferSizeEventSizeRatio, 1, MPI_DOUBLE, MPI_MIN, intraComm); 
     345     #ifdef _usingMPI 
     346     ep_lib::MPI_Allreduce(MPI_IN_PLACE, &minBufferSizeEventSizeRatio, 1, EP_DOUBLE, EP_MIN, intraComm); 
     347     #elif _usingEP 
     348     ep_lib::MPI_Allreduce(&minBufferSizeEventSizeRatio, &minBufferSizeEventSizeRatio, 1, EP_DOUBLE, EP_MIN, intraComm); 
     349     #endif 
    346350 
    347351     if (minBufferSizeEventSizeRatio < 1.0) 
  • XIOS/trunk/src/context_client.hpp

    r1232 r1638  
    2727    public: 
    2828      // Contructor 
    29       CContextClient(CContext* parent, MPI_Comm intraComm, MPI_Comm interComm, CContext* parentServer = 0); 
     29      CContextClient(CContext* parent, ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* parentServer = 0); 
    3030 
    3131      // Send event to server 
     
    7171      int serverSize; //!< Size of server group 
    7272 
    73       MPI_Comm interComm; //!< Communicator of server group 
     73      ep_lib::MPI_Comm interComm; //!< Communicator of server group 
    7474 
    75       MPI_Comm intraComm; //!< Communicator of client group 
     75      ep_lib::MPI_Comm intraComm; //!< Communicator of client group 
    7676 
    7777      map<int,CClientBuffer*> buffers; //!< Buffers for connection to servers 
  • XIOS/trunk/src/context_server.cpp

    r1230 r1638  
    2323{ 
    2424 
    25   CContextServer::CContextServer(CContext* parent,MPI_Comm intraComm_,MPI_Comm interComm_) 
     25  CContextServer::CContextServer(CContext* parent,ep_lib::MPI_Comm intraComm_,ep_lib::MPI_Comm interComm_) 
    2626  { 
    2727    context=parent; 
    2828    intraComm=intraComm_; 
    29     MPI_Comm_size(intraComm,&intraCommSize); 
    30     MPI_Comm_rank(intraComm,&intraCommRank); 
     29    ep_lib::MPI_Comm_size(intraComm,&intraCommSize); 
     30    ep_lib::MPI_Comm_rank(intraComm,&intraCommRank); 
    3131 
    3232    interComm=interComm_; 
    3333    int flag; 
    34     MPI_Comm_test_inter(interComm,&flag); 
    35     if (flag) MPI_Comm_remote_size(interComm,&commSize); 
    36     else  MPI_Comm_size(interComm,&commSize); 
     34    ep_lib::MPI_Comm_test_inter(interComm,&flag); 
     35    if (flag) ep_lib::MPI_Comm_remote_size(interComm,&commSize); 
     36    else  ep_lib::MPI_Comm_size(interComm,&commSize); 
    3737 
    3838    currentTimeLine=0; 
     
    7676    int count; 
    7777    char * addr; 
    78     MPI_Status status; 
     78    ep_lib::MPI_Status status; 
    7979    map<int,CServerBuffer*>::iterator it; 
    8080    bool okLoop; 
    8181 
    8282    traceOff(); 
     83    #ifdef _usingMPI 
    8384    MPI_Iprobe(MPI_ANY_SOURCE, 20,interComm,&flag,&status); 
     85    #elif _usingEP 
     86    ep_lib::MPI_Iprobe(-2, 20,interComm,&flag,&status); 
     87    #endif 
    8488    traceOn(); 
    8589 
    8690    if (flag==true) 
    8791    { 
     92      #ifdef _usingMPI 
    8893      rank=status.MPI_SOURCE ; 
     94      #elif _usingEP 
     95      rank=status.ep_src ; 
     96      #endif 
    8997      okLoop = true; 
    9098      if (pendingRequest.find(rank)==pendingRequest.end()) 
     
    98106 
    99107            traceOff(); 
    100             MPI_Iprobe(rank, 20,interComm,&flag,&status); 
     108            ep_lib::MPI_Iprobe(rank, 20,interComm,&flag,&status); 
    101109            traceOn(); 
    102110            if (flag==true) listenPendingRequest(status) ; 
     
    107115  } 
    108116 
    109   bool CContextServer::listenPendingRequest(MPI_Status& status) 
     117  bool CContextServer::listenPendingRequest(ep_lib::MPI_Status& status) 
    110118  { 
    111119    int count; 
    112120    char * addr; 
    113121    map<int,CServerBuffer*>::iterator it; 
     122    #ifdef _usingMPI 
    114123    int rank=status.MPI_SOURCE ; 
     124    #elif _usingEP 
     125    int rank=status.ep_src ; 
     126    #endif 
    115127 
    116128    it=buffers.find(rank); 
     
    118130    { 
    119131       StdSize buffSize = 0; 
    120        MPI_Recv(&buffSize, 1, MPI_LONG, rank, 20, interComm, &status); 
     132       ep_lib::MPI_Recv(&buffSize, 1, EP_LONG, rank, 20, interComm, &status); 
    121133       mapBufferSize_.insert(std::make_pair(rank, buffSize)); 
    122134       it=(buffers.insert(pair<int,CServerBuffer*>(rank,new CServerBuffer(buffSize)))).first; 
     
    125137    else 
    126138    { 
    127       MPI_Get_count(&status,MPI_CHAR,&count); 
     139      ep_lib::MPI_Get_count(&status,EP_CHAR,&count); 
    128140      if (it->second->isBufferFree(count)) 
    129141      { 
    130142         addr=(char*)it->second->getBuffer(count); 
    131          MPI_Irecv(addr,count,MPI_CHAR,rank,20,interComm,&pendingRequest[rank]); 
     143         ep_lib::MPI_Irecv(addr,count,EP_CHAR,rank,20,interComm,&pendingRequest[rank]); 
    132144         bufferRequest[rank]=addr; 
    133145         return true; 
     
    141153  void CContextServer::checkPendingRequest(void) 
    142154  { 
    143     map<int,MPI_Request>::iterator it; 
     155    map<int,ep_lib::MPI_Request>::iterator it; 
    144156    list<int> recvRequest; 
    145157    list<int>::iterator itRecv; 
     
    147159    int flag; 
    148160    int count; 
    149     MPI_Status status; 
     161    ep_lib::MPI_Status status; 
    150162 
    151163    for(it=pendingRequest.begin();it!=pendingRequest.end();it++) 
     
    153165      rank=it->first; 
    154166      traceOff(); 
    155       MPI_Test(& it->second, &flag, &status); 
     167      ep_lib::MPI_Test(& it->second, &flag, &status); 
    156168      traceOn(); 
    157169      if (flag==true) 
    158170      { 
    159171        recvRequest.push_back(rank); 
    160         MPI_Get_count(&status,MPI_CHAR,&count); 
     172        ep_lib::MPI_Get_count(&status,EP_CHAR,&count); 
    161173        processRequest(rank,bufferRequest[rank],count); 
    162174      } 
     
    218230         // The best way to properly solve this problem will be to use the event scheduler also in attached mode 
    219231         // for now just set up a MPI barrier 
    220          if (!CServer::eventScheduler && CXios::isServer) MPI_Barrier(intraComm) ; 
     232         if (!CServer::eventScheduler && CXios::isServer) ep_lib::MPI_Barrier(intraComm) ; 
    221233 
    222234         CTimer::get("Process events").resume(); 
  • XIOS/trunk/src/context_server.hpp

    r1228 r1638  
    1414    public: 
    1515 
    16     CContextServer(CContext* parent,MPI_Comm intraComm,MPI_Comm interComm) ; 
     16    CContextServer(CContext* parent,ep_lib::MPI_Comm intraComm,ep_lib::MPI_Comm interComm) ; 
    1717    bool eventLoop(bool enableEventsProcessing = true); 
    1818    void listen(void) ; 
    19     bool listenPendingRequest(MPI_Status& status) ; 
     19    bool listenPendingRequest(ep_lib::MPI_Status& status) ; 
    2020    void checkPendingRequest(void) ; 
    2121    void processRequest(int rank, char* buff,int count) ; 
     
    2626    bool hasPendingEvent(void) ; 
    2727 
    28     MPI_Comm intraComm ; 
     28    ep_lib::MPI_Comm intraComm ; 
    2929    int intraCommSize ; 
    3030    int intraCommRank ; 
    3131 
    32     MPI_Comm interComm ; 
     32    ep_lib::MPI_Comm interComm ; 
    3333    int commSize ; 
    3434 
    3535    map<int,CServerBuffer*> buffers ; 
    36     map<int,MPI_Request> pendingRequest ; 
     36    map<int,ep_lib::MPI_Request> pendingRequest ; 
    3737    map<int,char*> bufferRequest ; 
    3838 
  • XIOS/trunk/src/cxios.cpp

    r1622 r1638  
    2626  bool CXios::isClient ; 
    2727  bool CXios::isServer ; 
    28   MPI_Comm CXios::globalComm ; 
     28  ep_lib::MPI_Comm CXios::globalComm ; 
    2929  bool CXios::usingOasis ; 
    3030  bool CXios::usingServer = false; 
     
    9090 
    9191    checkEventSync = getin<bool>("check_event_sync", checkEventSync); 
    92  
     92    #ifdef _usingMPI 
    9393    globalComm=MPI_COMM_WORLD ; 
     94    #elif _usingEP 
     95    ep_lib::MPI_Comm *ep_comm; 
     96    ep_lib::MPI_Info info; 
     97    ep_lib::MPI_Comm_create_endpoints(EP_COMM_WORLD->mpi_comm, 1, info, ep_comm); 
     98    ep_lib::passage = ep_comm; 
     99    globalComm=ep_lib::passage[0] ; 
     100    #endif 
    94101  } 
    95102 
     
    100107  \param [in/out] returnComm communicator corresponding to group of client with same codeId 
    101108  */ 
    102   void CXios::initClientSide(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm) 
     109  void CXios::initClientSide(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm) 
    103110  TRY 
    104111  { 
     112    isClient = true; 
     113    isServer = false; 
     114 
    105115    initialize() ; 
    106116 
    107     isClient = true; 
    108117 
    109118    CClient::initialize(codeId,localComm,returnComm) ; 
    110119    if (CClient::getRank()==0) globalRegistry = new CRegistry(returnComm) ; 
     120 
    111121 
    112122    // If there are no server processes then we are in attached mode 
     
    167177  void CXios::initServerSide(void) 
    168178  { 
     179    isClient = false; 
     180    isServer = true; 
     181 
    169182    initServer(); 
    170183    isClient = false; 
    171184    isServer = true; 
    172  
    173185    // Initialize all aspects MPI 
    174186    CServer::initialize(); 
     
    223235        int firstPoolGlobalRank = secondaryServerGlobalRanks[0]; 
    224236        int rankGlobal; 
    225         MPI_Comm_rank(globalComm, &rankGlobal); 
     237        ep_lib::MPI_Comm_rank(globalComm, &rankGlobal); 
    226238 
    227239        // Merge registries defined on each pools 
     
    235247            globalRegistrySndServers.mergeRegistry(*globalRegistry) ; 
    236248            int registrySize = globalRegistrySndServers.size(); 
    237             MPI_Send(&registrySize,1,MPI_LONG,firstPoolGlobalRank,15,CXios::globalComm) ; 
     249            ep_lib::MPI_Send(&registrySize,1,EP_LONG,firstPoolGlobalRank,15,CXios::globalComm) ; 
    238250            CBufferOut buffer(registrySize) ; 
    239251            globalRegistrySndServers.toBuffer(buffer) ; 
    240             MPI_Send(buffer.start(),registrySize,MPI_CHAR,firstPoolGlobalRank,15,CXios::globalComm) ; 
     252            ep_lib::MPI_Send(buffer.start(),registrySize,EP_CHAR,firstPoolGlobalRank,15,CXios::globalComm) ; 
    241253          } 
    242254        } 
     
    245257        if (rankGlobal == firstPoolGlobalRank) 
    246258        { 
    247           MPI_Status status; 
     259          ep_lib::MPI_Status status; 
    248260          char* recvBuff; 
    249261 
     
    254266            int rank = secondaryServerGlobalRanks[i]; 
    255267            int registrySize = 0; 
    256             MPI_Recv(&registrySize, 1, MPI_LONG, rank, 15, CXios::globalComm, &status); 
     268            ep_lib::MPI_Recv(&registrySize, 1, EP_LONG, rank, 15, CXios::globalComm, &status); 
    257269            recvBuff = new char[registrySize]; 
    258             MPI_Recv(recvBuff, registrySize, MPI_CHAR, rank, 15, CXios::globalComm, &status); 
     270            ep_lib::MPI_Recv(recvBuff, registrySize, EP_CHAR, rank, 15, CXios::globalComm, &status); 
    259271            CBufferIn buffer(recvBuff, registrySize) ; 
    260272            CRegistry recvRegistry; 
  • XIOS/trunk/src/cxios.hpp

    r1622 r1638  
    1515    public: 
    1616     static void initialize(void) ; 
    17      static void initClientSide(const string & codeId, MPI_Comm& localComm, MPI_Comm& returnComm) ; 
     17     static void initClientSide(const string & codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm) ; 
    1818     static void initServerSide(void) ; 
    1919     static void clientFinalize(void) ; 
     
    4040     static bool isServer ; //!< Check if xios is server 
    4141 
    42      static MPI_Comm globalComm ; //!< Global communicator 
     42     static ep_lib::MPI_Comm globalComm ; //!< Global communicator 
    4343 
    4444     static bool printLogs2Files; //!< Printing out logs into files 
  • XIOS/trunk/src/dht_auto_indexing.cpp

    r1158 r1638  
    2222 
    2323  CDHTAutoIndexing::CDHTAutoIndexing(const CArray<size_t,1>& hashValue, 
    24                                      const MPI_Comm& clientIntraComm) 
     24                                     const ep_lib::MPI_Comm& clientIntraComm) 
    2525    : CClientClientDHTTemplate<size_t>(clientIntraComm) 
    2626  { 
     
    2828    nbIndexOnProc_ = hashValue.size(); 
    2929    size_t nbIndexAccum; 
    30     MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, clientIntraComm); 
     30    ep_lib::MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, EP_UNSIGNED_LONG, EP_SUM, clientIntraComm); 
    3131 
    3232    // Broadcasting the total number of indexes 
    3333    int rank, size; 
    34     MPI_Comm_rank(clientIntraComm, &rank); 
    35     MPI_Comm_size(clientIntraComm, &size); 
     34    ep_lib::MPI_Comm_rank(clientIntraComm, &rank); 
     35    ep_lib::MPI_Comm_size(clientIntraComm, &size); 
    3636    if (rank == (size-1)) nbIndexesGlobal_ = nbIndexAccum; 
    37     MPI_Bcast(&nbIndexesGlobal_, 1, MPI_UNSIGNED_LONG, size-1, clientIntraComm); 
     37    ep_lib::MPI_Bcast(&nbIndexesGlobal_, 1, EP_UNSIGNED_LONG, size-1, clientIntraComm); 
    3838 
    3939    CArray<size_t,1>::const_iterator itbIdx = hashValue.begin(), itIdx, 
     
    5858  */ 
    5959  CDHTAutoIndexing::CDHTAutoIndexing(Index2VectorInfoTypeMap& hashInitMap, 
    60                                      const MPI_Comm& clientIntraComm) 
     60                                     const ep_lib::MPI_Comm& clientIntraComm) 
    6161    : CClientClientDHTTemplate<size_t>(clientIntraComm) 
    6262  { 
     
    6464    nbIndexOnProc_ = hashInitMap.size(); 
    6565    size_t nbIndexAccum; 
    66     MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, clientIntraComm); 
     66    ep_lib::MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, EP_UNSIGNED_LONG, EP_SUM, clientIntraComm); 
    6767 
    6868    int rank, size; 
    69     MPI_Comm_rank(clientIntraComm, &rank); 
    70     MPI_Comm_size(clientIntraComm, &size); 
     69    ep_lib::MPI_Comm_rank(clientIntraComm, &rank); 
     70    ep_lib::MPI_Comm_size(clientIntraComm, &size); 
    7171    if (rank == (size-1)) nbIndexesGlobal_ = nbIndexAccum; 
    72     MPI_Bcast(&nbIndexesGlobal_, 1, MPI_UNSIGNED_LONG, size-1, clientIntraComm); 
     72    ep_lib::MPI_Bcast(&nbIndexesGlobal_, 1, EP_UNSIGNED_LONG, size-1, clientIntraComm); 
    7373 
    7474    Index2VectorInfoTypeMap::iterator itbIdx = hashInitMap.begin(), itIdx, 
  • XIOS/trunk/src/dht_auto_indexing.hpp

    r924 r1638  
    2525 
    2626    CDHTAutoIndexing(const CArray<size_t,1>& hashValue, 
    27                      const MPI_Comm& clientIntraComm); 
     27                     const ep_lib::MPI_Comm& clientIntraComm); 
    2828 
    2929    CDHTAutoIndexing(Index2VectorInfoTypeMap& hashInitMap, 
    30                      const MPI_Comm& clientIntraComm); 
     30                     const ep_lib::MPI_Comm& clientIntraComm); 
    3131 
    3232    size_t getNbIndexesGlobal() const; 
  • XIOS/trunk/src/event_scheduler.cpp

    r1224 r1638  
    88  
    99  
    10   CEventScheduler::CEventScheduler(const MPI_Comm& comm)  
    11   { 
    12     MPI_Comm_dup(comm, &communicator) ; 
    13     MPI_Comm_size(communicator,&mpiSize) ; 
    14     MPI_Comm_rank(communicator,&mpiRank); 
     10  CEventScheduler::CEventScheduler(const ep_lib::MPI_Comm& comm)  
     11  { 
     12    ep_lib::MPI_Comm_dup(comm, &communicator) ; 
     13    ep_lib::MPI_Comm_size(communicator,&mpiSize) ; 
     14    ep_lib::MPI_Comm_rank(communicator,&mpiRank); 
    1515 
    1616 
     
    8888 
    8989    pendingSentParentRequest.push(sentRequest) ; 
    90     MPI_Isend(sentRequest->buffer,3, MPI_UNSIGNED_LONG, parent[lev], 0, communicator, &sentRequest->request) ; 
     90    ep_lib::MPI_Isend(sentRequest->buffer,3, EP_UNSIGNED_LONG, parent[lev], 0, communicator, &sentRequest->request) ; 
    9191    traceOn() ; 
    9292  }  
     
    115115  { 
    116116    int completed ; 
    117     MPI_Status status ; 
     117    ep_lib::MPI_Status status ; 
    118118    int received ; 
    119119    SPendingRequest* recvRequest ; 
     
    135135    while(received) 
    136136    { 
     137      #ifdef _usingMPI 
    137138      MPI_Iprobe(MPI_ANY_SOURCE,1,communicator,&received, &status) ; 
     139      #elif _usingEP 
     140      ep_lib::MPI_Iprobe(-2,1,communicator,&received, &status) ; 
     141      #endif 
    138142      if (received) 
    139143      { 
    140144        recvRequest=new SPendingRequest ; 
     145        #ifdef _usingMPI 
    141146        MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, MPI_ANY_SOURCE, 1, communicator, &(recvRequest->request)) ; 
     147        #elif _usingEP 
     148        ep_lib::MPI_Irecv(recvRequest->buffer, 3, EP_UNSIGNED_LONG, -2, 1, communicator, &(recvRequest->request)) ; 
     149        #endif 
    142150        pendingRecvParentRequest.push(recvRequest) ; 
    143151      } 
     
    149157    { 
    150158      recvRequest=pendingRecvParentRequest.front() ; 
    151       MPI_Test( &(recvRequest->request), &completed, &status) ; 
     159      ep_lib::MPI_Test( &(recvRequest->request), &completed, &status) ; 
    152160      if (completed)  
    153161      { 
     
    169177// function call only by parent mpi process 
    170178 
    171     MPI_Status status ;  
     179    ep_lib::MPI_Status status ;  
    172180    int received ; 
    173181    received=true ; 
     
    177185    while(received) 
    178186    { 
     187      #ifdef _usingMPI 
    179188      MPI_Iprobe(MPI_ANY_SOURCE,0,communicator,&received, &status) ; 
     189      #elif _usingEP 
     190      ep_lib::MPI_Iprobe(-2,0,communicator,&received, &status) ; 
     191      #endif 
    180192      if (received) 
    181193      { 
    182194        recvRequest=new SPendingRequest ; 
     195        #ifdef _usingMPI 
    183196        MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, MPI_ANY_SOURCE, 0, communicator, &recvRequest->request) ; 
     197        #elif _usingEP 
     198        ep_lib::MPI_Irecv(recvRequest->buffer, 3, EP_UNSIGNED_LONG, -2, 0, communicator, &recvRequest->request) ; 
     199        #endif 
    184200        pendingRecvChildRequest.push_back(recvRequest) ; 
    185201      } 
     
    190206    for(list<SPendingRequest*>::iterator it=pendingRecvChildRequest.begin(); it!=pendingRecvChildRequest.end() ; ) 
    191207    { 
    192       MPI_Test(&((*it)->request),&received,&status) ; 
     208      ep_lib::MPI_Test(&((*it)->request),&received,&status) ; 
    193209      if (received) 
    194210      { 
     
    228244    for(list<SPendingRequest*>::iterator it=pendingSentChildRequest.begin(); it!=pendingSentChildRequest.end() ; ) 
    229245    { 
    230       MPI_Test(&(*it)->request,&received,&status) ; 
     246      ep_lib::MPI_Test(&(*it)->request,&received,&status) ; 
    231247      if (received) 
    232248      { 
     
    251267      sentRequest->buffer[1]=contextHashId ; 
    252268      sentRequest->buffer[2]=lev+1 ; 
    253       MPI_Isend(sentRequest->buffer,3, MPI_UNSIGNED_LONG, child[lev][i], 1, communicator, & sentRequest->request) ; 
     269      ep_lib::MPI_Isend(sentRequest->buffer,3, EP_UNSIGNED_LONG, child[lev][i], 1, communicator, & sentRequest->request) ; 
    254270      pendingSentChildRequest.push_back(sentRequest) ; 
    255271    } 
  • XIOS/trunk/src/event_scheduler.hpp

    r591 r1638  
    2626        *  @param[in] comm : MPI communicator du duplicate for internal use 
    2727        */ 
    28        CEventScheduler(const MPI_Comm& comm) ; 
     28       CEventScheduler(const ep_lib::MPI_Comm& comm) ; 
    2929 
    3030 
     
    151151       { 
    152152         size_t buffer[3] ;      /*!< communication buffer : timeLine, hashId, level */ 
    153          MPI_Request request ;   /*!< pending MPI request */  
     153         ep_lib::MPI_Request request ;   /*!< pending MPI request */  
    154154       } ; 
    155155        
    156        MPI_Comm communicator ;  /*!< Internal MPI communicator */  
     156       ep_lib::MPI_Comm communicator ;  /*!< Internal MPI communicator */  
    157157       int mpiRank ;            /*!< Rank in the communicator */ 
    158158       int mpiSize ;            /*!< Size of the communicator */ 
  • XIOS/trunk/src/filter/spatial_transform_filter.cpp

    r1637 r1638  
    224224 
    225225      idxSendBuff = 0; 
    226       std::vector<MPI_Request> sendRecvRequest; 
     226      std::vector<ep_lib::MPI_Request> sendRecvRequest; 
    227227      for (itSend = itbSend; itSend != iteSend; ++itSend, ++idxSendBuff) 
    228228      { 
     
    234234          sendBuff[idxSendBuff][idx] = dataCurrentSrc(localIndex_p(idx)); 
    235235        } 
    236         sendRecvRequest.push_back(MPI_Request()); 
    237         MPI_Isend(sendBuff[idxSendBuff], countSize, MPI_DOUBLE, destRank, 12, client->intraComm, &sendRecvRequest.back()); 
     236        sendRecvRequest.push_back(ep_lib::MPI_Request()); 
     237        ep_lib::MPI_Isend(sendBuff[idxSendBuff], countSize, EP_DOUBLE, destRank, 12, client->intraComm, &sendRecvRequest.back()); 
    238238      } 
    239239 
     
    252252        int srcRank = itRecv->first; 
    253253        int countSize = itRecv->second.size(); 
    254         sendRecvRequest.push_back(MPI_Request()); 
    255         MPI_Irecv(recvBuff + currentBuff, countSize, MPI_DOUBLE, srcRank, 12, client->intraComm, &sendRecvRequest.back()); 
     254        sendRecvRequest.push_back(ep_lib::MPI_Request()); 
     255        ep_lib::MPI_Irecv(recvBuff + currentBuff, countSize, EP_DOUBLE, srcRank, 12, client->intraComm, &sendRecvRequest.back()); 
    256256        currentBuff += countSize; 
    257257      } 
    258       std::vector<MPI_Status> status(sendRecvRequest.size()); 
    259       MPI_Waitall(sendRecvRequest.size(), &sendRecvRequest[0], &status[0]); 
     258      std::vector<ep_lib::MPI_Status> status(sendRecvRequest.size()); 
     259      ep_lib::MPI_Waitall(sendRecvRequest.size(), &sendRecvRequest[0], &status[0]); 
    260260 
    261261      dataCurrentDest.resize(*itNbListRecv); 
  • XIOS/trunk/src/interface/c/icdata.cpp

    r1622 r1638  
    6060   { 
    6161      std::string str; 
    62       MPI_Comm local_comm; 
    63       MPI_Comm return_comm; 
     62      ep_lib::MPI_Comm local_comm; 
     63      ep_lib::MPI_Comm return_comm; 
    6464 
    6565      if (!cstr2string(client_id, len_client_id, str)) return; 
    6666 
    6767      int initialized; 
    68       MPI_Initialized(&initialized); 
     68      ep_lib::MPI_Initialized(&initialized); 
     69      #ifdef _usingMPI 
    6970      if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm); 
    7071      else local_comm=MPI_COMM_NULL; 
     72      #elif _usingEP 
     73      if (initialized) local_comm=EP_Comm_f2c(f_local_comm); 
     74      else local_comm=EP_COMM_NULL; 
     75      #endif 
    7176      CXios::initClientSide(str, local_comm, return_comm); 
     77      #ifdef _usingMPI 
    7278      *f_return_comm=MPI_Comm_c2f(return_comm); 
     79      #elif _usingEP 
     80      *f_return_comm=*static_cast<MPI_Fint* >(EP_Comm_c2f(return_comm)); 
     81      #endif 
    7382      CTimer::get("XIOS init").suspend(); 
    7483      CTimer::get("XIOS").suspend(); 
     
    8089   { 
    8190     std::string str; 
    82      MPI_Comm comm; 
     91     ep_lib::MPI_Comm comm; 
    8392 
    8493     if (!cstr2string(context_id, len_context_id, str)) return; 
    8594     CTimer::get("XIOS").resume(); 
    8695     CTimer::get("XIOS init context").resume(); 
     96     #ifdef _usingMPI 
    8797     comm=MPI_Comm_f2c(*f_comm); 
     98     #elif _usingEP 
     99     comm=EP_Comm_f2c(f_comm); 
     100     #endif 
    88101     CClient::registerContext(str, comm); 
    89102     CTimer::get("XIOS init context").suspend(); 
  • XIOS/trunk/src/interface/c/oasis_cinterface.cpp

    r501 r1638  
    2121  } 
    2222 
    23   void oasis_get_localcomm(MPI_Comm& comm) 
     23  void oasis_get_localcomm(ep_lib::MPI_Comm& comm) 
    2424  { 
    25     MPI_Fint f_comm ; 
     25    ep_lib::MPI_Fint f_comm ; 
    2626     
    2727    fxios_oasis_get_localcomm(&f_comm) ; 
    28     comm=MPI_Comm_f2c(f_comm) ; 
     28    //comm=MPI_Comm_f2c(f_comm) ; 
    2929  } 
    3030  
    31   void oasis_get_intracomm(MPI_Comm& comm_client_server,const std::string& server_id) 
     31  void oasis_get_intracomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) 
    3232  { 
    33     MPI_Fint f_comm ; 
     33    ep_lib::MPI_Fint f_comm ; 
    3434     
    3535    fxios_oasis_get_intracomm(&f_comm,server_id.data(),server_id.size()) ; 
    36     comm_client_server=MPI_Comm_f2c(f_comm) ; 
     36    //comm_client_server=MPI_Comm_f2c(f_comm) ; 
    3737  } 
    3838  
    39   void oasis_get_intercomm(MPI_Comm& comm_client_server,const std::string& server_id) 
     39  void oasis_get_intercomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) 
    4040  { 
    41     MPI_Fint f_comm ; 
     41    ep_lib::MPI_Fint f_comm ; 
    4242     
    4343    fxios_oasis_get_intercomm(&f_comm,server_id.data(),server_id.size()) ; 
    44     comm_client_server=MPI_Comm_f2c(f_comm) ; 
     44    //comm_client_server=MPI_Comm_f2c(f_comm) ; 
    4545  } 
    4646} 
  • XIOS/trunk/src/interface/c/oasis_cinterface.hpp

    r501 r1638  
    1010  void fxios_oasis_enddef(void) ; 
    1111  void fxios_oasis_finalize(void) ; 
    12   void fxios_oasis_get_localcomm(MPI_Fint* f_comm) ; 
    13   void fxios_oasis_get_intracomm(MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ; 
    14   void fxios_oasis_get_intercomm(MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ; 
     12  void fxios_oasis_get_localcomm(ep_lib::MPI_Fint* f_comm) ; 
     13  void fxios_oasis_get_intracomm(ep_lib::MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ; 
     14  void fxios_oasis_get_intercomm(ep_lib::MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ; 
    1515} 
    1616  
     
    2020  void oasis_enddef(void) ; 
    2121  void oasis_finalize(void) ; 
    22   void oasis_get_localcomm(MPI_Comm& comm) ; 
    23   void oasis_get_intracomm(MPI_Comm& comm_client_server,const std::string& server_id) ; 
    24   void oasis_get_intercomm(MPI_Comm& comm_client_server,const std::string& server_id) ; 
     22  void oasis_get_localcomm(ep_lib::MPI_Comm& comm) ; 
     23  void oasis_get_intracomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) ; 
     24  void oasis_get_intercomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) ; 
    2525} 
    2626#endif 
  • XIOS/trunk/src/io/inetcdf4.cpp

    r1534 r1638  
    77namespace xios 
    88{ 
    9   CINetCDF4::CINetCDF4(const StdString& filename, const MPI_Comm* comm /*= NULL*/, bool multifile /*= true*/, 
     9  CINetCDF4::CINetCDF4(const StdString& filename, const ep_lib::MPI_Comm* comm /*= NULL*/, bool multifile /*= true*/, 
    1010                       bool readMetaDataPar /*= false*/, const StdString& timeCounterName /*= "time_counter"*/) 
    1111  { 
     
    1414    { 
    1515      int commSize = 0; 
    16       MPI_Comm_size(*comm, &commSize); 
     16      ep_lib::MPI_Comm_size(*comm, &commSize); 
    1717      if (commSize <= 1) 
    1818        comm = NULL; 
     
    2323    // even if Parallel NetCDF ends up being used. 
    2424    if (mpi) 
    25       CNetCdfInterface::openPar(filename, NC_NOWRITE | NC_MPIIO, *comm, MPI_INFO_NULL, this->ncidp); 
     25      CNetCdfInterface::openPar(filename, NC_NOWRITE | NC_MPIIO, *comm, EP_INFO_NULL, this->ncidp); 
    2626    else 
    2727      CNetCdfInterface::open(filename, NC_NOWRITE, this->ncidp); 
  • XIOS/trunk/src/io/inetcdf4.hpp

    r1485 r1638  
    2222    public: 
    2323      /// Constructors /// 
    24       CINetCDF4(const StdString& filename, const MPI_Comm* comm = NULL, bool multifile = true, 
     24      CINetCDF4(const StdString& filename, const ep_lib::MPI_Comm* comm = NULL, bool multifile = true, 
    2525                bool readMetaDataPar = false, const StdString& timeCounterName = "time_counter"); 
    2626 
  • XIOS/trunk/src/io/nc4_data_input.cpp

    r1622 r1638  
    1010namespace xios 
    1111{ 
    12   CNc4DataInput::CNc4DataInput(const StdString& filename, MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/, 
     12  CNc4DataInput::CNc4DataInput(const StdString& filename, ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/, 
    1313                               bool readMetaDataPar /*= false*/, bool ugridConvention /*= false*/, const StdString& timeCounterName /*= "time_counter"*/) 
    1414    : SuperClass() 
  • XIOS/trunk/src/io/nc4_data_input.hpp

    r1486 r1638  
    2323 
    2424    /// Constructors /// 
    25     CNc4DataInput(const StdString& filename, MPI_Comm comm_file, bool multifile, bool isCollective = true, 
     25    CNc4DataInput(const StdString& filename, ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective = true, 
    2626                  bool readMetaDataPar = false, bool ugridConvention = false, const StdString& timeCounterName = "time_counter"); 
    2727    CNc4DataInput(const CNc4DataInput& dataInput);       // Not implemented. 
     
    7070  private: 
    7171    /// Private attributes /// 
    72     MPI_Comm comm_file; 
     72    ep_lib::MPI_Comm comm_file; 
    7373    const StdString filename; 
    7474    bool isCollective; 
  • XIOS/trunk/src/io/nc4_data_output.cpp

    r1637 r1638  
    2828      CNc4DataOutput::CNc4DataOutput 
    2929         (CFile* file, const StdString & filename, bool exist, bool useClassicFormat, bool useCFConvention, 
    30           MPI_Comm comm_file, bool multifile, bool isCollective, const StdString& timeCounterName) 
     30          ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective, const StdString& timeCounterName) 
    3131            : SuperClass() 
    3232            , SuperClassWriter(filename, exist, useClassicFormat, useCFConvention, &comm_file, multifile, timeCounterName) 
  • XIOS/trunk/src/io/nc4_data_output.hpp

    r1542 r1638  
    2727               (CFile* file, const StdString & filename, bool exist, bool useClassicFormat, 
    2828                bool useCFConvention, 
    29                 MPI_Comm comm_file, bool multifile, bool isCollective = true, 
     29                ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective = true, 
    3030                const StdString& timeCounterName = "time_counter"); 
    3131 
     
    117117 
    118118            /// Propriétés privées /// 
    119             MPI_Comm comm_file; 
     119            ep_lib::MPI_Comm comm_file; 
    120120            const StdString filename; 
    121121            std::map<Time, StdSize> timeToRecordCache; 
  • XIOS/trunk/src/io/netCdfInterface.cpp

    r1454 r1638  
    1010#include "netCdfInterface.hpp" 
    1111#include "netCdfException.hpp" 
    12  
     12#include "ep_mpi.hpp" 
    1313namespace xios 
    1414{ 
     
    4747\return Status code 
    4848*/ 
    49 int CNetCdfInterface::createPar(const StdString& fileName, int cMode, MPI_Comm comm, MPI_Info info, int& ncId) 
    50 { 
     49int CNetCdfInterface::createPar(const StdString& fileName, int cMode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId) 
     50{ 
     51  #ifdef _usingMPI 
    5152  int status = xios::nc_create_par(fileName.c_str(), cMode, comm, info, &ncId); 
     53  #elif _usingEP 
     54  int status = xios::nc_create_par(fileName.c_str(), cMode, to_mpi_comm(comm->mpi_comm), to_mpi_info(info), &ncId); 
     55  #endif 
    5256  if (NC_NOERR != status) 
    5357  { 
     
    100104\return Status code 
    101105*/ 
    102 int CNetCdfInterface::openPar(const StdString& fileName, int oMode, MPI_Comm comm, MPI_Info info, int& ncId) 
    103 { 
     106int CNetCdfInterface::openPar(const StdString& fileName, int oMode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId) 
     107{ 
     108  #ifdef _usingMPI 
    104109  int status = xios::nc_open_par(fileName.c_str(), oMode, comm, info, &ncId); 
     110  #elif _usingEP 
     111  int status = xios::nc_open_par(fileName.c_str(), oMode, to_mpi_comm(comm->mpi_comm), to_mpi_info(info), &ncId); 
     112  #endif 
    105113  if (NC_NOERR != status) 
    106114  { 
  • XIOS/trunk/src/io/netCdfInterface.hpp

    r811 r1638  
    3232 
    3333    //! Create a netcdf file on a parallel file system 
    34     static int createPar(const StdString& path, int cmode, MPI_Comm comm, MPI_Info info, int& ncId); 
     34    static int createPar(const StdString& path, int cmode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId); 
    3535 
    3636    //! Open a netcdf file 
     
    3838 
    3939    //! Open a netcdf file 
    40     static int openPar(const StdString& path, int cmode, MPI_Comm comm, MPI_Info info, int& ncId); 
     40    static int openPar(const StdString& path, int cmode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId); 
    4141 
    4242    //! Close a netcdf file 
  • XIOS/trunk/src/io/onetcdf4.cpp

    r1456 r1638  
    1515      CONetCDF4::CONetCDF4(const StdString& filename, bool append, bool useClassicFormat, 
    1616                                                        bool useCFConvention, 
    17                            const MPI_Comm* comm, bool multifile, const StdString& timeCounterName) 
     17                           const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName) 
    1818        : path() 
    1919        , wmpi(false) 
     
    3333 
    3434      void CONetCDF4::initialize(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention,  
    35                                  const MPI_Comm* comm, bool multifile, const StdString& timeCounterName) 
     35                                 const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName) 
    3636      { 
    3737         this->useClassicFormat = useClassicFormat; 
     
    4444         { 
    4545            int commSize = 0; 
    46             MPI_Comm_size(*comm, &commSize); 
     46            ep_lib::MPI_Comm_size(*comm, &commSize); 
    4747            if (commSize <= 1) 
    4848               comm = NULL; 
     
    5858            CTimer::get("Files : create").resume(); 
    5959            if (wmpi) 
    60                CNetCdfInterface::createPar(filename, mode, *comm, MPI_INFO_NULL, this->ncidp); 
     60               CNetCdfInterface::createPar(filename, mode, *comm, EP_INFO_NULL, this->ncidp); 
    6161            else 
    6262               CNetCdfInterface::create(filename, mode, this->ncidp); 
     
    7070            CTimer::get("Files : open").resume(); 
    7171            if (wmpi) 
    72                CNetCdfInterface::openPar(filename, mode, *comm, MPI_INFO_NULL, this->ncidp); 
     72               CNetCdfInterface::openPar(filename, mode, *comm, EP_INFO_NULL, this->ncidp); 
    7373            else 
    7474               CNetCdfInterface::open(filename, mode, this->ncidp); 
  • XIOS/trunk/src/io/onetcdf4.hpp

    r1456 r1638  
    2828            CONetCDF4(const StdString& filename, bool append, bool useClassicFormat = false, 
    2929                          bool useCFConvention = true, 
    30                       const MPI_Comm* comm = NULL, bool multifile = true, 
     30                      const ep_lib::MPI_Comm* comm = NULL, bool multifile = true, 
    3131                      const StdString& timeCounterName = "time_counter"); 
    3232 
     
    3737            /// Initialisation /// 
    3838            void initialize(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention, 
    39                             const MPI_Comm* comm, bool multifile, const StdString& timeCounterName); 
     39                            const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName); 
    4040            void close(void); 
    4141            void sync(void); 
  • XIOS/trunk/src/mpi.hpp

    r501 r1638  
    1111#define OMPI_SKIP_MPICXX 
    1212 
     13#ifdef _usingEP 
     14#include "ep_lib.hpp" 
     15#include "ep_declaration.hpp" 
     16#endif 
     17 
    1318#include <mpi.h> 
    1419 
     20#ifdef _usingMPI 
     21 
     22#define ep_lib   
     23 
     24#define EP_INT MPI_INT 
     25#define EP_FLOAT MPI_FLOAT 
     26#define EP_DOUBLE MPI_DOUBLE 
     27#define EP_CHAR MPI_CHAR 
     28#define EP_LONG MPI_LONG 
     29#define EP_LONG_LONG_INT MPI_LONG_LONG_INT 
     30#define EP_UNSIGNED_LONG  MPI_UNSIGNED_LONG 
     31#define EP_UNSIGNED_CHAR  MPI_UNSIGNED_CHAR 
     32 
     33 
     34#define EP_COMM_WORLD MPI_COMM_WORLD 
     35#define EP_COMM_NULL MPI_COMM_NULL 
     36#define EP_INFO_NULL MPI_INFO_NULL 
     37 
     38#define EP_MAX MPI_MAX 
     39#define EP_MIN MPI_MIN 
     40#define EP_SUM MPI_SUM 
     41#define EP_LOR MPI_LOR 
     42 
    1543#endif 
     44 
     45#endif 
  • XIOS/trunk/src/node/axis.cpp

    r1637 r1638  
    130130     \return the number of indexes written by each server 
    131131   */ 
    132    int CAxis::getNumberWrittenIndexes(MPI_Comm writtenCom) 
     132   int CAxis::getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
    133133   TRY 
    134134   { 
    135135     int writtenSize; 
    136      MPI_Comm_size(writtenCom, &writtenSize); 
     136     ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
    137137     return numberWrittenIndexes_[writtenSize]; 
    138138   } 
     
    143143     \return the total number of indexes written by the servers 
    144144   */ 
    145    int CAxis::getTotalNumberWrittenIndexes(MPI_Comm writtenCom) 
     145   int CAxis::getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
    146146   TRY 
    147147   { 
    148148     int writtenSize; 
    149      MPI_Comm_size(writtenCom, &writtenSize); 
     149     ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
    150150     return totalNumberWrittenIndexes_[writtenSize]; 
    151151   } 
     
    156156     \return the offset of indexes written by each server 
    157157   */ 
    158    int CAxis::getOffsetWrittenIndexes(MPI_Comm writtenCom) 
     158   int CAxis::getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
    159159   TRY 
    160160   { 
    161161     int writtenSize; 
    162      MPI_Comm_size(writtenCom, &writtenSize); 
     162     ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
    163163     return offsetWrittenIndexes_[writtenSize]; 
    164164   } 
    165165   CATCH_DUMP_ATTR 
    166166 
    167    CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom) 
     167   CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom) 
    168168   TRY 
    169169   { 
    170170     int writtenSize; 
    171      MPI_Comm_size(writtenCom, &writtenSize); 
     171     ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
    172172     return compressedIndexToWriteOnServer[writtenSize]; 
    173173   } 
     
    768768  CATCH_DUMP_ATTR 
    769769 
    770   void CAxis::computeWrittenCompressedIndex(MPI_Comm writtenComm) 
     770  void CAxis::computeWrittenCompressedIndex(ep_lib::MPI_Comm writtenComm) 
    771771  TRY 
    772772  { 
    773773    int writtenCommSize; 
    774     MPI_Comm_size(writtenComm, &writtenCommSize); 
     774    ep_lib::MPI_Comm_size(writtenComm, &writtenCommSize); 
    775775    if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end()) 
    776776      return; 
     
    850850      { 
    851851              
    852         MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
    853         MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
     852        ep_lib::MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm); 
     853        ep_lib::MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm); 
    854854        offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize]; 
    855855      } 
  • XIOS/trunk/src/node/axis.hpp

    r1637 r1638  
    6868         const std::set<StdString> & getRelFiles(void) const; 
    6969 
    70          int getNumberWrittenIndexes(MPI_Comm writtenCom); 
    71          int getTotalNumberWrittenIndexes(MPI_Comm writtenCom); 
    72          int getOffsetWrittenIndexes(MPI_Comm writtenCom); 
    73          CArray<int, 1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom); 
     70         int getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom); 
     71         int getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom); 
     72         int getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom); 
     73         CArray<int, 1>& getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom); 
    7474 
    7575         std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, 
     
    113113 
    114114         void computeWrittenIndex(); 
    115          void computeWrittenCompressedIndex(MPI_Comm); 
     115         void computeWrittenCompressedIndex(ep_lib::MPI_Comm); 
    116116         bool hasTransformation(); 
    117117         void solveInheritanceTransformation(); 
  • XIOS/trunk/src/node/context.cpp

    r1622 r1638  
    265265 
    266266   //! Initialize client side 
    267    void CContext::initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer /*= 0*/) 
     267   void CContext::initClient(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtServer /*= 0*/) 
    268268   TRY 
    269269   { 
    270270 
    271271     hasClient = true; 
    272      MPI_Comm intraCommServer, interCommServer; 
     272     ep_lib::MPI_Comm intraCommServer, interCommServer; 
    273273      
    274274 
     
    284284       else 
    285285       { 
    286          MPI_Comm_dup(intraComm, &intraCommServer); 
     286         ep_lib::MPI_Comm_dup(intraComm, &intraCommServer); 
    287287         comms.push_back(intraCommServer); 
    288          MPI_Comm_dup(interComm, &interCommServer); 
     288         ep_lib::MPI_Comm_dup(interComm, &interCommServer); 
    289289         comms.push_back(interCommServer); 
    290290       } 
     
    309309     { 
    310310       clientPrimServer.push_back(new CContextClient(this, intraComm, interComm)); 
    311        MPI_Comm_dup(intraComm, &intraCommServer); 
     311       ep_lib::MPI_Comm_dup(intraComm, &intraCommServer); 
    312312       comms.push_back(intraCommServer); 
    313        MPI_Comm_dup(interComm, &interCommServer); 
     313       ep_lib::MPI_Comm_dup(interComm, &interCommServer); 
    314314       comms.push_back(interCommServer); 
    315315       serverPrimServer.push_back(new CContextServer(this, intraCommServer, interCommServer)); 
     
    383383   CATCH_DUMP_ATTR 
    384384 
    385    void CContext::initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient /*= 0*/) 
     385   void CContext::initServer(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtClient /*= 0*/) 
    386386   TRY 
    387387   { 
     
    402402     registryOut->setPath(contextRegistryId) ; 
    403403 
    404      MPI_Comm intraCommClient, interCommClient; 
     404     ep_lib::MPI_Comm intraCommClient, interCommClient; 
    405405     if (cxtClient) // Attached mode 
    406406     { 
     
    410410     else 
    411411     { 
    412        MPI_Comm_dup(intraComm, &intraCommClient); 
     412       ep_lib::MPI_Comm_dup(intraComm, &intraCommClient); 
    413413       comms.push_back(intraCommClient); 
    414        MPI_Comm_dup(interComm, &interCommClient); 
     414       ep_lib::MPI_Comm_dup(interComm, &interCommClient); 
    415415       comms.push_back(interCommClient); 
    416416     } 
     
    502502 
    503503         //! Free internally allocated communicators 
    504          for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
    505            MPI_Comm_free(&(*it)); 
     504         for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
     505           ep_lib::MPI_Comm_free(&(*it)); 
    506506         comms.clear(); 
    507507 
     
    544544 
    545545         //! Free internally allocated communicators 
    546          for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
    547            MPI_Comm_free(&(*it)); 
     546         for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
     547           ep_lib::MPI_Comm_free(&(*it)); 
    548548         comms.clear(); 
    549549 
     
    560560   TRY 
    561561   { 
    562      for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
    563        MPI_Comm_free(&(*it)); 
     562     for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
     563       ep_lib::MPI_Comm_free(&(*it)); 
    564564     comms.clear(); 
    565565   } 
  • XIOS/trunk/src/node/context.hpp

    r1622 r1638  
    8888      public : 
    8989         // Initialize server or client 
    90          void initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer = 0); 
    91          void initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient = 0); 
     90         void initClient(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtServer = 0); 
     91         void initServer(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtClient = 0); 
    9292         bool isInitialized(void); 
    9393 
     
    263263         StdString idServer_; 
    264264         CGarbageCollector garbageCollector; 
    265          std::list<MPI_Comm> comms; //!< Communicators allocated internally 
     265         std::list<ep_lib::MPI_Comm> comms; //!< Communicators allocated internally 
    266266 
    267267      public: // Some function maybe removed in the near future 
  • XIOS/trunk/src/node/domain.cpp

    r1637 r1638  
    9999     \return the number of indexes written by each server 
    100100   */ 
    101    int CDomain::getNumberWrittenIndexes(MPI_Comm writtenCom) 
     101   int CDomain::getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
    102102   TRY 
    103103   { 
    104104     int writtenSize; 
    105      MPI_Comm_size(writtenCom, &writtenSize); 
     105     ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
    106106     return numberWrittenIndexes_[writtenSize]; 
    107107   } 
     
    112112     \return the total number of indexes written by the servers 
    113113   */ 
    114    int CDomain::getTotalNumberWrittenIndexes(MPI_Comm writtenCom) 
     114   int CDomain::getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
    115115   TRY 
    116116   { 
    117117     int writtenSize; 
    118      MPI_Comm_size(writtenCom, &writtenSize); 
     118     ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
    119119     return totalNumberWrittenIndexes_[writtenSize]; 
    120120   } 
     
    125125     \return the offset of indexes written by each server 
    126126   */ 
    127    int CDomain::getOffsetWrittenIndexes(MPI_Comm writtenCom) 
     127   int CDomain::getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
    128128   TRY 
    129129   { 
    130130     int writtenSize; 
    131      MPI_Comm_size(writtenCom, &writtenSize); 
     131     ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
    132132     return offsetWrittenIndexes_[writtenSize]; 
    133133   } 
    134134   CATCH_DUMP_ATTR 
    135135 
    136    CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom) 
     136   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom) 
    137137   TRY 
    138138   { 
    139139     int writtenSize; 
    140      MPI_Comm_size(writtenCom, &writtenSize); 
     140     ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
    141141     return compressedIndexToWriteOnServer[writtenSize]; 
    142142   } 
     
    690690     int v ; 
    691691     v=ibegin ; 
    692      MPI_Allgather(&v,1,MPI_INT,ibegin_g,1,MPI_INT,client->intraComm) ; 
     692     ep_lib::MPI_Allgather(&v,1,EP_INT,ibegin_g,1,EP_INT,client->intraComm) ; 
    693693     v=jbegin ; 
    694      MPI_Allgather(&v,1,MPI_INT,jbegin_g,1,MPI_INT,client->intraComm) ; 
     694     ep_lib::MPI_Allgather(&v,1,EP_INT,jbegin_g,1,EP_INT,client->intraComm) ; 
    695695     v=ni ; 
    696      MPI_Allgather(&v,1,MPI_INT,ni_g,1,MPI_INT,client->intraComm) ; 
     696     ep_lib::MPI_Allgather(&v,1,EP_INT,ni_g,1,EP_INT,client->intraComm) ; 
    697697     v=nj ; 
    698      MPI_Allgather(&v,1,MPI_INT,nj_g,1,MPI_INT,client->intraComm) ; 
    699  
    700      MPI_Allgatherv(lon.dataFirst(),ni,MPI_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,MPI_DOUBLE,client->intraComm) ; 
    701      MPI_Allgatherv(lat.dataFirst(),nj,MPI_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,MPI_DOUBLE,client->intraComm) ; 
     698     ep_lib::MPI_Allgather(&v,1,EP_INT,nj_g,1,EP_INT,client->intraComm) ; 
     699 
     700     ep_lib::MPI_Allgatherv(lon.dataFirst(),ni,EP_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,EP_DOUBLE,client->intraComm) ; 
     701     ep_lib::MPI_Allgatherv(lat.dataFirst(),nj,EP_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,EP_DOUBLE,client->intraComm) ; 
    702702 
    703703      delete[] ibegin_g ; 
     
    19321932          displs[0] = 0; 
    19331933          int localCount = connectedServerRank_[nbServer].size() ; 
    1934           MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ; 
     1934          ep_lib::MPI_Gather(&localCount, 1, EP_INT, &counts[0], 1, EP_INT, 0, client->intraComm) ; 
    19351935          for (int i = 0; i < clientSize-1; ++i) 
    19361936          { 
     
    19381938          } 
    19391939          std::vector<int> allConnectedServers(displs[clientSize-1]+counts[clientSize-1]); 
    1940           MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm); 
     1940          ep_lib::MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, EP_INT, &allConnectedServers[0], &counts[0], &displs[0], EP_INT, 0, client->intraComm); 
    19411941 
    19421942          if ((allConnectedServers.size() != nbServer) && (rank == 0)) 
     
    20032003   CATCH_DUMP_ATTR 
    20042004 
    2005   void CDomain::computeWrittenCompressedIndex(MPI_Comm writtenComm) 
     2005  void CDomain::computeWrittenCompressedIndex(ep_lib::MPI_Comm writtenComm) 
    20062006  TRY 
    20072007  { 
    20082008    int writtenCommSize; 
    2009     MPI_Comm_size(writtenComm, &writtenCommSize); 
     2009    ep_lib::MPI_Comm_size(writtenComm, &writtenCommSize); 
    20102010    if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end()) 
    20112011      return; 
     
    20642064      { 
    20652065              
    2066         MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
    2067         MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
     2066        ep_lib::MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm); 
     2067        ep_lib::MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm); 
    20682068        offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize]; 
    20692069      } 
  • XIOS/trunk/src/node/domain.hpp

    r1637 r1638  
    9494         bool isWrittenCompressed(const StdString& filename) const; 
    9595          
    96          int getNumberWrittenIndexes(MPI_Comm writtenCom); 
    97          int getTotalNumberWrittenIndexes(MPI_Comm writtenCom); 
    98          int getOffsetWrittenIndexes(MPI_Comm writtenCom); 
    99          CArray<int,1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom); 
     96         int getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom); 
     97         int getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom); 
     98         int getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom); 
     99         CArray<int,1>& getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom); 
    100100 
    101101         std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, bool bufferForWriting = false); 
     
    116116          
    117117         void computeWrittenIndex(); 
    118          void computeWrittenCompressedIndex(MPI_Comm); 
     118         void computeWrittenCompressedIndex(ep_lib::MPI_Comm); 
    119119 
    120120         void AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat, 
  • XIOS/trunk/src/node/field.cpp

    r1637 r1638  
    531531    if (!nstepMaxRead) 
    532532    { 
     533       #ifdef _usingMPI 
    533534       MPI_Allreduce(MPI_IN_PLACE, &nstepMax, 1, MPI_INT, MPI_MAX, context->server->intraComm); 
     535       #elif _usingEP 
     536       ep_lib::MPI_Allreduce(&nstepMax, &nstepMax, 1, EP_INT, EP_MAX, context->server->intraComm); 
     537       #endif 
    534538       nstepMaxRead = true; 
    535539    } 
  • XIOS/trunk/src/node/file.cpp

    r1622 r1638  
    2525   CFile::CFile(void) 
    2626      : CObjectTemplate<CFile>(), CFileAttributes() 
    27       , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL) 
     27      , vFieldGroup(), data_out(), enabledFields(), fileComm(EP_COMM_NULL) 
    2828      , isOpen(false), read_client(0), checkRead(false), allZoneEmpty(false) 
    2929   { 
     
    3434   CFile::CFile(const StdString & id) 
    3535      : CObjectTemplate<CFile>(id), CFileAttributes() 
    36       , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL) 
     36      , vFieldGroup(), data_out(), enabledFields(), fileComm(EP_COMM_NULL) 
    3737      , isOpen(false), read_client(0), checkRead(false), allZoneEmpty(false) 
    3838    { 
     
    307307 
    308308      int color = allZoneEmpty ? 0 : 1; 
    309       MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm); 
    310       if (allZoneEmpty) MPI_Comm_free(&fileComm); 
     309      ep_lib::MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm); 
     310      if (allZoneEmpty) ep_lib::MPI_Comm_free(&fileComm); 
    311311    } 
    312312    CATCH_DUMP_ATTR 
     
    554554         { 
    555555            int commSize, commRank; 
    556             MPI_Comm_size(fileComm, &commSize); 
    557             MPI_Comm_rank(fileComm, &commRank); 
     556            ep_lib::MPI_Comm_size(fileComm, &commSize); 
     557            ep_lib::MPI_Comm_rank(fileComm, &commRank); 
    558558 
    559559            if (server->intraCommSize > 1) 
     
    634634    CContext* context = CContext::getCurrent(); 
    635635    CContextServer* server = context->server; 
    636     MPI_Comm readComm = this->fileComm; 
     636    ep_lib::MPI_Comm readComm = this->fileComm; 
    637637 
    638638    if (!allZoneEmpty) 
     
    677677      { 
    678678        int commSize, commRank; 
    679         MPI_Comm_size(readComm, &commSize); 
    680         MPI_Comm_rank(readComm, &commRank); 
     679        ep_lib::MPI_Comm_size(readComm, &commSize); 
     680        ep_lib::MPI_Comm_rank(readComm, &commRank); 
    681681 
    682682        if (server->intraCommSize > 1) 
     
    722722        isOpen = false; 
    723723       } 
    724       if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm); 
     724      if (fileComm != EP_COMM_NULL) ep_lib::MPI_Comm_free(&fileComm); 
    725725   } 
    726726   CATCH_DUMP_ATTR 
  • XIOS/trunk/src/node/file.hpp

    r1622 r1638  
    175175         int nbAxis, nbDomains; 
    176176         bool isOpen;          
    177          MPI_Comm fileComm; 
     177         ep_lib::MPI_Comm fileComm; 
    178178 
    179179      private: 
  • XIOS/trunk/src/node/grid.cpp

    r1637 r1638  
    661661        { 
    662662          CContextServer* server = CContext::getCurrent()->server;       
    663           MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
    664           MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
     663          ep_lib::MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, EP_INT, EP_SUM, server->intraComm); 
     664          ep_lib::MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, EP_INT, EP_SUM, server->intraComm); 
    665665          offsetWrittenIndexes_ -= numberWrittenIndexes_; 
    666666        } 
     
    856856         displs[0] = 0; 
    857857         int localCount = connectedServerRank_[receiverSize].size() ; 
    858          MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ; 
     858         ep_lib::MPI_Gather(&localCount, 1, EP_INT, &counts[0], 1, EP_INT, 0, client->intraComm) ; 
    859859         for (int i = 0; i < client->clientSize-1; ++i) 
    860860         { 
     
    862862         } 
    863863         std::vector<int> allConnectedServers(displs[client->clientSize-1]+counts[client->clientSize-1]); 
    864          MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm); 
     864         ep_lib::MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, EP_INT, &allConnectedServers[0], &counts[0], &displs[0], EP_INT, 0, client->intraComm); 
    865865 
    866866         if ((allConnectedServers.size() != receiverSize) && (client->clientRank == 0)) 
  • XIOS/trunk/src/node/mesh.cpp

    r1542 r1638  
    414414 * \param [in] bounds_lat Array of boundary latitudes. Its size depends on the element type. 
    415415 */ 
    416   void CMesh::createMeshEpsilon(const MPI_Comm& comm, 
     416  void CMesh::createMeshEpsilon(const ep_lib::MPI_Comm& comm, 
    417417                                const CArray<double, 1>& lonvalue, const CArray<double, 1>& latvalue, 
    418418                                const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat) 
     
    421421    int nvertex = (bounds_lon.numElements() == 0) ? 1 : bounds_lon.rows(); 
    422422    int mpiRank, mpiSize; 
    423     MPI_Comm_rank(comm, &mpiRank); 
    424     MPI_Comm_size(comm, &mpiSize); 
     423    ep_lib::MPI_Comm_rank(comm, &mpiRank); 
     424    ep_lib::MPI_Comm_size(comm, &mpiSize); 
    425425    double prec = 1e-11;  // used in calculations of edge_lon/lat 
    426426 
     
    460460      unsigned long nbEdgesOnProc = nbEdges_; 
    461461      unsigned long nbEdgesAccum; 
    462       MPI_Scan(&nbEdgesOnProc, &nbEdgesAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
     462      ep_lib::MPI_Scan(&nbEdgesOnProc, &nbEdgesAccum, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
    463463      nbEdgesAccum -= nbEdges_; 
    464464 
     
    590590         unsigned long nodeCount = nodeIdx2Idx.size(); 
    591591         unsigned long nodeStart, nbNodes; 
    592          MPI_Scan(&nodeCount, &nodeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
     592         ep_lib::MPI_Scan(&nodeCount, &nodeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
    593593         int nNodes = nodeStart; 
    594          MPI_Bcast(&nNodes, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm); 
     594         ep_lib::MPI_Bcast(&nNodes, 1, EP_UNSIGNED_LONG, mpiSize-1, comm); 
    595595         nbNodesGlo = nNodes; 
    596596 
     
    683683      unsigned long nbFacesOnProc = nbFaces_; 
    684684      unsigned long nbFacesAccum; 
    685       MPI_Scan(&nbFacesOnProc, &nbFacesAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
     685      ep_lib::MPI_Scan(&nbFacesOnProc, &nbFacesAccum, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
    686686      nbFacesAccum -= nbFaces_; 
    687687 
     
    807807 
    808808        unsigned long edgeStart, nbEdges; 
    809         MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
     809        ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
    810810        int nEdges = edgeStart; 
    811         MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm); 
     811        ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm); 
    812812        nbEdgesGlo = nEdges; 
    813813 
     
    10281028        unsigned long edgeCount = edgeIdx2Idx.size(); 
    10291029        unsigned long edgeStart, nbEdges; 
    1030         MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
     1030        ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
    10311031        int nEdges = edgeStart; 
    1032         MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm); 
     1032        ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm); 
    10331033        nbEdgesGlo = nEdges; 
    10341034 
     
    12981298        unsigned long nodeCount = nodeIdx2Idx.size(); 
    12991299        unsigned long nodeStart, nbNodes; 
    1300         MPI_Scan(&nodeCount, &nodeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
     1300        ep_lib::MPI_Scan(&nodeCount, &nodeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
    13011301        int nNodes = nodeStart; 
    1302         MPI_Bcast(&nNodes, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm); 
     1302        ep_lib::MPI_Bcast(&nNodes, 1, EP_UNSIGNED_LONG, mpiSize-1, comm); 
    13031303        nbNodesGlo = nNodes; 
    13041304 
     
    14181418        unsigned long edgeCount = edgeIdx2Idx.size(); 
    14191419        unsigned long edgeStart, nbEdges; 
    1420         MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
     1420        ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
    14211421        int nEdges = edgeStart; 
    1422         MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm); 
     1422        ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm); 
    14231423        nbEdgesGlo = nEdges; 
    14241424 
     
    16141614   */ 
    16151615 
    1616   void CMesh::getGloNghbFacesNodeType(const MPI_Comm& comm, const CArray<int, 1>& face_idx, 
     1616  void CMesh::getGloNghbFacesNodeType(const ep_lib::MPI_Comm& comm, const CArray<int, 1>& face_idx, 
    16171617                               const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat, 
    16181618                               CArray<int, 2>& nghbFaces) 
     
    16231623 
    16241624    int mpiRank, mpiSize; 
    1625     MPI_Comm_rank(comm, &mpiRank); 
    1626     MPI_Comm_size(comm, &mpiSize); 
     1625    ep_lib::MPI_Comm_rank(comm, &mpiRank); 
     1626    ep_lib::MPI_Comm_size(comm, &mpiSize); 
    16271627 
    16281628    // (1) Generating unique node indexes 
     
    17701770   */ 
    17711771 
    1772   void CMesh::getGloNghbFacesEdgeType(const MPI_Comm& comm, const CArray<int, 1>& face_idx, 
     1772  void CMesh::getGloNghbFacesEdgeType(const ep_lib::MPI_Comm& comm, const CArray<int, 1>& face_idx, 
    17731773                               const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat, 
    17741774                               CArray<int, 2>& nghbFaces) 
     
    17791779 
    17801780    int mpiRank, mpiSize; 
    1781     MPI_Comm_rank(comm, &mpiRank); 
    1782     MPI_Comm_size(comm, &mpiSize); 
     1781    ep_lib::MPI_Comm_rank(comm, &mpiRank); 
     1782    ep_lib::MPI_Comm_size(comm, &mpiSize); 
    17831783 
    17841784    // (1) Generating unique node indexes 
     
    19511951   */ 
    19521952 
    1953   void CMesh::getGlobalNghbFaces(const int nghbType, const MPI_Comm& comm, 
     1953  void CMesh::getGlobalNghbFaces(const int nghbType, const ep_lib::MPI_Comm& comm, 
    19541954                                 const CArray<int, 1>& face_idx, 
    19551955                                 const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat, 
  • XIOS/trunk/src/node/mesh.hpp

    r1542 r1638  
    6060                      const CArray<double, 2>&, const CArray<double, 2>& ); 
    6161                         
    62       void createMeshEpsilon(const MPI_Comm&, 
     62      void createMeshEpsilon(const ep_lib::MPI_Comm&, 
    6363                             const CArray<double, 1>&, const CArray<double, 1>&, 
    6464                             const CArray<double, 2>&, const CArray<double, 2>& ); 
    6565 
    66       void getGlobalNghbFaces(const int, const MPI_Comm&, const CArray<int, 1>&, 
     66      void getGlobalNghbFaces(const int, const ep_lib::MPI_Comm&, const CArray<int, 1>&, 
    6767                              const CArray<double, 2>&, const CArray<double, 2>&, 
    6868                              CArray<int, 2>&); 
     
    8787      CClientClientDHTSizet* pNodeGlobalIndex;                    // pointer to a map <nodeHash, nodeIdxGlo> 
    8888      CClientClientDHTSizet* pEdgeGlobalIndex;                    // pointer to a map <edgeHash, edgeIdxGlo> 
    89       void getGloNghbFacesNodeType(const MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&); 
    90       void getGloNghbFacesEdgeType(const MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&); 
     89      void getGloNghbFacesNodeType(const ep_lib::MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&); 
     90      void getGloNghbFacesEdgeType(const ep_lib::MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&); 
    9191      void getLocNghbFacesNodeType(const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&, CArray<int, 1>&); 
    9292      void getLocNghbFacesEdgeType(const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&, CArray<int, 1>&); 
  • XIOS/trunk/src/policy.cpp

    r855 r1638  
    4949//} 
    5050 
    51 DivideAdaptiveComm::DivideAdaptiveComm(const MPI_Comm& mpiComm) 
     51DivideAdaptiveComm::DivideAdaptiveComm(const ep_lib::MPI_Comm& mpiComm) 
    5252  : internalComm_(mpiComm), level_(0), groupBegin_(), nbInGroup_(), computed_(false) 
    5353{ 
     
    6161 
    6262  int mpiSize, mpiRank; 
    63   MPI_Comm_size(internalComm_,&mpiSize); 
    64   MPI_Comm_rank(internalComm_,&mpiRank); 
     63  ep_lib::MPI_Comm_size(internalComm_,&mpiSize); 
     64  ep_lib::MPI_Comm_rank(internalComm_,&mpiRank); 
    6565 
    6666  int maxChild=1; 
  • XIOS/trunk/src/policy.hpp

    r855 r1638  
    3131{ 
    3232protected: 
    33   DivideAdaptiveComm(const MPI_Comm& mpiComm); 
     33  DivideAdaptiveComm(const ep_lib::MPI_Comm& mpiComm); 
    3434 
    3535  void computeMPICommLevel(); 
     
    4141 
    4242protected: 
    43   const MPI_Comm& internalComm_; 
     43  const ep_lib::MPI_Comm& internalComm_; 
    4444  std::vector<std::vector<int> > groupParentsBegin_; 
    4545  std::vector<std::vector<int> > nbInGroupParents_; 
  • XIOS/trunk/src/registry.cpp

    r696 r1638  
    191191  { 
    192192    int rank ; 
    193     MPI_Comm_rank(communicator,&rank); 
     193    ep_lib::MPI_Comm_rank(communicator,&rank); 
    194194    if (rank==0) 
    195195    { 
     
    197197      this->toBuffer(buffer) ; 
    198198      int size=buffer.count() ; 
    199       MPI_Bcast(&size,1,MPI_INT,0,communicator) ; 
    200       MPI_Bcast(buffer.start(),size,MPI_CHAR,0,communicator) ; 
     199      ep_lib::MPI_Bcast(&size,1,EP_INT,0,communicator) ; 
     200      ep_lib::MPI_Bcast(buffer.start(),size,EP_CHAR,0,communicator) ; 
    201201    } 
    202202    else 
    203203    { 
    204204      int size ; 
    205       MPI_Bcast(&size,1,MPI_INT,0,communicator) ; 
     205      ep_lib::MPI_Bcast(&size,1,EP_INT,0,communicator) ; 
    206206      CBufferIn buffer(size) ; 
    207       MPI_Bcast(buffer.start(),size,MPI_CHAR,0,communicator) ; 
     207      ep_lib::MPI_Bcast(buffer.start(),size,EP_CHAR,0,communicator) ; 
    208208      this->fromBuffer(buffer) ; 
    209209    } 
     
    214214  } 
    215215 
    216   void CRegistry::gatherRegistry(const MPI_Comm& comm) 
     216  void CRegistry::gatherRegistry(const ep_lib::MPI_Comm& comm) 
    217217  { 
    218218    int rank,mpiSize ; 
    219     MPI_Comm_rank(comm,&rank); 
    220     MPI_Comm_size(comm,&mpiSize); 
     219    ep_lib::MPI_Comm_rank(comm,&rank); 
     220    ep_lib::MPI_Comm_size(comm,&mpiSize); 
    221221 
    222222    int* sizes=new int[mpiSize] ; 
     
    224224    this->toBuffer(localBuffer) ; 
    225225    int localSize=localBuffer.count() ; 
    226     MPI_Gather(&localSize,1,MPI_INT,sizes,1,MPI_INT,0,comm) ; 
     226    ep_lib::MPI_Gather(&localSize,1,EP_INT,sizes,1,EP_INT,0,comm) ; 
    227227 
    228228    char* globalBuffer ; 
     
    240240 
    241241      globalBuffer=new char[globalBufferSize] ; 
    242       MPI_Gatherv(localBuffer.start(),localSize,MPI_CHAR,globalBuffer,sizes,displs,MPI_CHAR,0,comm) ; 
     242      ep_lib::MPI_Gatherv(localBuffer.start(),localSize,EP_CHAR,globalBuffer,sizes,displs,EP_CHAR,0,comm) ; 
    243243      for(int i=1;i<mpiSize;++i) 
    244244      { 
     
    251251      delete[] globalBuffer ; 
    252252    } 
    253     else  MPI_Gatherv(localBuffer.start(),localSize,MPI_CHAR,globalBuffer,sizes,displs,MPI_CHAR,0,comm) ;    
     253    else  ep_lib::MPI_Gatherv(localBuffer.start(),localSize,EP_CHAR,globalBuffer,sizes,displs,EP_CHAR,0,comm) ;    
    254254    delete[] sizes ; 
    255255     
     
    261261  } 
    262262 
    263   void CRegistry::hierarchicalGatherRegistry(const MPI_Comm& comm) 
     263  void CRegistry::hierarchicalGatherRegistry(const ep_lib::MPI_Comm& comm) 
    264264  { 
    265265    int mpiRank,mpiSize ; 
    266     MPI_Comm_rank(comm,&mpiRank); 
    267     MPI_Comm_size(comm,&mpiSize);     
     266    ep_lib::MPI_Comm_rank(comm,&mpiRank); 
     267    ep_lib::MPI_Comm_size(comm,&mpiSize);     
    268268 
    269269    if (mpiSize>2) 
     
    272272      if (mpiRank<mpiSize/2+mpiSize%2) color=0 ; 
    273273      else color=1 ; 
    274       MPI_Comm commUp ; 
    275       MPI_Comm_split(comm,color,mpiRank,&commUp) , 
     274      ep_lib::MPI_Comm commUp ; 
     275      ep_lib::MPI_Comm_split(comm,color,mpiRank,&commUp) , 
    276276      hierarchicalGatherRegistry(commUp) ; 
    277       MPI_Comm_free(&commUp) ; 
     277      ep_lib::MPI_Comm_free(&commUp) ; 
    278278    } 
    279279 
    280280    if (mpiSize>1) 
    281281    { 
    282       MPI_Comm commDown ; 
     282      ep_lib::MPI_Comm commDown ; 
    283283      int color ; 
    284284       
    285285      if (mpiRank==0 || mpiRank==mpiSize/2+mpiSize%2) color=0 ; 
    286286      else color=1 ; 
    287       MPI_Comm_split(comm,color,mpiRank,&commDown) ; 
     287      ep_lib::MPI_Comm_split(comm,color,mpiRank,&commDown) ; 
    288288      if (color==0) gatherRegistry(commDown) ; 
    289       MPI_Comm_free(&commDown) ;     
     289      ep_lib::MPI_Comm_free(&commDown) ;     
    290290    } 
    291291  } 
  • XIOS/trunk/src/registry.hpp

    r700 r1638  
    2323 
    2424/** Constructor, the communicator is used for bcast or gather operation between MPI processes */ 
    25       CRegistry(const MPI_Comm& comm=MPI_COMM_WORLD) : communicator(comm) {} 
     25      CRegistry(const ep_lib::MPI_Comm& comm=EP_COMM_WORLD) : communicator(comm) {} 
    2626 
    2727/** Copy constructor */ 
     
    106106 
    107107/** use internally for recursivity */ 
    108       void gatherRegistry(const MPI_Comm& comm) ; 
     108      void gatherRegistry(const ep_lib::MPI_Comm& comm) ; 
    109109 
    110110/** use internally for recursivity */ 
    111       void hierarchicalGatherRegistry(const MPI_Comm& comm) ; 
     111      void hierarchicalGatherRegistry(const ep_lib::MPI_Comm& comm) ; 
    112112 
    113113 
     
    120120 
    121121/** MPI communicator used for broadcast and gather operation */ 
    122       MPI_Comm communicator ; 
     122      ep_lib::MPI_Comm communicator ; 
    123123  } ; 
    124124 
  • XIOS/trunk/src/server.cpp

    r1587 r1638  
    1818namespace xios 
    1919{ 
    20     MPI_Comm CServer::intraComm ; 
    21     std::list<MPI_Comm> CServer::interCommLeft ; 
    22     std::list<MPI_Comm> CServer::interCommRight ; 
    23     std::list<MPI_Comm> CServer::contextInterComms; 
    24     std::list<MPI_Comm> CServer::contextIntraComms; 
     20    ep_lib::MPI_Comm CServer::intraComm ; 
     21    std::list<ep_lib::MPI_Comm> CServer::interCommLeft ; 
     22    std::list<ep_lib::MPI_Comm> CServer::interCommRight ; 
     23    std::list<ep_lib::MPI_Comm> CServer::contextInterComms; 
     24    std::list<ep_lib::MPI_Comm> CServer::contextIntraComms; 
    2525    int CServer::serverLevel = 0 ; 
    2626    int CServer::nbContexts = 0; 
     
    4848    { 
    4949      int initialized ; 
    50       MPI_Initialized(&initialized) ; 
     50      ep_lib::MPI_Initialized(&initialized) ; 
    5151      if (initialized) is_MPI_Initialized=true ; 
    5252      else is_MPI_Initialized=false ; 
     
    5959        if (!is_MPI_Initialized) 
    6060        { 
    61           MPI_Init(NULL, NULL); 
     61          ep_lib::MPI_Init(NULL, NULL); 
    6262        } 
    6363        CTimer::get("XIOS").resume() ; 
     
    7272        int myColor ; 
    7373        int i,c ; 
    74         MPI_Comm newComm; 
    75  
    76         MPI_Comm_size(CXios::globalComm, &size) ; 
    77         MPI_Comm_rank(CXios::globalComm, &rank_); 
     74        ep_lib::MPI_Comm newComm; 
     75 
     76        ep_lib::MPI_Comm_size(CXios::globalComm, &size) ; 
     77        ep_lib::MPI_Comm_rank(CXios::globalComm, &rank_); 
    7878 
    7979        hashAll=new unsigned long[size] ; 
    80         MPI_Allgather(&hashServer, 1, MPI_LONG, hashAll, 1, MPI_LONG, CXios::globalComm) ; 
     80        ep_lib::MPI_Allgather(&hashServer, 1, EP_LONG, hashAll, 1, EP_LONG, CXios::globalComm) ; 
    8181 
    8282        map<unsigned long, int> colors ; 
     
    174174        // (2) Create intraComm 
    175175        if (serverLevel != 2) myColor=colors[hashServer]; 
    176         MPI_Comm_split(CXios::globalComm, myColor, rank_, &intraComm) ; 
     176        ep_lib::MPI_Comm_split(CXios::globalComm, myColor, rank_, &intraComm) ; 
    177177 
    178178        // (3) Create interComm 
     
    186186              clientLeader=it->second ; 
    187187              int intraCommSize, intraCommRank ; 
    188               MPI_Comm_size(intraComm,&intraCommSize) ; 
    189               MPI_Comm_rank(intraComm,&intraCommRank) ; 
     188              ep_lib::MPI_Comm_size(intraComm,&intraCommSize) ; 
     189              ep_lib::MPI_Comm_rank(intraComm,&intraCommRank) ; 
    190190              info(50)<<"intercommCreate::server (classical mode) "<<rank_<<" intraCommSize : "<<intraCommSize 
    191191                       <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ; 
    192192 
    193               MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ; 
     193              ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ; 
    194194              interCommLeft.push_back(newComm) ; 
    195195            } 
     
    207207              clientLeader=it->second ; 
    208208              int intraCommSize, intraCommRank ; 
    209               MPI_Comm_size(intraComm, &intraCommSize) ; 
    210               MPI_Comm_rank(intraComm, &intraCommRank) ; 
     209              ep_lib::MPI_Comm_size(intraComm, &intraCommSize) ; 
     210              ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ; 
    211211              info(50)<<"intercommCreate::server (server level 1) "<<rank_<<" intraCommSize : "<<intraCommSize 
    212212                       <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ; 
    213               MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ; 
     213              ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ; 
    214214              interCommLeft.push_back(newComm) ; 
    215215            } 
     
    219219          { 
    220220            int intraCommSize, intraCommRank ; 
    221             MPI_Comm_size(intraComm, &intraCommSize) ; 
    222             MPI_Comm_rank(intraComm, &intraCommRank) ; 
     221            ep_lib::MPI_Comm_size(intraComm, &intraCommSize) ; 
     222            ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ; 
    223223            info(50)<<"intercommCreate::client (server level 1) "<<rank_<<" intraCommSize : "<<intraCommSize 
    224224                <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< sndServerGlobalRanks[i]<<endl ; 
    225             MPI_Intercomm_create(intraComm, 0, CXios::globalComm, sndServerGlobalRanks[i], 1, &newComm) ; 
     225            ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, sndServerGlobalRanks[i], 1, &newComm) ; 
    226226            interCommRight.push_back(newComm) ; 
    227227          } 
     
    232232          clientLeader = leaders[hashString(CXios::xiosCodeId)]; 
    233233          int intraCommSize, intraCommRank ; 
    234           MPI_Comm_size(intraComm, &intraCommSize) ; 
    235           MPI_Comm_rank(intraComm, &intraCommRank) ; 
     234          ep_lib::MPI_Comm_size(intraComm, &intraCommSize) ; 
     235          ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ; 
    236236          info(50)<<"intercommCreate::server (server level 2) "<<rank_<<" intraCommSize : "<<intraCommSize 
    237237                   <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ; 
    238238 
    239           MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 1, &newComm) ; 
     239          ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 1, &newComm) ; 
    240240          interCommLeft.push_back(newComm) ; 
    241241        } 
     
    253253 
    254254        CTimer::get("XIOS").resume() ; 
    255         MPI_Comm localComm; 
     255        ep_lib::MPI_Comm localComm; 
    256256        oasis_get_localcomm(localComm); 
    257         MPI_Comm_rank(localComm,&rank_) ; 
     257        ep_lib::MPI_Comm_rank(localComm,&rank_) ; 
    258258 
    259259//      (1) Create server intraComm 
    260260        if (!CXios::usingServer2) 
    261261        { 
    262           MPI_Comm_dup(localComm, &intraComm); 
     262          ep_lib::MPI_Comm_dup(localComm, &intraComm); 
    263263        } 
    264264        else 
    265265        { 
    266266          int globalRank; 
    267           MPI_Comm_size(localComm,&size) ; 
    268           MPI_Comm_rank(CXios::globalComm,&globalRank) ; 
     267          ep_lib::MPI_Comm_size(localComm,&size) ; 
     268          ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank) ; 
    269269          srvGlobalRanks = new int[size] ; 
    270           MPI_Allgather(&globalRank, 1, MPI_INT, srvGlobalRanks, 1, MPI_INT, localComm) ; 
     270          ep_lib::MPI_Allgather(&globalRank, 1, EP_INT, srvGlobalRanks, 1, EP_INT, localComm) ; 
    271271 
    272272          int reqNbProc = size*CXios::ratioServer2/100.; 
     
    276276                << "It is impossible to dedicate the requested number of processes = "<<reqNbProc 
    277277                <<" to secondary server. XIOS will run in the classical server mode."<<endl; 
    278             MPI_Comm_dup(localComm, &intraComm); 
     278            ep_lib::MPI_Comm_dup(localComm, &intraComm); 
    279279          } 
    280280          else 
     
    339339            } 
    340340            if (serverLevel != 2) myColor=0; 
    341             MPI_Comm_split(localComm, myColor, rank_, &intraComm) ; 
     341            ep_lib::MPI_Comm_split(localComm, myColor, rank_, &intraComm) ; 
    342342          } 
    343343        } 
     
    348348        vector<string>::iterator it ; 
    349349 
    350         MPI_Comm newComm ; 
     350        ep_lib::MPI_Comm newComm ; 
    351351        int globalRank ; 
    352         MPI_Comm_rank(CXios::globalComm,&globalRank); 
     352        ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank); 
    353353 
    354354//      (2) Create interComms with models 
     
    359359          { 
    360360            interCommLeft.push_back(newComm) ; 
    361             if (rank_==0) MPI_Send(&globalRank,1,MPI_INT,0,0,newComm) ; 
     361            if (rank_==0) ep_lib::MPI_Send(&globalRank,1,EP_INT,0,0,newComm) ; 
    362362          } 
    363363        } 
     
    365365//      (3) Create interComms between primary and secondary servers 
    366366        int intraCommSize, intraCommRank ; 
    367         MPI_Comm_size(intraComm,&intraCommSize) ; 
    368         MPI_Comm_rank(intraComm, &intraCommRank) ; 
     367        ep_lib::MPI_Comm_size(intraComm,&intraCommSize) ; 
     368        ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ; 
    369369 
    370370        if (serverLevel == 1) 
     
    375375            info(50)<<"intercommCreate::client (server level 1) "<<globalRank<<" intraCommSize : "<<intraCommSize 
    376376                <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< srvSndLeader<<endl ; 
    377             MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvSndLeader, 0, &newComm) ; 
     377            ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvSndLeader, 0, &newComm) ; 
    378378            interCommRight.push_back(newComm) ; 
    379379          } 
     
    383383          info(50)<<"intercommCreate::server (server level 2)"<<globalRank<<" intraCommSize : "<<intraCommSize 
    384384                   <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< srvGlobalRanks[0] <<endl ; 
    385           MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvGlobalRanks[0], 0, &newComm) ; 
     385          ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvGlobalRanks[0], 0, &newComm) ; 
    386386          interCommLeft.push_back(newComm) ; 
    387387        } 
     
    393393 
    394394 
    395       MPI_Comm_rank(intraComm, &rank) ; 
     395      ep_lib::MPI_Comm_rank(intraComm, &rank) ; 
    396396      if (rank==0) isRoot=true; 
    397397      else isRoot=false; 
     
    406406      delete eventScheduler ; 
    407407 
    408       for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++) 
    409         MPI_Comm_free(&(*it)); 
    410  
    411       for (std::list<MPI_Comm>::iterator it = contextIntraComms.begin(); it != contextIntraComms.end(); it++) 
    412         MPI_Comm_free(&(*it)); 
     408      for (std::list<ep_lib::MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++) 
     409        ep_lib::MPI_Comm_free(&(*it)); 
     410 
     411      for (std::list<ep_lib::MPI_Comm>::iterator it = contextIntraComms.begin(); it != contextIntraComms.end(); it++) 
     412        ep_lib::MPI_Comm_free(&(*it)); 
    413413 
    414414//      for (std::list<MPI_Comm>::iterator it = interComm.begin(); it != interComm.end(); it++) 
     
    418418//          MPI_Comm_free(&(*it)); 
    419419 
    420         for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++) 
    421           MPI_Comm_free(&(*it)); 
    422  
    423       MPI_Comm_free(&intraComm); 
     420        for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++) 
     421          ep_lib::MPI_Comm_free(&(*it)); 
     422 
     423      ep_lib::MPI_Comm_free(&intraComm); 
    424424 
    425425      if (!is_MPI_Initialized) 
    426426      { 
    427427        if (CXios::usingOasis) oasis_finalize(); 
    428         else MPI_Finalize() ; 
     428        else ep_lib::MPI_Finalize() ; 
    429429      } 
    430430      report(0)<<"Performance report : Time spent for XIOS : "<<CTimer::get("XIOS server").getCumulatedTime()<<endl  ; 
     
    465465     void CServer::listenFinalize(void) 
    466466     { 
    467         list<MPI_Comm>::iterator it, itr; 
     467        list<ep_lib::MPI_Comm>::iterator it, itr; 
    468468        int msg ; 
    469469        int flag ; 
     
    471471        for(it=interCommLeft.begin();it!=interCommLeft.end();it++) 
    472472        { 
    473            MPI_Status status ; 
     473           ep_lib::MPI_Status status ; 
    474474           traceOff() ; 
    475            MPI_Iprobe(0,0,*it,&flag,&status) ; 
     475           ep_lib::MPI_Iprobe(0,0,*it,&flag,&status) ; 
    476476           traceOn() ; 
    477477           if (flag==true) 
    478478           { 
    479               MPI_Recv(&msg,1,MPI_INT,0,0,*it,&status) ; 
     479              ep_lib::MPI_Recv(&msg,1,EP_INT,0,0,*it,&status) ; 
    480480              info(20)<<" CServer : Receive client finalize"<<endl ; 
    481481              // Sending server finalize message to secondary servers (if any) 
    482482              for(itr=interCommRight.begin();itr!=interCommRight.end();itr++) 
    483483              { 
    484                 MPI_Send(&msg,1,MPI_INT,0,0,*itr) ; 
     484                ep_lib::MPI_Send(&msg,1,EP_INT,0,0,*itr) ; 
    485485              } 
    486               MPI_Comm_free(&(*it)); 
     486              ep_lib::MPI_Comm_free(&(*it)); 
    487487              interCommLeft.erase(it) ; 
    488488              break ; 
     
    493493         { 
    494494           int i,size ; 
    495            MPI_Comm_size(intraComm,&size) ; 
    496            MPI_Request* requests= new MPI_Request[size-1] ; 
    497            MPI_Status* status= new MPI_Status[size-1] ; 
    498  
    499            for(int i=1;i<size;i++) MPI_Isend(&msg,1,MPI_INT,i,4,intraComm,&requests[i-1]) ; 
    500            MPI_Waitall(size-1,requests,status) ; 
     495           ep_lib::MPI_Comm_size(intraComm,&size) ; 
     496           ep_lib::MPI_Request* requests= new ep_lib::MPI_Request[size-1] ; 
     497           ep_lib::MPI_Status* status= new ep_lib::MPI_Status[size-1] ; 
     498 
     499           for(int i=1;i<size;i++) ep_lib::MPI_Isend(&msg,1,EP_INT,i,4,intraComm,&requests[i-1]) ; 
     500           ep_lib::MPI_Waitall(size-1,requests,status) ; 
    501501 
    502502           finished=true ; 
     
    510510     { 
    511511        int flag ; 
    512         MPI_Status status ; 
     512        ep_lib::MPI_Status status ; 
    513513        int msg ; 
    514514 
    515515        traceOff() ; 
    516         MPI_Iprobe(0,4,intraComm, &flag, &status) ; 
     516        ep_lib::MPI_Iprobe(0,4,intraComm, &flag, &status) ; 
    517517        traceOn() ; 
    518518        if (flag==true) 
    519519        { 
    520            MPI_Recv(&msg,1,MPI_INT,0,4,intraComm,&status) ; 
     520           ep_lib::MPI_Recv(&msg,1,EP_INT,0,4,intraComm,&status) ; 
    521521           finished=true ; 
    522522        } 
     
    534534     { 
    535535        int flag ; 
    536         MPI_Status status ; 
    537         list<MPI_Comm>::iterator it; 
     536        ep_lib::MPI_Status status ; 
     537        list<ep_lib::MPI_Comm>::iterator it; 
    538538        int msg ; 
    539539        static int nbCompound=0 ; 
    540540        int size ; 
    541541        static bool sent=false ; 
    542         static MPI_Request* allRequests ; 
    543         static MPI_Status* allStatus ; 
     542        static ep_lib::MPI_Request* allRequests ; 
     543        static ep_lib::MPI_Status* allStatus ; 
    544544 
    545545 
    546546        if (sent) 
    547547        { 
    548           MPI_Comm_size(intraComm,&size) ; 
    549           MPI_Testall(size,allRequests, &flag, allStatus) ; 
     548          ep_lib::MPI_Comm_size(intraComm,&size) ; 
     549          ep_lib::MPI_Testall(size,allRequests, &flag, allStatus) ; 
    550550          if (flag==true) 
    551551          { 
     
    559559        for(it=interCommLeft.begin();it!=interCommLeft.end();it++) 
    560560        { 
    561            MPI_Status status ; 
     561           ep_lib::MPI_Status status ; 
    562562           traceOff() ; 
    563            MPI_Iprobe(0,5,*it,&flag,&status) ;  // tags oasis_endded = 5 
     563           ep_lib::MPI_Iprobe(0,5,*it,&flag,&status) ;  // tags oasis_endded = 5 
    564564           traceOn() ; 
    565565           if (flag==true) 
    566566           { 
    567               MPI_Recv(&msg,1,MPI_INT,0,5,*it,&status) ; // tags oasis_endded = 5 
     567              ep_lib::MPI_Recv(&msg,1,EP_INT,0,5,*it,&status) ; // tags oasis_endded = 5 
    568568              nbCompound++ ; 
    569569              if (nbCompound==interCommLeft.size()) 
    570570              { 
    571                 for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++) 
     571                for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++) 
    572572                { 
    573                    MPI_Send(&msg,1,MPI_INT,0,5,*it) ; // tags oasis_endded = 5 
     573                   ep_lib::MPI_Send(&msg,1,EP_INT,0,5,*it) ; // tags oasis_endded = 5 
    574574                } 
    575                 MPI_Comm_size(intraComm,&size) ; 
    576                 allRequests= new MPI_Request[size] ; 
    577                 allStatus= new MPI_Status[size] ; 
    578                 for(int i=0;i<size;i++) MPI_Isend(&msg,1,MPI_INT,i,5,intraComm,&allRequests[i]) ; // tags oasis_endded = 5 
     575                ep_lib::MPI_Comm_size(intraComm,&size) ; 
     576                allRequests= new ep_lib::MPI_Request[size] ; 
     577                allStatus= new ep_lib::MPI_Status[size] ; 
     578                for(int i=0;i<size;i++) ep_lib::MPI_Isend(&msg,1,EP_INT,i,5,intraComm,&allRequests[i]) ; // tags oasis_endded = 5 
    579579                sent=true ; 
    580580              } 
     
    590590     { 
    591591       int flag ; 
    592        MPI_Status status ; 
     592       ep_lib::MPI_Status status ; 
    593593       const int root=0 ; 
    594594       int msg ; 
     
    607607          
    608608       traceOff() ; 
    609        MPI_Iprobe(root,5,intraComm, &flag, &status) ; 
     609       ep_lib::MPI_Iprobe(root,5,intraComm, &flag, &status) ; 
    610610       traceOn() ; 
    611611       if (flag==true) 
    612612       { 
    613          MPI_Recv(&msg,1,MPI_INT,root,5,intraComm,&status) ; // tags oasis_endded = 5 
     613         ep_lib::MPI_Recv(&msg,1,EP_INT,root,5,intraComm,&status) ; // tags oasis_endded = 5 
    614614         boost::hash<string> hashString; 
    615615         size_t hashId = hashString("oasis_enddef"); 
     
    626626     { 
    627627 
    628        MPI_Status status ; 
     628       ep_lib::MPI_Status status ; 
    629629       int flag ; 
    630630       static char* buffer ; 
    631        static MPI_Request request ; 
     631       static ep_lib::MPI_Request request ; 
    632632       static bool recept=false ; 
    633633       int rank ; 
     
    637637       { 
    638638         traceOff() ; 
    639          MPI_Iprobe(MPI_ANY_SOURCE,1,CXios::globalComm, &flag, &status) ; 
     639         #ifdef _usingMPI 
     640         ep_lib::MPI_Iprobe(MPI_ANY_SOURCE,1,CXios::globalComm, &flag, &status) ; 
     641         #elif _usingEP 
     642         ep_lib::MPI_Iprobe(-2,1,CXios::globalComm, &flag, &status) ; 
     643         #endif 
    640644         traceOn() ; 
    641645         if (flag==true) 
    642646         { 
     647           #ifdef _usingMPI 
    643648           rank=status.MPI_SOURCE ; 
    644            MPI_Get_count(&status,MPI_CHAR,&count) ; 
     649           #elif _usingEP 
     650           rank=status.ep_src ; 
     651           #endif 
     652           ep_lib::MPI_Get_count(&status,EP_CHAR,&count) ; 
    645653           buffer=new char[count] ; 
    646            MPI_Irecv((void*)buffer,count,MPI_CHAR,rank,1,CXios::globalComm,&request) ; 
     654           ep_lib::MPI_Irecv((void*)buffer,count,EP_CHAR,rank,1,CXios::globalComm,&request) ; 
    647655           recept=true ; 
    648656         } 
     
    651659       { 
    652660         traceOff() ; 
    653          MPI_Test(&request,&flag,&status) ; 
     661         ep_lib::MPI_Test(&request,&flag,&status) ; 
    654662         traceOn() ; 
    655663         if (flag==true) 
    656664         { 
     665           #ifdef _usingMPI 
    657666           rank=status.MPI_SOURCE ; 
    658            MPI_Get_count(&status,MPI_CHAR,&count) ; 
     667           #elif _usingEP 
     668           rank=status.ep_src ; 
     669           #endif 
     670           ep_lib::MPI_Get_count(&status,EP_CHAR,&count) ; 
    659671           recvContextMessage((void*)buffer,count) ; 
    660672           delete [] buffer ; 
     
    689701       { 
    690702         int size ; 
    691          MPI_Comm_size(intraComm,&size) ; 
     703         ep_lib::MPI_Comm_size(intraComm,&size) ; 
    692704//         MPI_Request* requests= new MPI_Request[size-1] ; 
    693705//         MPI_Status* status= new MPI_Status[size-1] ; 
    694          MPI_Request* requests= new MPI_Request[size] ; 
    695          MPI_Status* status= new MPI_Status[size] ; 
     706         ep_lib::MPI_Request* requests= new ep_lib::MPI_Request[size] ; 
     707         ep_lib::MPI_Status* status= new ep_lib::MPI_Status[size] ; 
    696708 
    697709         CMessage msg ; 
     
    705717         for(int i=0; i<size; i++) 
    706718         { 
    707            MPI_Isend(sendBuff,sendBuffer.count(),MPI_CHAR,i,2,intraComm,&requests[i]) ; 
     719           ep_lib::MPI_Isend(sendBuff,sendBuffer.count(),EP_CHAR,i,2,intraComm,&requests[i]) ; 
    708720         } 
    709721 
     
    717729     void CServer::listenRootContext(void) 
    718730     { 
    719        MPI_Status status ; 
     731       ep_lib::MPI_Status status ; 
    720732       int flag ; 
    721733       static std::vector<void*> buffers; 
    722        static std::vector<MPI_Request> requests ; 
     734       static std::vector<ep_lib::MPI_Request> requests ; 
    723735       static std::vector<int> counts ; 
    724736       static std::vector<bool> isEventRegistered ; 
    725737       static std::vector<bool> isEventQueued ; 
    726        MPI_Request request; 
     738       ep_lib::MPI_Request request; 
    727739 
    728740       int rank ; 
     
    733745       // (1) Receive context id from the root, save it into a buffer 
    734746       traceOff() ; 
    735        MPI_Iprobe(root,2,intraComm, &flag, &status) ; 
     747       ep_lib::MPI_Iprobe(root,2,intraComm, &flag, &status) ; 
    736748       traceOn() ; 
    737749       if (flag==true) 
    738750       { 
    739751         counts.push_back(0); 
    740          MPI_Get_count(&status,MPI_CHAR,&(counts.back())) ; 
     752         ep_lib::MPI_Get_count(&status,EP_CHAR,&(counts.back())) ; 
    741753         buffers.push_back(new char[counts.back()]) ; 
    742754         requests.push_back(request); 
    743          MPI_Irecv((void*)(buffers.back()),counts.back(),MPI_CHAR,root,2,intraComm,&(requests.back())) ; 
     755         ep_lib::MPI_Irecv((void*)(buffers.back()),counts.back(),EP_CHAR,root,2,intraComm,&(requests.back())) ; 
    744756         isEventRegistered.push_back(false); 
    745757         isEventQueued.push_back(false); 
     
    750762       { 
    751763         // (2) If context id is received, register an event 
    752          MPI_Test(&requests[ctxNb],&flag,&status) ; 
     764         ep_lib::MPI_Test(&requests[ctxNb],&flag,&status) ; 
    753765         if (flag==true && !isEventRegistered[ctxNb]) 
    754766         { 
     
    787799       // (1) create interComm (with a client) 
    788800       // (2) initialize client and server (contextClient and contextServer) 
    789        MPI_Comm inter; 
     801       ep_lib::MPI_Comm inter; 
    790802       if (serverLevel < 2) 
    791803       { 
    792          MPI_Comm contextInterComm; 
    793          MPI_Intercomm_create(intraComm, 0, CXios::globalComm, leaderRank, 10+leaderRank, &contextInterComm); 
    794          MPI_Intercomm_merge(contextInterComm,1,&inter); 
    795          MPI_Barrier(inter); 
    796          MPI_Comm_free(&inter); 
     804         ep_lib::MPI_Comm contextInterComm; 
     805         ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, leaderRank, 10+leaderRank, &contextInterComm); 
     806         ep_lib::MPI_Intercomm_merge(contextInterComm,1,&inter); 
     807         ep_lib::MPI_Barrier(inter); 
     808         ep_lib::MPI_Comm_free(&inter); 
    797809         context->initServer(intraComm,contextInterComm); 
    798810         contextInterComms.push_back(contextInterComm); 
     
    807819       else if (serverLevel == 2) 
    808820       { 
    809          MPI_Comm_dup(interCommLeft.front(), &inter); 
     821         ep_lib::MPI_Comm_dup(interCommLeft.front(), &inter); 
    810822         contextInterComms.push_back(inter); 
    811823         context->initServer(intraComm, contextInterComms.back()); 
     
    818830       { 
    819831         int i = 0, size; 
    820          MPI_Comm_size(intraComm, &size) ; 
    821          for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++, ++i) 
     832         ep_lib::MPI_Comm_size(intraComm, &size) ; 
     833         for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++, ++i) 
    822834         { 
    823835           StdString str = contextId +"_server_" + boost::lexical_cast<string>(i); 
     
    829841           CBufferOut buffer(buff,messageSize) ; 
    830842           buffer<<msg ; 
    831            MPI_Send(buff, buffer.count(), MPI_CHAR, sndServerGlobalRanks[i], 1, CXios::globalComm) ; 
    832            MPI_Comm_dup(*it, &inter); 
     843           ep_lib::MPI_Send(buff, buffer.count(), EP_CHAR, sndServerGlobalRanks[i], 1, CXios::globalComm) ; 
     844           ep_lib::MPI_Comm_dup(*it, &inter); 
    833845           contextInterComms.push_back(inter); 
    834            MPI_Comm_dup(intraComm, &inter); 
     846           ep_lib::MPI_Comm_dup(intraComm, &inter); 
    835847           contextIntraComms.push_back(inter); 
    836848           context->initClient(contextIntraComms.back(), contextInterComms.back()) ; 
     
    862874     { 
    863875       int rank; 
    864        MPI_Comm_rank(intraComm,&rank); 
     876       ep_lib::MPI_Comm_rank(intraComm,&rank); 
    865877       return rank; 
    866878     } 
     
    885897      int size = 0; 
    886898      int id; 
    887       MPI_Comm_size(CXios::globalComm, &size); 
     899      ep_lib::MPI_Comm_size(CXios::globalComm, &size); 
    888900      while (size) 
    889901      { 
  • XIOS/trunk/src/server.hpp

    r1587 r1638  
    2626        static void registerContext(void* buff,int count, int leaderRank=0); 
    2727 
    28         static MPI_Comm intraComm; 
    29         static std::list<MPI_Comm> interCommLeft;           // interComm between server (primary, classical or secondary) and its client (client or primary server) 
    30         static std::list<MPI_Comm> interCommRight;          // interComm between primary server and secondary server (non-empty only for primary server pool) 
    31         static std::list<MPI_Comm> contextInterComms;  // list of context intercomms 
    32         static std::list<MPI_Comm> contextIntraComms;  // list of context intercomms (needed only in case of secondary servers) 
     28        static ep_lib::MPI_Comm intraComm; 
     29        static std::list<ep_lib::MPI_Comm> interCommLeft;           // interComm between server (primary, classical or secondary) and its client (client or primary server) 
     30        static std::list<ep_lib::MPI_Comm> interCommRight;          // interComm between primary server and secondary server (non-empty only for primary server pool) 
     31        static std::list<ep_lib::MPI_Comm> contextInterComms;  // list of context intercomms 
     32        static std::list<ep_lib::MPI_Comm> contextIntraComms;  // list of context intercomms (needed only in case of secondary servers) 
    3333        static CEventScheduler* eventScheduler; 
    3434 
  • XIOS/trunk/src/timer.cpp

    r1158 r1638  
    11#include "timer.hpp" 
     2//#include "mpi_std.hpp" 
    23#include "mpi.hpp" 
    34#include <string> 
     
    67#include <sstream> 
    78#include "tracer.hpp" 
     9//extern ::MPI_Comm MPI_COMM_WORLD; 
    810 
    911namespace xios 
     
    1820  double CTimer::getTime(void) 
    1921  { 
     22    MPI_COMM_WORLD; 
    2023    return MPI_Wtime(); 
    2124  } 
  • XIOS/trunk/src/tracer.cpp

    r501 r1638  
    11#include "tracer.hpp" 
    22#ifdef VTRACE 
    3 #include <vt_user.h> 
     3//#include <vt_user.h> 
     4#include <VT.h> 
    45#endif 
    56#include <string> 
     
    1213  { 
    1314#ifdef VTRACE 
    14     VT_ON() ; 
     15    //VT_ON() ; 
     16    VT_traceon() ; 
    1517#endif 
    1618  } 
     
    1921  { 
    2022#ifdef VTRACE 
    21     VT_OFF() ; 
     23    //VT_OFF() ; 
     24    VT_traceoff() ; 
    2225#endif 
    2326  } 
     
    2629  { 
    2730#ifdef VTRACE 
    28     VT_USER_START(name.c_str()) ; 
     31    //VT_USER_START(name.c_str()) ; 
    2932#endif 
    3033  } 
     
    3336  { 
    3437#ifdef VTRACE 
    35     VT_USER_END(name.c_str()) ; 
     38    //VT_USER_END(name.c_str()) ; 
    3639#endif 
    3740  } 
  • XIOS/trunk/src/transformation/axis_algorithm_interpolate.cpp

    r1622 r1638  
    272272 
    273273    int* recvCount=new int[nbClient]; 
    274     MPI_Allgather(&numValue,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm); 
     274    ep_lib::MPI_Allgather(&numValue,1,EP_INT,recvCount,1,EP_INT,client->intraComm); 
    275275 
    276276    int* displ=new int[nbClient]; 
     
    279279 
    280280    // Each client have enough global info of axis 
    281     MPI_Allgatherv(sendIndexBuff,numValue,MPI_INT,recvIndexBuff,recvCount,displ,MPI_INT,client->intraComm); 
    282     MPI_Allgatherv(sendValueBuff,numValue,MPI_DOUBLE,&(recvBuff[0]),recvCount,displ,MPI_DOUBLE,client->intraComm); 
     281    ep_lib::MPI_Allgatherv(sendIndexBuff,numValue,EP_INT,recvIndexBuff,recvCount,displ,EP_INT,client->intraComm); 
     282    ep_lib::MPI_Allgatherv(sendValueBuff,numValue,EP_DOUBLE,&(recvBuff[0]),recvCount,displ,EP_DOUBLE,client->intraComm); 
    283283 
    284284    for (int idx = 0; idx < srcSize; ++idx) 
  • XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp

    r1622 r1638  
    161161    sendRankSizeMap[itIndex->first] = sendSize; 
    162162  } 
    163   MPI_Allgather(&connectedClient,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm); 
     163  ep_lib::MPI_Allgather(&connectedClient,1,EP_INT,recvCount,1,EP_INT,client->intraComm); 
    164164 
    165165  displ[0]=0 ; 
     
    168168  int* recvRankBuff=new int[recvSize]; 
    169169  int* recvSizeBuff=new int[recvSize]; 
    170   MPI_Allgatherv(sendRankBuff,connectedClient,MPI_INT,recvRankBuff,recvCount,displ,MPI_INT,client->intraComm); 
    171   MPI_Allgatherv(sendSizeBuff,connectedClient,MPI_INT,recvSizeBuff,recvCount,displ,MPI_INT,client->intraComm); 
     170  ep_lib::MPI_Allgatherv(sendRankBuff,connectedClient,EP_INT,recvRankBuff,recvCount,displ,EP_INT,client->intraComm); 
     171  ep_lib::MPI_Allgatherv(sendSizeBuff,connectedClient,EP_INT,recvSizeBuff,recvCount,displ,EP_INT,client->intraComm); 
    172172  for (int i = 0; i < nbClient; ++i) 
    173173  { 
     
    181181 
    182182  // Sending global index of grid source to corresponding process as well as the corresponding mask 
    183   std::vector<MPI_Request> requests; 
    184   std::vector<MPI_Status> status; 
     183  std::vector<e